Name sourceName = new Name(mockConfig, "SourceName", 0x1C, "source.scope");
        sourceName.srcHashCode = 12345;

        Name name = new Name(mockConfig, sourceName);

        assertEquals("SOURCENAME", name.name);
        assertEquals(0x1C, name.hexCode);
        assertEquals("source.scope", name.scope);
        assertEquals(12345, name.srcHashCode);
    }

    @Test
    void getName_shouldReturnName() {

            b[off + 1] = 0x34;
            return 2;
        }).when(raf).read(any(byte[].class), anyInt(), eq(2));
        assertEquals(0x1234, raf.readUnsignedShort());
        assertEquals((short) 0x1234, raf.readShort());
        assertEquals((char) 0x1234, raf.readChar());
    }

    @Test
    @DisplayName("readInt/Long/Float/Double: big-endian decoding")
    void read_multiByteVariants() throws Exception {

        int decodedValue = 0;

        TestMessage() {
            /* nothing */
        }

        @Override
        public int getOpnum() {
            return 0x1234;
        }

        @Override
        public void encode_in(NdrBuffer buf) throws NdrException {
            buf.enc_ndr_small(0xAB);
        }

        @Override

        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        // set fields via reflection
        setField(cmd, "fid", 0x1234);
        setField(cmd, "typeOfLock", (byte) 0x05);
        setField(cmd, "newOpLockLevel", (byte) 0x01);
        setField(cmd, "timeout", 3000L);
        // arrays of one lock and one unlock range

    ByteArrayDataInput in = ByteStreams.newDataInput(data);
    assertEquals(0, in.readUnsignedShort());
    assertEquals(1, in.readUnsignedShort());
    assertEquals(65535, in.readUnsignedShort());
    assertEquals(0x1234, in.readUnsignedShort());
  }

  public void testNewDataInput_readLong() {
    byte[] data = {0x12, 0x34, 0x56, 0x78, 0x76, 0x54, 0x32, 0x10};
    ByteArrayDataInput in = ByteStreams.newDataInput(data);

        @DisplayName("Should return tree ID")
        void testGetTid() {
            // Given
            when(mockResponse.getTid()).thenReturn(12345);

            // When
            int tid = mockResponse.getTid();

            // Then
            assertEquals(12345, tid, "Should return the configured tree ID");
            verify(mockResponse).getTid();
        }

        @Test

        ndrBuffer.enc_ndr_short(0x1234);
        assertEquals(4, ndrBuffer.getIndex()); // Aligned from 1 to 2, then advanced by 2
        assertEquals(4, ndrBuffer.getLength());
        assertEquals((byte) 0x34, buffer[2]);
        assertEquals((byte) 0x12, buffer[3]);

        ndrBuffer.setIndex(2);
        val = ndrBuffer.dec_ndr_short();
        assertEquals(0x1234, val);
        assertEquals(4, ndrBuffer.getIndex());

        dnsDomainInfo.domain_guid.time_low = 0x12345678;
        dnsDomainInfo.domain_guid.time_mid = 0x1234;
        dnsDomainInfo.domain_guid.time_hi_and_version = 0x5678;
        dnsDomainInfo.domain_guid.clock_seq_hi_and_reserved = 0x12;
        dnsDomainInfo.domain_guid.clock_seq_low = 0x34;
        dnsDomainInfo.domain_guid.node = new byte[] { 1, 2, 3, 4, 5, 6 };

        dnsDomainInfo.sid = new rpc.sid_t();
        dnsDomainInfo.sid.revision = 1;

    void testPrepareWithoutReceivedDoesNotPropagate() {
        Smb2SessionSetupResponse resp = newResponse();
        // Set a sessionId, but do not mark as received via decode
        resp.setSessionId(0x1234L);

        CIFSContext mockCtx = mock(CIFSContext.class);
        when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));

  @Override
  public int hashCode() {
    return Objects.hash(host, port);
  }

  /** Rebuild the host:port string, including brackets if necessary. */
  @Override
  public String toString() {
    // "[]:12345" requires 8 extra bytes.
    StringBuilder builder = new StringBuilder(host.length() + 8);
    if (host.indexOf(':') >= 0) {
      builder.append('[').append(host).append(']');
    } else {
      builder.append(host);