public void testGetRootCause_noCause() {
    SomeCheckedException exception = new SomeCheckedException();
    assertSame(exception, getRootCause(exception));
  }

  public void testGetRootCause_singleWrapped() {
    SomeCheckedException cause = new SomeCheckedException();
    SomeChainingException exception = new SomeChainingException(cause);
    assertSame(cause, getRootCause(exception));
  }

     *
     * @param checker the credential checker to use
     * @throws UnsupportedOperationException always thrown as this method is not supported
     */
    @Override
    protected void checkCredential(final TypicalLoginAssist<String, FessUserBean, FessUser>.CredentialChecker checker) {
        throw new UnsupportedOperationException("checkCredential is not supported.");
    }

    /**

        return files;
    }

    /**
     * Update directory cache with new listing
     *
     * @param directoryPath directory path
     * @param files list of files in directory
     */
    public void updateDirectoryCache(String directoryPath, List<SmbFile> files) {
        DirectoryCacheEntry entry = getCacheEntry(directoryPath);
        if (entry == null)
            return;

     *
     * @param officeManager the office manager to set
     */
    public void setOfficeManager(final OfficeManager officeManager) {
        this.officeManager = officeManager;
    }

    /**
     * Sets the temporary directory for file operations.
     *
     * @param tempDir the temporary directory to set
     */
    public void setTempDir(final File tempDir) {
        this.tempDir = tempDir;
    }

        return null;
    }

    @Override
    protected void testRead() {
        final Map<String, Object> searchBody = new HashMap<>();
        final String response = checkMethodBase(searchBody).get(API_PATH + "/" + LIST_ENDPOINT_SUFFIX).asString();
        assertEquals(Integer.valueOf(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test

public class QueueOfferTester<E> extends AbstractQueueTester<E> {
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testOffer_supportedNotPresent() {
    assertTrue("offer(notPresent) should return true", getQueue().offer(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require({SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  public void testOffer_nullSupported() {
    assertTrue("offer(null) should return true", getQueue().offer(null));

     * @throws RuntimeException If PUT fails for any reason.
     */
    void put(@Nonnull Path source, @Nonnull URI relativeTarget);

    /**
     * PUTs the source byte array to target URI. The target MUST BE relative from the
     * {@link RemoteRepository#getUrl()} root.
     *
     * @throws RuntimeException If PUT fails for any reason.
     */
    void putBytes(@Nonnull byte[] source, @Nonnull URI relativeTarget);

    /**

    }
  }

  public void testConverterDefaultValue() {
    new ConverterDefaultValueChecker().check();
  }

  private static class VisibilityMethods {

    private void privateMethod() {}

    void packagePrivateMethod() {}

    @Keep
    protected void protectedMethod() {}

    @Keep
    public void publicMethod() {}
  }

    assertThat(LOWER_UNDERSCORE.to(LOWER_CAMEL, "foo")).isEqualTo("foo");
    assertThat(LOWER_UNDERSCORE.to(LOWER_CAMEL, "foo_bar")).isEqualTo("fooBar");
  }

  public void testLowerUnderscoreToUpperCamel() {
    assertThat(LOWER_UNDERSCORE.to(UPPER_CAMEL, "foo")).isEqualTo("Foo");
    assertThat(LOWER_UNDERSCORE.to(UPPER_CAMEL, "foo_bar")).isEqualTo("FooBar");
  }

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setName_Terms() {
        setName_Terms(null);
    }

    public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setName_Terms("name", opLambda, null);
    }

    public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {