this.path = path;
        this.service = service;
        command = SMB_COM_TREE_CONNECT_ANDX;
    }

    @Override
    int getBatchLimit(final byte command) {
        final int c = command & 0xFF;
        // why isn't this just return batchLimits[c]?
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return batchLimits[0];
        case SMB_COM_CREATE_DIRECTORY:
            return batchLimits[2];

        h1 = mixH1(h1, mixK1((int) buffer));
        buffer >>>= 32;
        shift -= 32;
      }
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putByte(byte b) {
      update(1, b & 0xFF);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putBytes(byte[] bytes, int off, int len) {
      checkPositionIndexes(off, off + len, bytes.length);
      int i;

    void testDifferentFileIds() {
        // Given
        byte[] fileId1 = new byte[16];
        Arrays.fill(fileId1, (byte) 0x11);

        byte[] fileId2 = new byte[16];
        Arrays.fill(fileId2, (byte) 0xFF);

        byte[] fileId3 = new byte[16];
        for (int i = 0; i < 16; i++) {
            fileId3[i] = (byte) i;
        }

        // When & Then for each file ID
        testFileIdWriting(fileId1);

        bufferIndex += 2;
        this.deviceState = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        return bufferIndex - start;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override

        this.server = server;
        this.path = path;
        this.service = service;
    }

    @Override
    protected int getBatchLimit(final Configuration cfg, final byte cmd) {
        final int c = cmd & 0xFF;
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return cfg.getBatchLimit("TreeConnectAndX.CheckDirectory");
        case SMB_COM_CREATE_DIRECTORY:

                log.println("session established ok with " + address);
            }
            return;
        case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
            final int errorCode = in.read() & 0xFF;
            close();
            throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
        case -1:
            throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);

                    break;
                case ServerMessageBlock.SMB_COM_TRANSACTION:
                case ServerMessageBlock.SMB_COM_TRANSACTION2:
                    switch (((SmbComTransaction) request).subCommand & 0xFF) {
                    case SmbComTransaction.NET_SHARE_ENUM:
                    case SmbComTransaction.NET_SERVER_ENUM2:
                    case SmbComTransaction.NET_SERVER_ENUM3:

        assertEquals(0x123, buf.dec_ndr_long()); // call_id
    }

    @Test
    void testEncodeWithDifferentFlags() throws Exception {
        for (int flag : new int[] { 0, 0xFF, 0x01, 0x80 }) {
            TestMessage m = new TestMessage();
            m.ptype = 0;
            m.flags = flag;

            NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
            m.encode(buf);

		{"a/b/c/", []int{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1, 2}},
		{"/a/b/c", []int{6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5}},
		{string([]byte{0xff, 0xfe, 0xfd}), []int{15, 16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}},
	}

	// Tests hashing order to be consistent.
	for i, testCase := range testCases {
		hashedOrder := hashOrder(testCase.objectName, 16)

            switch (this.sbuf[0] & 0xFF) {
            case SessionServicePacket.POSITIVE_SESSION_RESPONSE:
                if (log.isDebugEnabled()) {
                    log.debug("session established ok with " + this.address);
                }
                return;
            case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
                final int errorCode = this.in.read() & 0xFF;
                switch (errorCode) {