outputStream = new SmbFileOutputStream(mockFile);

        // Then
        assertNotNull(outputStream);

        // Verify the AutoCloseable resources were closed
        verify(autoCloseableMockTreeHandle).close();
        verify(autoCloseableMockFileHandle).close();
    }

    @Test
    void testConstructorWithAppendFlag() throws IOException, CIFSException {
        // Given

    public int available() throws IOException {
        if (bip > 0) {
            return bip;
        }
        return in.available();
    }

    @Override
    public void close() throws IOException {
        in.close();
    }

          }
        }
      }

      assertThat(call.canceled).isTrue()
      assertThat(call.responseClosed).isTrue()
    }
  }

  /** A call that keeps track of whether its response body is closed. */
  private class ClosableCall : FailingCall() {
    private val response =
      Response
        .Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)

	}
	pdb.Mux.Unlock()

	pdb.Close()
	pdb.Mux.Lock()
	defer pdb.Mux.Unlock()
	if len(pdb.Stmts.Keys()) != 0 {
		t.Fatalf("prepared stmt should be empty")
	}
}

func isUsingClosedConnError(err error) bool {
	// https://github.com/golang/go/blob/e705a2d16e4ece77e08e80c168382cdb02890f5b/src/database/sql/sql.go#L2717
	return err.Error() == "sql: statement is closed"
}

    }
  }

  /**
   * Closes this connection. This cancels all open streams and unanswered pings. It closes the
   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,

    private final String fileName;
    private int closeFlags;

    /**
     * Constructs a close request with file ID and name
     *
     * @param config
     *            The configuration to use
     * @param fileId
     *            The file ID to close
     * @param fileName
     *            The name of the file being closed
     */

   *
   * Will only be invoked for requests having a response body e.g. won't be invoked for a web socket
   * upgrade.
   *
   * If the response body is closed before the response body is exhausted, this is invoked at the
   * time it is closed. In such calls [byteCount] is the number of bytes returned to the
   * application. This may be smaller than the resource's byte count if were read to completion.
   *

@NullUnmarked
public class QuantilesBenchmark {

  private static final ContiguousSet<Integer> ALL_DECILE_INDEXES =
      ContiguousSet.create(Range.closed(0, 10), DiscreteDomain.integers());

  @Param({"10", "100", "1000", "10000", "100000"})
  int datasetSize;

  @Param QuantilesAlgorithm algorithm;

  private final double[][] datasets = new double[0x100][];

        }
    }

    private
    fun openJarFile(file: File) =
        openJars.computeIfAbsent(file, ::JarFile)

    override fun close() {
        openJars.values.forEach(JarFile::close)
    }
}


/**
 * See https://docs.oracle.com/javase/8/docs/technotes/tools/findingclasses.html#userclass
 */
private
val File.isClassPathArchive

    assertEquals(map, Maps.subMap(map, Range.closed(0, 12)));
    assertEquals(ImmutableSortedMap.of(2, 0, 4, 0), Maps.subMap(map, Range.closed(0, 4)));
    assertEquals(ImmutableSortedMap.of(2, 0, 4, 0, 6, 0), Maps.subMap(map, Range.closed(2, 6)));
    assertEquals(ImmutableSortedMap.of(4, 0, 6, 0), Maps.subMap(map, Range.closed(3, 7)));
    assertEquals(empty, Maps.subMap(map, Range.closed(20, 30)));