assertThat(explicitAdapter.toDer("hi")).isEqualTo(bytes)
  }

  @Test fun `boolean`() {
    val bytes = "0101FF".decodeHex()
    assertThat(Adapters.BOOLEAN.fromDer(bytes)).isEqualTo(true)
    assertThat(Adapters.BOOLEAN.toDer(true)).isEqualTo(bytes)
  }

  @Test fun `positive integer`() {
    val bytes = "020132".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.toDer(50L)).isEqualTo(bytes)

        }

        @Test
        @DisplayName("SMB dialect ANY should be 0x02FF")
        void testDialectAny() {
            assertEquals(0x02FF, Smb2Constants.SMB2_DIALECT_ANY, "SMB dialect ANY must be 0x02FF");
        }

        @ParameterizedTest
        @ValueSource(ints = { 0x0202, 0x0210, 0x0300, 0x0302, 0x0311 })

        assertEquals(1.0f, item.getUserBoost(), 0.001f); // Should be set to 1

        // Test with boost greater than 1
        SuggestItem item2 = new SuggestItem(text, readings, null, 0L, 0L, 2.5f, null, null, null, SuggestItem.Kind.QUERY);
        assertEquals(2.5f, item2.getUserBoost(), 0.001f); // Should keep the value
    }

    @Test(expected = IllegalArgumentException.class)

        assertEquals(data1.getUrl(), data2.getUrl());
        assertEquals(data1.getWeight(), data2.getWeight(), 0.001f);

        assertEquals(data2.getMethod(), data3.getMethod());
        assertEquals(data2.getUrl(), data3.getUrl());
        assertEquals(data2.getWeight(), data3.getWeight(), 0.001f);
    }

    public void test_overwritingValues() {
        // Test that later values overwrite earlier ones

        elevateWord = new ElevateWord(word, boost, readings, fields, tags, roles);

        assertEquals(word, elevateWord.getElevateWord());
        assertEquals(boost, elevateWord.getBoost(), 0.001f);
        assertEquals(readings, elevateWord.getReadings());
        assertEquals(fields, elevateWord.getFields());
        assertEquals(tags, elevateWord.getTags());
        assertEquals(roles, elevateWord.getRoles());
    }

  // 128
  private static final long EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT =
      ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 1920 [chars 0x0080 to 0x07FF]
  private static final long TWO_BYTE_ROUNDTRIPPABLE_CHARACTERS = 0x07FF - 0x0080 + 1;

  // 18,304
  private static final long EXPECTED_TWO_BYTE_ROUNDTRIPPABLE_COUNT =
      // Both bytes are one byte characters

    @DisplayName("Pipe Flags Tests")
    class PipeFlagsTests {

        @Test
        @DisplayName("Should have correct pipe flags constant")
        void testPipeFlags() {
            int expectedFlags = (0x2019F << 16) | SmbPipeResource.PIPE_TYPE_RDWR | SmbPipeResource.PIPE_TYPE_DCE_TRANSACT;
            assertEquals(expectedFlags, DcerpcPipeHandle.pipeFlags);
        }
    }

        assertTrue(s.contains("flags=" + flags), "toString should include flags");
        assertTrue(s.contains(Arrays.toString(mechs)), "toString should include mechanisms");
        assertTrue(s.contains("000AFF"), "toString should include MIC hex");
    }

    @Test
    @DisplayName("Mechanism ordering is preserved after parse")
    void testMechanismOrderPreserved() throws Exception {

            getResultMessageMethod.setAccessible(true);

            assertEquals("0x0004", getResultMessageMethod.invoke(null, 4), "Should return hex format for unknown code 4");
            assertEquals("0x00FF", getResultMessageMethod.invoke(null, 255), "Should return hex format for unknown code 255");
            assertEquals("0x1000", getResultMessageMethod.invoke(null, 4096), "Should return hex format for large unknown code");
        }

        assertEquals(expectedHigh, buffer[offset + 3]);
    }

    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));
    }