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)
			}
		})
	}

        try {
          encoding.decode(cannotDecode);
          fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException expected) {
          if (expectedMessage != null) {
            assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo(expectedMessage);
          }
        }
      }
    },
    DECODE_CHECKED {

		t.Run(testCase.timeStr, func(t *testing.T) {
			gott, goterr := Parse(testCase.timeStr)
			if !errors.Is(goterr, testCase.expectedErr) {
				t.Errorf("expected %v, got %v", testCase.expectedErr, goterr)
			}
			if !gott.Equal(testCase.expectedTime) {
				t.Errorf("expected %v, got %v", testCase.expectedTime, gott)
			}
		})
	}

            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

        final TextExtractor extractor = container.getComponent("textExtractor");

        try {
            extractor.getText(null, null);
            fail("Expected CrawlerSystemException");
        } catch (final CrawlerSystemException e) {
            assertEquals("The inputstream is null.", e.getMessage());
        }
    }

    /**

      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());

    @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);
    }

  }

  public void testFailed() {
    Exception failureCause = new Exception();
    ExecutionException expected =
        assertThrows(ExecutionException.class, () -> getDone(immediateFailedFuture(failureCause)));
    assertThat(expected).hasCauseThat().isEqualTo(failureCause);
  }

  public void testCancelled() throws ExecutionException {

            new ICUNormalizer(null);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertEquals("transliteratorId must not be null", e.getMessage());
        }
    }

    public void test_invalidTransliteratorId() {
        try {
            new ICUNormalizer("Invalid-Transliterator-ID-12345");
            fail("Expected IllegalArgumentException");

		if gotErr != testCase.err {
			t.Errorf("Test %d : expected %s, got %s", i+1, testCase.err, gotErr)
		}
		gotNewErr := reduceWriteQuorumErrs(t.Context(), testCase.errs, testCase.ignoredErrs, 6)
		if gotNewErr != errErasureWriteQuorum {
			t.Errorf("Test %d : expected %s, got %s", i+1, errErasureWriteQuorum, gotErr)
		}
	}
}

// TestHashOrder - test order of ints in array