if (i > 0) {
                    signature.append(", ");
                }
                signature.append(methodDoc.getMetaData().getParameters().get(i).getName());
            }
            signature.append(")");
            literal.appendChild(document.createTextNode(signature.toString()));

            td = document.createElement("td");
            tr.appendChild(td);

    fun addProjectToEnableNullawayIn(projectPath: String) {
        ensureProjectNotSeen(projectPath)

        projectsToEnableNullaway.add(projectPath)
    }

    private val seenProjectsCount: Int
        get() = projectsWithNullAwayEnabled.size + projectsWithUncheckedDeps.size + projectsToEnableNullaway.size

    override fun close() {
        require(seenProjectsCount > 0) {

            log.debug("Closing SmbTreeConnection via AutoCloseable.close()");
        }
        release();
    }

    protected void checkRelease() {
        if (isConnected() && this.usageCount.get() != 0) {
            log.warn("Tree connection was not properly released " + this);
        }
    }

    synchronized void disconnect(final boolean inError) {
        try (SmbSessionImpl session = getSession()) {

   *
   * <p>For example, when resolving {@code List<T>} in the context of {@code ArrayList<?>}, {@code
   * <T>} is covariantly resolved to {@code <?>} such that return type of {@code List::get} is
   * {@code <?>}.
   */
  static TypeResolver covariantly(Type contextType) {
    return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(contextType));
  }

  /**

          .withCertificateChainCleaner(certificateChainCleaner)
    } else {
      this.x509TrustManager = Platform.get().platformTrustManager()
      this.sslSocketFactoryOrNull = Platform.get().newSslSocketFactory(x509TrustManager)
      this.certificateChainCleaner = CertificateChainCleaner.get(x509TrustManager)
      this.certificatePinner =
        builder.certificatePinner

    @DisplayName("Getter Tests")
    class GetterTests {

        @Test
        @DisplayName("Should get chunksWritten value")
        void testGetChunksWritten() {
            // Initial value should be 0
            assertEquals(0, response.getChunksWritten());
        }

        @Test
        @DisplayName("Should get chunkBytesWritten value")
        void testGetChunkBytesWritten() {
            // Initial value should be 0

        try {
            final RESULT result = entityType.newInstance();
            result.setName(DfTypeUtil.toString(source.get("name")));
            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))

            final FileConfigService fileConfigService = ComponentUtil.getComponent(FileConfigService.class);
            try {
                fileConfig = fileConfigService.getFileConfig(getFileConfigId()).get();
            } catch (final Exception e) {
                logger.warn("File Config {} does not exist.", getFileConfigId(), e);
            }
        }
        return fileConfig;
    }

    @Override

 * that it is not "API-frozen."
 *
 * <p>It is generally safe for <i>applications</i> to depend on beta APIs, at the cost of some extra
 * work during upgrades. However it is generally inadvisable for <i>libraries</i> (which get
 * included on users' CLASSPATHs, outside the library developers' control) to do so.
 *
 * @author Kevin Bourrillion
 */
@Retention(RetentionPolicy.CLASS)
@Target({
  ElementType.ANNOTATION_TYPE,

 * that it is not "API-frozen."
 *
 * <p>It is generally safe for <i>applications</i> to depend on beta APIs, at the cost of some extra
 * work during upgrades. However it is generally inadvisable for <i>libraries</i> (which get
 * included on users' CLASSPATHs, outside the library developers' control) to do so.
 *
 * @author Kevin Bourrillion
 */
@Retention(RetentionPolicy.CLASS)
@Target({
  ElementType.ANNOTATION_TYPE,