assertNotEquals(guid1, guid2);
        assertEquals(16, guid1.toBytes().length);
        assertEquals(16, guid2.toBytes().length);
    }

    @Test
    public void testHandleGuidRoundTrip() {
        HandleGuid original = new HandleGuid();
        byte[] bytes = original.toBytes();
        HandleGuid reconstructed = new HandleGuid(bytes);

        assertEquals(original, reconstructed);

    }

    /**
     * Convert the GUID to byte array for wire format (little-endian as per MS-SMB2)
     * @return 16-byte array representing the GUID in SMB wire format
     */
    public byte[] toBytes() {
        byte[] result = new byte[16];
        ByteBuffer bb = ByteBuffer.wrap(result).order(java.nio.ByteOrder.LITTLE_ENDIAN);

        long mostSig = guid.getMostSignificantBits();

        HandleGuid guid2 = new HandleGuid();
        
        assertNotEquals(guid1, guid2);
        assertEquals(16, guid1.toBytes().length);
        
        // Test round-trip
        HandleGuid guid3 = new HandleGuid(guid1.toBytes());
        assertEquals(guid1, guid3);
    }
    
    @Test
    public void testHandleInfoExpiration() {
        HandleInfo info = new HandleInfo(

        dstIndex += 4;

        SMBUtil.writeInt8(0, dst, dstIndex); // Reserved (8 bytes)
        dstIndex += 8;

        System.arraycopy(createGuid.toBytes(), 0, dst, dstIndex, 16); // CreateGuid (16 bytes)
        dstIndex += 16;

        return dstIndex - start;
    }

    private static final byte[] SIGNCONTEXT_300 = toCBytes("SmbSign");
    private static final byte[] SIGNLABEL_300 = toCBytes("SMB2AESCMAC");
    private static final byte[] SIGNLABEL_311 = toCBytes("SMBSigningKey");

    private static final byte[] APPCONTEXT_300 = toCBytes("SmbRpc");
    private static final byte[] APPLABEL_300 = toCBytes("SMB2APP");
    private static final byte[] APPLABEL_311 = toCBytes("SMBAppKey");

     */
    public static Byte toByte(final Object o) {
        return toByte(o, null);
    }

    /**
     * Converts to {@link Byte}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Byte}
     */
    public static Byte toByte(final Object o, final String pattern) {
        if (o == null) {

        final byte[] twoBytes = new byte[] { 'A', 'B' };
        final String encoded = Base64Util.encode(twoBytes);
        assertNotNull("Encoded result should not be null", encoded);
        final byte[] decoded = Base64Util.decode(encoded);
        assertEquals("Decoded should have same length", 2, decoded.length);
        assertEquals("First byte should match", twoBytes[0], decoded[0]);

 *
 */
public class ByteConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToByte() throws Exception {
        assertEquals(Byte.valueOf("100"), ByteConversionUtil.toByte("100"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveByte() throws Exception {
        assertEquals(100, ByteConversionUtil.toPrimitiveByte("100"));
    }

    /**

        } else if (type == BigInteger.class) {
            return BigIntegerConversionUtil.toBigInteger(o);
        } else if (type == Byte.class) {
            return ByteConversionUtil.toByte(o);
        }
        return o;
    }

    /**
     * Converts to the wrapper type corresponding to the specified primitive type.
     *
     * @param type
     *            Primitive type
     * @param o

sols
son 
són
sons 
sota
sou
t'ha
t'han
t'he
ta
tal
també
tampoc
tan
tant
tanta
tantes
teu
teus
teva
teves
ton
tons
tot
tota
totes
tots
un
una
unes
uns
us
va
vaig
vam
van
vas
veu
vosaltres
vostra
vostre