Type1Message type1 = new Type1Message(mockContext);
        byte[] messageBytes = type1.toByteArray();

        // Then
        assertTrue(messageBytes.length >= 12);
        // Message type should be 1 (little endian)
        assertEquals(1, messageBytes[8] & 0xFF);
        assertEquals(0, messageBytes[9] & 0xFF);
        assertEquals(0, messageBytes[10] & 0xFF);
        assertEquals(0, messageBytes[11] & 0xFF);
    }

        assertTrue(infoString.contains("bytesPerSect=512"), "toString should contain bytesPerSect");
    }

    // Helper methods to write numbers to byte array in little-endian format.
    private void writeInt2(int val, byte[] dst, int dstIndex) {
        dst[dstIndex++] = (byte) val;
        dst[dstIndex++] = (byte) (val >> 8);
    }

    checkArgument(
        result == (int) result,
        "the total number of elements (%s) in the arrays must fit in an int",
        result);
    return (int) result;
  }

  /**
   * Returns a big-endian representation of {@code value} in a 4-element byte array; equivalent to
   * {@code ByteBuffer.allocate(4).putInt(value).array()}. For example, the input value {@code

        Mac mac = Mac.getInstance("HmacMD5");
        MessageDigest md = MessageDigest.getInstance("MD5");
        mac.init(key);
        byte[] dk = mac.doFinal(MD5_CONSTANT);
        try {
            // little endian
            md.update((byte) (ms_usage & 0xFF));
            md.update((byte) (ms_usage >> 8 & 0xFF));
            md.update((byte) (ms_usage >> 16 & 0xFF));
            md.update((byte) (ms_usage >> 24 & 0xFF));

	// OpMerged is several operations merged into one.
	OpMerged
)

const (
	// FlagCRCxxh3 indicates that, the lower 32 bits of xxhash3 of the serialized
	// message will be sent after the serialized message as little endian.
	FlagCRCxxh3 Flags = 1 << iota

	// FlagEOF the stream (either direction) is at EOF.
	FlagEOF

	// FlagStateless indicates the message is stateless.
	// This will retain clients across reconnections or

        assertTrue(raf.readBoolean());
        assertEquals((byte) 0xFF, raf.readByte());
        assertEquals(0xFF, raf.readUnsignedByte());
    }

    @Test
    @DisplayName("readShort/UnsignedShort/Char: big-endian decoding")
    void read_twoByteVariants() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        doAnswer(inv -> {
            byte[] b = inv.getArgument(0);

        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten, "Should write 4 bytes");
        // Check that structure size (4) is written as 2-byte little-endian
        assertEquals(4, buffer[offset] | (buffer[offset + 1] << 8), "Structure size should be 4");
        assertEquals(0, buffer[offset + 2], "Reserved bytes should be 0");

/**
 * Unit tests for {@link HashCode}.
 *
 * @author Dimitris Andreou
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class HashCodeTest extends TestCase {
  // note: asInt(), asLong() are in little endian
  private static final ImmutableList<ExpectedHashCode> expectedHashCodes =
      ImmutableList.of(
          new ExpectedHashCode(
              new byte[] {
                (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x89,

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_TRANSACT_NAMED_PIPE, dst[0]);
        assertEquals(0x00, dst[1]);

        // Verify FID is written correctly (little-endian)
        int writtenFid = SMBUtil.readInt2(dst, 2);
        assertEquals(TEST_FID, writtenFid);
    }

    @Test
    @DisplayName("Test writeDataWireFormat with sufficient buffer")

func (p *parser) parseNumeric(b []byte) int64 {
	// Check for base-256 (binary) format first.
	// If the first bit is set, then all following bits constitute a two's
	// complement encoded number in big-endian byte order.
	if len(b) > 0 && b[0]&0x80 != 0 {
		// Handling negative numbers relies on the following identity:
		//	-a-1 == ^a
		//
		// If the number is negative, we use an inversion mask to invert the