int written = trans2QueryPathInfo.writeParametersWireFormat(buffer, 0);

        // Should handle Unicode characters
        assertTrue(written > 6);

        // Check information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel);
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, 0, 100, 255, Integer.MAX_VALUE })

        }
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.internal.SMBSigningDigest#verify(byte[], int, int, int, jcifs.internal.CommonServerMessageBlock)
     */
    @Override
    public boolean verify(final byte[] data, final int offset, final int length, final int extraPad, final CommonServerMessageBlock msg) {
        // Validate input parameters
        if (data == null) {

const val PLUGINS_PORTAL_URL_OVERRIDE = "-Dorg.gradle.internal.plugins.portal.url.override=%gradle.plugins.portal.url%"

fun BuildSteps.customGradle(
    init: GradleBuildStep.() -> Unit,
    custom: GradleBuildStep.() -> Unit,
): GradleBuildStep =
    GradleBuildStep(init)
        .apply(custom)
        .also {
            step(it)
        }

/**

    class ConstructorTests {

        @ParameterizedTest
        @DisplayName("Should mask input values with 0xFF correctly")
        @ValueSource(ints = { 0, 1, 127, 128, 255, 256, -1, -128, -255, -256, 32767, -32768, 65535, 65536 })
        void testConstructorMasking(int inputValue) {
            // Given: An input value
            // When: Creating NdrShort with that value
            NdrShort ndrShort = new NdrShort(inputValue);

      @Override
      public UnmodifiableIterator<EndpointPair<N>> iterator() {
        return EndpointPairIterator.of(AbstractBaseGraph.this);
      }

      @Override
      public int size() {
        return Ints.saturatedCast(edgeCount());
      }

      @Override
      public boolean remove(@Nullable Object o) {
        throw new UnsupportedOperationException();
      }

    } else {
      toIndex = ranges.size();
    }
    int length = toIndex - fromIndex;
    if (length == 0) {
      return ImmutableList.of();
    } else {
      return new ImmutableList<Range<C>>() {
        @Override
        public int size() {
          return length;
        }

        @Override
        public Range<C> get(int index) {
          checkElementIndex(index, length);

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

    }

    @Test
    public void test_init() {
        try {
            labelTypeHelper.init();
        } catch (Exception e) {
            fail("init() should not throw an exception: " + e.getMessage());
        }
    }

    @Test
    public void test_load() {
        int result = labelTypeHelper.load();
        assertTrue(result >= 0);
    }

    @Test
    public void test_refresh() {

  @CanIgnoreReturnValue
  @Override
  public int remove(@Nullable Object element, int occurrences) {
    if (occurrences == 0) {
      return count(element);
    }
    checkPositive(occurrences, "occurrences");

    AtomicInteger existingCounter = safeGet(countMap, element);
    if (existingCounter == null) {
      return 0;
    }
    while (true) {
      int oldValue = existingCounter.get();

        assertEquals(0x56, buffer[2] & 0xFF);
        assertEquals(0x78, buffer[3] & 0xFF);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 255, 256, 65535, 65536, Integer.MAX_VALUE })
    @DisplayName("Should handle boundary values")
    void testBoundaryValues(int value) {
        // Given
        byte[] buffer = new byte[4];

        // When
        Encdec.enc_uint32le(value, buffer, 0);