* License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *

    builder.build(CacheLoader.from(Suppliers.ofInstance(null)));
  }

  public void testDisableCaching() {
    // Functional test: assert that CacheBuilderSpec.disableCaching()
    // disables caching.  It's irrelevant how it does so.
    CacheBuilder<Object, Object> builder = CacheBuilder.from(CacheBuilderSpec.disableCaching());
    Object key = new Object();

            byte[] dst = new byte[offset + buffer.size()];
            int bytesEncoded = buffer.encode(dst, offset);

            assertEquals(buffer.size(), bytesEncoded);

            // Verify that data before offset is untouched
            for (int i = 0; i < offset; i++) {
                assertEquals(0, dst[i]);
            }

            // Verify encoded data at offset

            buffer[i] = (byte) (i % 256);
        }

        int offset = 50;
        trans2QueryFSInfo.writeParametersWireFormat(buffer, offset);

        // Check that only the 2 bytes at offset were modified
        for (int i = 0; i < offset; i++) {
            assertEquals((byte) (i % 256), buffer[i], "Buffer before offset should be unchanged");
        }

    }

    @Test
    @DisplayName("Should handle large session key")
    void testDeriveKeys_LargeSessionKey() {
        // Given
        byte[] largeSessionKey = new byte[256]; // Larger than typical 16-byte key
        new SecureRandom().nextBytes(largeSessionKey);
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        // When

        }
      webSocket!!.initReaderAndWriter(name, this, client)
    }

    /**
     * Peeks the number of bytes available for the client to read immediately. This doesn't block so
     * it requires that bytes have already been flushed by the server.
     */
    fun clientSourceBufferSize(): Long {
      source.request(1L)
      return source.buffer.size
    }

    fun processNextFrame(): Boolean {

    ContiguousSet<Integer> regular = ContiguousSet.create(Range.closed(1, 3), integers());
    assertTrue(regular instanceof RegularContiguousSet);
    reserializeAndAssert(regular);

    /*
     * Make sure that we're using RegularContiguousSet.SerializedForm and not
     * ImmutableSet.SerializedForm, which would be enormous.
     */
    ContiguousSet<Integer> enormous = ContiguousSet.create(Range.<Integer>all(), integers());

    @Test
    @DisplayName("Invalid path triggers RuntimeCIFSException during canonicalize")
    void testCanonicalizeInvalidPath() {
        SmbResourceLocatorImpl a = locator("smb:invalid-no-slash");
        // Any accessor that triggers canonicalizePath should throw
        assertThrows(RuntimeCIFSException.class, a::getURLPath);
        assertThrows(RuntimeCIFSException.class, a::getUNCPath);
    }

    @Test

            assertFalse(addresses[i].groupName);
        }
    }

    @Test
    void readRDataWireFormat_shouldTrimTrailingSpaces() throws Exception {
        // Test that trailing spaces (0x20) are trimmed from names
        byte[] src = new byte[50];
        int srcIndex = 0;

        Field rDataLengthField = NameServicePacket.class.getDeclaredField("rDataLength");

// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//