}

    private static Stream<Arguments> provideFidTestCases() {
        return Stream.of(Arguments.of(0x0000, (byte) 0x00, (byte) 0x00), Arguments.of(0x00FF, (byte) 0xFF, (byte) 0x00),
                Arguments.of(0xFF00, (byte) 0x00, (byte) 0xFF), Arguments.of(0xFFFF, (byte) 0xFF, (byte) 0xFF),
                Arguments.of(0x1234, (byte) 0x34, (byte) 0x12));
    }

    @Test
    @DisplayName("readSetupWireFormat should return 0")

     * - Tab (0x9)
     * - Line feed (0xA)
     * - Carriage return (0xD)
     * - Any character between 0x20 and 0xD7FF
     * - Any character between 0xE000 and 0xFFFD
     * - Any character between 0x10000 and 0x10FFFF
     *
     * @param in the input string to be processed
     * @return a new string with invalid XML characters removed, or the original

    val flags = buf.readShort().toInt() and 0xffff
    require(flags shr 15 != 0) { "not a response" }

    val responseCode = flags and 0xf

    if (responseCode == NXDOMAIN) {
      throw UnknownHostException("$hostname: NXDOMAIN")
    } else if (responseCode == SERVFAIL) {
      throw UnknownHostException("$hostname: SERVFAIL")
    }

    val questionCount = buf.readShort().toInt() and 0xffff

        buffer.putShort(0, (short) 0xFFFF);
        assertEquals(0xFFFF, NtlmMessage.readUShort(data, 0), "Should read max UShort correctly.");

        // Test with a negative short (should be interpreted as unsigned positive)
        buffer.putShort(0, (short) -1); // -1 is 0xFFFF
        assertEquals(0xFFFF, NtlmMessage.readUShort(data, 0), "Should interpret -1 as unsigned max UShort.");
    }

                final int _name_bufferi = _src.index;
                _src.advance(2 * _name_bufferl);

                if (this.name.buffer == null) {
                    if (_name_buffers < 0 || _name_buffers > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.name.buffer = new short[_name_buffers];
                }

                final int _ss = _src.dec_ndr_long();
                final int _si = _src.index;
                _src.advance(4 * _ss);

                if (this.s == null) {
                    if (_ss < 0 || _ss > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.s = new DfsInfo1[_ss];
                }
                _src = _src.derive(_si);

            final int _nodes = 6;
            final int _nodei = _src.index;
            _src.advance(1 * _nodes);

            if (node == null) {
                if (_nodes < 0 || _nodes > 0xFFFF) {
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                }
                node = new byte[_nodes];
            }
            _src = _src.derive(_nodei);

            // Given
            setResultField(bind, 0xFFFF);

            // When
            DcerpcException result = bind.getResult();

            // Then
            assertNotNull(result, "Should return exception for large error code");
            assertEquals("0xFFFF", result.getMessage(), "Should return hex representation for large error code");
        }

        long data4 = bb2.getLong();

        // Construct UUID from components - Java UUID expects big-endian representation
        long mostSig = ((long) data1 << 32) | ((long) (data2 & 0xFFFF) << 16) | (data3 & 0xFFFF);
        long leastSig = data4;

        this.guid = new UUID(mostSig, leastSig);
    }

    /**
     * Create a handle GUID from existing UUID
     * @param uuid the UUID to wrap
     */

                this.negotiatedFlags2 |= SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
            }
        } else {
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_SIGNATURES;
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
        }

        if (log.isDebugEnabled()) {