@Test
    @DisplayName("Test FileBasicInfo decode method")
    void testFileBasicInfoDecode() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[64];
        int bufferIndex = 8;

        // Prepare test data in buffer (40 bytes of data)
        // Use SMBUtil to properly encode times in Windows FILETIME format
        SMBUtil.writeTime(TEST_CREATE_TIME, buffer, bufferIndex);

		if err != nil {
			f.Fatalf("failed to read testdata: %s", err)
		}
		f.Add(b)
	}

	f.Fuzz(func(t *testing.T, b []byte) {
		r, err := NewReader(bytes.NewReader(b), int64(len(b)))
		if err != nil {
			return
		}

		type file struct {
			header  *FileHeader
			content []byte
		}
		files := []file{}

		for _, f := range r.File {
			fr, err := f.Open()
			if err != nil {
				continue
			}

		if err != nil {
			err = msgp.WrapError(err, "Cache")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *nsScannerOptions) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--

        byte[] key1 = new byte[16];
        byte[] key2 = new byte[16];
        new SecureRandom().nextBytes(key1);
        new SecureRandom().nextBytes(key2);

        keyManager.storeSessionKey(sessionId1, key1, "AES");
        keyManager.storeSessionKey(sessionId2, key2, "AES");

        byte[] retrieved1 = keyManager.getRawKey(sessionId1);
        byte[] retrieved2 = keyManager.getRawKey(sessionId2);

  }

  /**
   * Reads all bytes from a file into a byte array.
   *
   * <p><b>{@link java.nio.file.Path} equivalent:</b> {@link java.nio.file.Files#readAllBytes}.
   *
   * @param file the file to read from
   * @return a byte array containing all the bytes from file
   * @throws IllegalArgumentException if the file is bigger than the largest possible byte array
   *     (2^31 - 1)

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"bytes"
	"fmt"
	"syscall"
	"unsafe"
)

func direntNamlen(dirent *syscall.Dirent) (uint64, error) {
	const fixedHdr = uint16(unsafe.Offsetof(syscall.Dirent{}.Name))
	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
	const nameBufLen = uint16(len(nameBuf))
	limit := dirent.Reclen - fixedHdr

        assertNull(serverData.guid);
    }

    /**
     * Test setting and getting byte field (sflags)
     */
    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x01, 0x7F, (byte) 0x80, (byte) 0xFF })
    @DisplayName("Test sflags field with various byte values")
    public void testSflagsField(byte value) {
        // When
        serverData.sflags = value;

        // Then

            // Given
            byte[] originalBuffer = new byte[100];
            for (int i = 0; i < originalBuffer.length; i++) {
                originalBuffer[i] = (byte) i;
            }
            byte[] buffer = originalBuffer.clone();

            // When
            Method readParams = SmbComNtCancel.class.getDeclaredMethod("readParameterWordsWireFormat", byte[].class, int.class);

        // Flags (4 bytes)
        SMBUtil.writeInt4(this.flags, dst, dstIndex);
        dstIndex += 4;

        // Compression algorithms (2 bytes each)
        for (int algo : this.compressionAlgorithms) {
            SMBUtil.writeInt2(algo, dst, dstIndex);
            dstIndex += 2;
        }

        return dstIndex - start;
    }

    @Override

        return Stream.of(Arguments.of(new byte[] {}, ""), Arguments.of(new byte[] { (byte) 0x00 }, "00"),
                Arguments.of(new byte[] { (byte) 0x0F }, "0f"), Arguments.of(new byte[] { (byte) 0x10 }, "10"),
                Arguments.of(new byte[] { (byte) 0xAB }, "ab"),
                Arguments.of(new byte[] { (byte) 0x7F, (byte) 0x80, (byte) 0xFF }, "7f80ff"));
    }