assertEquals("TestAgent", fessConfig.getUserAgentName());
    }

    private void assertArrays(final String[] expected, final String[] actual) {
        Arrays.sort(expected);
        Arrays.sort(actual);
        assertEquals(String.join(",", expected), String.join(",", actual));
    }

            }
            finally {
                f.delete();
            }
        }

    }


    @Test ( expected = ConnectionTimeoutException.class )
    public void testConnectTimeoutRead () throws IOException {
        Set<Thread> threadsBefore = new HashSet<>(Thread.getAllStackTraces().keySet());

  }

  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 {

var ErrInvalidChecksum = errors.New("invalid checksum")

// SetExpectedMin set expected minimum data expected from reader
func (r *Reader) SetExpectedMin(expectedMin int64) {
	r.expectedMin = expectedMin
}

// SetExpectedMax set expected max data expected from reader
func (r *Reader) SetExpectedMax(expectedMax int64) {
	r.expectedMax = expectedMax
}

    CacheBuilder<?, ?> expected =
        CacheBuilder.newBuilder()
            .initialCapacity(10)
            .maximumSize(20)
            .concurrencyLevel(30)
            .weakKeys()
            .weakValues()
            .expireAfterAccess(10L, MINUTES)
            .expireAfterWrite(1L, HOURS);
    assertCacheBuilderEquivalence(expected, CacheBuilder.from(spec));
  }

    ValueAndCloser<?> valueAndCloser = finishToValueAndCloser(closingFuture);
    try {
      valueAndCloser.get();
      fail();
    } catch (ExecutionException expected) {
      assertThat(expected).hasCauseThat().isSameInstanceAs(exception);
    }
    valueAndCloser.closeAsync();
  }

  @Override
  void assertBecomesCanceled(ClosingFuture<?> closingFuture) throws ExecutionException {

    return new LinkedHashMultiset<>();
  }

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *
   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */

public interface ModelLocator {

    /**
     * Locates the POM file within the specified project directory. In case the given project directory does not exist
     * or does not contain a POM file, the return value indicates the expected path to the POM file. Subdirectories of
     * the project directory will not be considered when locating the POM file. The return value will be an absolute
     * path if the project directory is given as an absolute path.
     *

		},
		{
			revision:       "canary",
			version:        "XX",
			expectedOutput: nil,
			expectedError:  fmt.Errorf("invalid version XX, expected format like '1.0'"),
		},
		{
			revision:       "canary",
			version:        "2.0",
			expectedOutput: nil,
			expectedError:  fmt.Errorf("expected major version 1, got 2"),
		},
		{
			revision:       "canary",
			version:        "2.",
			expectedOutput: nil,

      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());