if l > len(b) {
		return nil, 0, errors.New("zip: invalid comment length")
	}
	d.comment = string(b[:l])

	// These values mean that the file can be a zip64 file
	if d.directoryRecords == 0xffff || d.directorySize == 0xffff || d.directoryOffset == 0xffffffff {
		p, err := findDirectory64End(r, directoryEndOffset)
		if err == nil && p >= 0 {
			directoryEndOffset = p
			err = readDirectory64End(r, p, d)
		}

        }

        @Test
        @DisplayName("Should handle ciphers with maximum value")
        void testMaximumCipherValues() throws SMBProtocolDecodingException {
            int[] ciphers = { 0xFFFF, 0x0000, 0x7FFF };
            EncryptionNegotiateContext originalContext = new EncryptionNegotiateContext(mockConfig, ciphers);

            int encoded = originalContext.encode(buffer, 0);

                Arguments.of((IntGetter) FileEntry::getAttributes, 0, "no attributes"),
                Arguments.of((IntGetter) FileEntry::getAttributes, 0xFFFF, "many attributes"),

                Arguments.of((IntGetter) FileEntry::getFileIndex, -5, "negative index"),
                Arguments.of((IntGetter) FileEntry::getFileIndex, 0, "zero index"));
    }

        String str = info.toString();
        assertTrue(str.contains(specialName));
        assertTrue(str.contains(specialRemark));
    }

    @Test
    @DisplayName("Test type masking with 0xFFFF")
    void testTypeMasking() {
        // Test that only lower 16 bits are considered for type determination
        int typeWithUpperBits = 0xFFFF0001; // Should be treated as type 1 (printer)

        tmp = new byte[TMP_BUFFER_SIZE];
    }

    @Override
    public synchronized int read() throws IOException {
        if (read(tmp, 0, 1) < 0) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    @Override
    public synchronized int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /* This method will not return until len bytes have been read

)

type exprTest struct {
	input  string
	output int64
	atEOF  bool
}

var exprTests = []exprTest{
	// Simple
	{"0", 0, true},
	{"3", 3, true},
	{"070", 8 * 7, true},
	{"0x0f", 15, true},
	{"0xFF", 255, true},
	{"9223372036854775807", 9223372036854775807, true}, // max int64
	// Unary
	{"-0", 0, true},
	{"~0", -1, true},
	{"~0*0", 0, true},
	{"+3", 3, true},
	{"-3", -3, true},

            jcifs.internal.smb1.com.SmbComReadAndX req = cap.getValue();
            assertEquals(0x12345 & 0xFFFF, req.getMaxCount(), "maxCount should contain lower 16 bits");
            assertEquals(0x12345, req.getMinCount(), "minCount should remain original full value");
        }

        @Test

       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")
            }
            b and 0x80 == 0x80 -> {
              // 1NNNNNNN

      } else {
        encodedCharBuffer.writeString(input, i, i + Character.charCount(codePoint), charset)
      }

      while (!encodedCharBuffer.exhausted()) {
        val b = encodedCharBuffer.readByte().toInt() and 0xff
        writeByte('%'.code)
        writeByte(HEX_DIGITS[b shr 4 and 0xf].code)
        writeByte(HEX_DIGITS[b and 0xf].code)
      }
    } else {
      // This character doesn't need encoding. Just copy it over.

      }
    }
  }

  @Benchmark
  int meanAndVariance(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      tmp += varianceAlgorithm.variance(values[i & 0xFF], meanAlgorithm).hashCode();
    }
    return tmp;
  }