override fun close() = source().closeQuietly()

  internal class BomAwareReader(
    private val source: BufferedSource,
    private val charset: Charset,
  ) : Reader() {
    private var closed: Boolean = false
    private var delegate: Reader? = null

    @Throws(IOException::class)
    override fun read(
      cbuf: CharArray,
      off: Int,
      len: Int,
    ): Int {

   * resources are released and all following calls to [.newSource] return null. Guarded by this.
   */
  var sourceCount = 0

  val isClosed: Boolean
    get() = file == null

  @Throws(IOException::class)
  private fun writeHeader(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Long,
  ) {
    val header =
      Buffer().apply {

      fail();
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().isSameInstanceAs(expectedException);
    }
  }

  private static void assertCancelled(AbstractFuture<Integer> future, boolean expectWasInterrupted)
      throws InterruptedException, TimeoutException, ExecutionException {
    assertDone(future);
    assertThat(future.isCancelled()).isTrue();

        }

        final byte[] targetInfo = readSecurityBuffer(input, pos);
        if (targetInfo.length != 0) {
            setTargetInformation(targetInfo);
        }
    }

    private static boolean allZeros8(final byte[] input, final int pos) {
        for (int i = pos; i < pos + 8; i++) {
            if (input[i] != 0) {
                return false;
            }
        }
        return true;
    }

        assertFalse(status.equals(nullStatus));

        // null == Enum should be false
        assertFalse(nullStatus == status);

        // Verify no NullPointerException when comparing with ==
        boolean result = (nullStatus == CrawlerStatus.INITIALIZING);
        assertFalse(result);
    }

    /**
     * Test thread safety of enum
     */
    public void test_threadSafety() throws Exception {

     * @param decrementAuthority whether to decrement the authority count
     */
    public SID(final rpc.sid_t sid, final int type, final String domainName, final String acctName, final boolean decrementAuthority) {
        this.revision = sid.revision;
        this.sub_authority_count = sid.sub_authority_count;
        this.identifier_authority = sid.identifier_authority;

    // Helper to build a SPNEGO NegTokenInit as per NegTokenInit#toByteArray but parameterized for tests
    private static byte[] buildInitToken(ASN1ObjectIdentifier[] mechs, Integer flags, byte[] mechToken, byte[] mic, boolean micInTag4,
            String spnegoOidOverride, Integer outerTagNoOverride, ASN1TaggedObject extraField) throws IOException {

        ASN1EncodableVector fields = new ASN1EncodableVector();
        if (mechs != null) {

    public void test_insert() {
        loadTestData();

        StopwordsItem newItem = new StopwordsItem(0, "test");
        stopwordsFile.insert(newItem);

        // Verify the item was added
        boolean found = false;
        for (StopwordsItem item : stopwordsFile.stopwordsItemList) {
            if ("test".equals(item.getInput())) {
                found = true;
                break;
            }
        }

     *
     * @param size the message size
     * @param isSmb1 whether this is SMB1 protocol
     * @throws SmbException if size is invalid
     */
    public void validateMessageSize(int size, boolean isSmb1) throws SmbException {
        totalValidations.incrementAndGet();

        if (size < MIN_SMB_HEADER_SIZE) {
            failedValidations.incrementAndGet();

func IsARM64CASP(op obj.As) bool {
	switch op {
	case arm64.ACASPD, arm64.ACASPW:
		return true
	}
	return false
}

// ARM64Suffix handles the special suffix for the ARM64.
// It returns a boolean to indicate success; failure means
// cond was unrecognized.
func ARM64Suffix(prog *obj.Prog, cond string) bool {
	if cond == "" {
		return true
	}
	bits, ok := parseARM64Suffix(cond)
	if !ok {