<!--- Provide a general summary of the issue in the Title above -->

## Expected Behavior
<!--- If you're describing a bug, tell us what should happen -->
<!--- If you're suggesting a change/improvement, tell us how it should work -->

## Current Behavior
<!--- If describing a bug, tell us what happens instead of the expected behavior -->
<!--- If suggesting a change/improvement, explain the difference from current behavior -->

          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    assertFailsWith<IOException> {
      response.body.string()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("unexpected end of stream")
    }
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",

            pb.redirectErrorStream(true);
        };

        try {
            processHelper.startProcess(sessionId, cmdList, pbCall);
            fail("Expected exception for empty command list");
        } catch (Exception e) {
            // Expected - empty command list should cause exception
            assertTrue(e instanceof JobProcessingException || e instanceof IndexOutOfBoundsException);
        }
    }

            byte[] buf = new byte[0x30000];
            try {
                in.readDirect(buf, 0, 0x12345);
                fail("Expected IOException due to short-circuit");
            } catch (IOException expected) {
                // expected
            }

            // Assert captured request parameters

    String msg = "Alphanumeric characters are always 'safe' and should not be explicitly specified";
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> new PercentEscaper("-+#abc.!", false));
    assertThat(expected).hasMessageThat().isEqualTo(msg);
  }

  public void testBadArguments_plusforspace() {
    // space can be a safe char if plusForSpace is false

    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    assertTrue("add(nullPresent) should return true", getList().add(null));

    List<E> expected = copyToList(array);
    expected.add(null);
    expectContents(expected);
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_supportedNullPresent()} so that tests

			if err != nil {
				gotErr := err.(BatchJobYamlErr)
				testErr := test.err.(BatchJobYamlErr)
				if gotErr.message() != testErr.message() {
					t.Fatalf("Expected %v but got %v", test.err, err)
				}
			}
			if err == nil && test.err != nil {
				t.Fatalf("Expected %v but got nil", test.err)
			}
		})
	}

    assertArrayEquals("toArray(largeEnough) order should match list", createOrderedArray(), actual);
  }

  private static void assertArrayEquals(String message, Object[] expected, Object[] actual) {
    assertEquals(message, asList(expected), asList(actual));
  }

		if _, ok := diskFailures[diskIndex]; ok {
			if !partNeedsHealing(dataErrsPerDisk[diskIndex]) {
				t.Errorf("Disk expected to be healed, driveIndex: %d", diskIndex)
			}
		} else {
			if partNeedsHealing(dataErrsPerDisk[diskIndex]) {
				t.Errorf("Disk not expected to be healed, driveIndex: %d", diskIndex)
			}
		}
	}
}

func TestCommonParities(t *testing.T) {

    @DisplayName("shouldForceSigning returns stubbed boolean value")
    void shouldForceSigningReturns(boolean expected) {
        when(locator.shouldForceSigning()).thenReturn(expected);

        boolean result = locator.shouldForceSigning();

        assertEquals(expected, result);
        verify(locator, times(1)).shouldForceSigning();
        verifyNoMoreInteractions(locator);
    }