}

    @Test
    void testWriteHeaderWireFormat() {
        byte[] dst = new byte[NameServicePacket.HEADER_LENGTH];
        packet.nameTrnId = 0x1234;
        packet.isResponse = true;
        packet.opCode = NameServicePacket.QUERY;
        packet.isAuthAnswer = true;
        packet.isTruncated = true;
        packet.isRecurDesired = true;
        packet.isRecurAvailable = true;

        case NB -> "NB";
        case NBSTAT -> "NBSTAT";
        default -> "0x" + Hexdump.toHexString(this.recordType, 4);
        };

        return ("nameTrnId=" + this.nameTrnId + ",isResponse=" + this.isResponse + ",opCode=" + opCodeString + ",isAuthAnswer="
                + this.isAuthAnswer + ",isTruncated=" + this.isTruncated + ",isRecurAvailable=" + this.isRecurAvailable + ",isRecurDesired="

        case NULL -> "NULL";
        case NB -> "NB";
        case NBSTAT -> "NBSTAT";
        default -> "0x" + Hexdump.toHexString(recordType, 4);
        };

        return ("nameTrnId=" + nameTrnId + ",isResponse=" + isResponse + ",opCode=" + opCodeString + ",isAuthAnswer=" + isAuthAnswer
                + ",isTruncated=" + isTruncated + ",isRecurAvailable=" + isRecurAvailable + ",isRecurDesired=" + isRecurDesired

        }

        @Test
        @DisplayName("Test isResponse method")
        void testIsResponse() {
            testBlock.setFlags((byte) 0);
            assertFalse(testBlock.isResponse());

            testBlock.setFlags((byte) SmbConstants.FLAGS_RESPONSE);
            assertTrue(testBlock.isResponse());
        }

        @Test
        @DisplayName("Test hashCode method")

        assertEquals(smb.mid, readSmb.mid);
    }

    @Test
    void testIsResponse() {
        smb.flags = (byte) ServerMessageBlock.FLAGS_RESPONSE;
        assertTrue(smb.isResponse());
        smb.flags = 0;
        assertFalse(smb.isResponse());
    }

    @Test
    void testEqualsAndHashCode() {
        ServerMessageBlock smb1 = new TestServerMessageBlock();
        smb1.mid = 100;

            isPrimary = false;

            parameterOffset = primarySetupOffset + setupCount * 2 + 2;
            if (command != SMB_COM_NT_TRANSACT) {
                if (command == SMB_COM_TRANSACTION && !isResponse()) {
                    parameterOffset += stringWireLength(name, parameterOffset);
                }
            } else {
                parameterOffset += 2;
            }

            // 2* setupCount
            this.parameterOffset += this.setupCount * 2;
            this.parameterOffset += 2; // ByteCount

            if (this.getCommand() == SMB_COM_TRANSACTION && !isResponse()) {
                this.parameterOffset += stringWireLength(this.name, this.parameterOffset);
            }

            this.pad1 = pad(this.parameterOffset);
            this.parameterOffset += this.pad1;

        uid = readInt2(buffer, bufferIndex + TID_OFFSET + 4);
        mid = readInt2(buffer, bufferIndex + TID_OFFSET + 6);
        return HEADER_LENGTH;
    }

    boolean isResponse() {
        return (flags & FLAGS_RESPONSE) == FLAGS_RESPONSE;
    }

    /*
     * For this packet deconstruction technique to work for
     * other networking protocols the InputStream may need

        }

        @Test
        @DisplayName("Should detect response flag")
        void testIsResponse() {
            assertFalse(testMessage.isResponse());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_SERVER_TO_REDIR);
            assertTrue(testMessage.isResponse());
        }
    }

    @Nested
    @DisplayName("Digest Tests")
    class DigestTests {

        @Test

        bufferIndex += 8;
        System.arraycopy(buffer, bufferIndex, this.signature, 0, 16);
        bufferIndex += 16;

        return Smb2Constants.SMB2_HEADER_LENGTH;
    }

    boolean isResponse() {
        return (this.flags & SMB2_FLAGS_SERVER_TO_REDIR) == SMB2_FLAGS_SERVER_TO_REDIR;
    }

    /**
     * Writes the message body to the wire format.
     *
     * @param dst the destination buffer