String message = "Localized error message";
        DataStoreException exception = new DataStoreException(message);

        // By default, getLocalizedMessage returns the same as getMessage
        assertEquals(message, exception.getLocalizedMessage());
    }

    @Test
    public void test_toString() {
        // Test toString method
        String message = "Test exception";

        JobProcess jobProcess = new JobProcess(mockProcess);

        Process assignedProcess = jobProcess.getProcess();

        assertSame(mockProcess, assignedProcess, "Process should be exactly the same instance");
    }

    private Process createMockProcess(String output) {
        return new MockProcess(output);
    }

    private static class MockProcess extends Process {

    this.collector = checkNotNull(collector);
    this.equivalence = checkNotNull(equivalence);
  }

  /**
   * Different orderings for combining the elements of an input array, which must all produce the
   * same result.
   */
  enum CollectStrategy {
    /** Get one accumulator and accumulate the elements into it sequentially. */
    SEQUENTIAL {
      @Override

  }

  public final void testEnterWhen_initiallyTrue() throws Exception {
    TestGuard guard = new TestGuard(true);
    thread1.callAndAssertReturns(enterWhen(), guard);
    // same as above but with the new syntax
    thread1.callAndAssertReturns(enterWhen(), monitor.newGuard(() -> true));
  }

  public final void testEnterWhen_initiallyFalse() throws Exception {

 *
 * <h3>Cancelling</h3>
 *
 * Any step in a pipeline can be {@linkplain #cancel(boolean) cancelled}, even after another step
 * has been derived, with the same semantics as cancelling a {@link Future}. In addition, a
 * successfully cancelled step will immediately start closing all objects captured for later closing
 * by it and by its input steps.
 *
 * <h3>Ending a pipeline</h3>

        final String jwtClaim = "{\"sub\":\"user123\",\"name\":\"John Doe\",\"email\":\"******@****.***\"}";
        final Map<String, Object> attributes = new HashMap<>();

        authenticator.parseJwtClaim(jwtClaim, attributes);

        assertEquals("user123", attributes.get("sub"));
        assertEquals("John Doe", attributes.get("name"));
        assertEquals("******@****.***", attributes.get("email"));
    }

      cachedHeaders: Headers,
      networkHeaders: Headers,
    ): Headers {
      val result = Headers.Builder()

      for (index in 0 until cachedHeaders.size) {
        val fieldName = cachedHeaders.name(index)
        val value = cachedHeaders.value(index)
        if ("Warning".equals(fieldName, ignoreCase = true) && value.startsWith("1")) {
          // Drop 100-level freshness warnings.
          continue
        }

        String arg0 = "plugin-name";
        FessMessages result = messages.addSuccessInstallPlugin(property, arg0);
        assertNotNull(result);
        assertSame(messages, result);
        assertTrue(messages.hasMessageOf(property));
    }

    @Test
    public void test_addSuccessDeletePlugin() {
        String property = "testProperty";
        String arg0 = "plugin-name";

  private static File file(File first, String... more) {
    // not very efficient, but should definitely be correct
    File file = first;
    for (String name : more) {
      file = new File(file, name);
    }
    return file;
  }

   * expression {@code o -> Optional.toJavaUtil(o)} instead.
   *
   * @since 33.4.0 (but since 21.0 in the JRE flavor)
   */
  @SuppressWarnings({
    "AmbiguousMethodReference", // We chose the name despite knowing this risk.
    "NullableOptional", // Null passthrough is reasonable for type conversions
  })
  // If users use this when they shouldn't, we hope that NewApi will catch subsequent Optional calls