public void testToByteArray() {
    assertThat(Ints.toByteArray(0x12131415)).isEqualTo(new byte[] {0x12, 0x13, 0x14, 0x15});
    assertThat(Ints.toByteArray(0xFFEEDDCC))
        .isEqualTo(new byte[] {(byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC});
  }

  public void testFromByteArray() {
    assertThat(Ints.fromByteArray(new byte[] {0x12, 0x13, 0x14, 0x15, 0x33})).isEqualTo(0x12131415);

	// map header, size 3
	// write "PartNumber"
	err = en.Append(0x83, 0xaa, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteInt(z.PartNumber)
	if err != nil {
		err = msgp.WrapError(err, "PartNumber")
		return
	}
	// write "Algorithm"
	err = en.Append(0xa9, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d)
	if err != nil {
		return
	}

    @Mock
    private CommonServerMessageBlock message;

    private byte[] testData;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        testData = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
    }

    @Test
    @DisplayName("Test sign method with valid parameters")
    void testSignWithValidParameters() {
        // Arrange
        int offset = 0;

        void shouldHaveCorrectInheritanceFlags() {
            assertEquals(0x01, ACE.FLAGS_OBJECT_INHERIT, "FLAGS_OBJECT_INHERIT should be 0x01");
            assertEquals(0x02, ACE.FLAGS_CONTAINER_INHERIT, "FLAGS_CONTAINER_INHERIT should be 0x02");
            assertEquals(0x04, ACE.FLAGS_NO_PROPAGATE, "FLAGS_NO_PROPAGATE should be 0x04");
            assertEquals(0x08, ACE.FLAGS_INHERIT_ONLY, "FLAGS_INHERIT_ONLY should be 0x08");

            request.setOffset(1000L);
            request.setMinimumCount(200);
            request.setRemainingBytes(3000);
            request.setPadding((byte) 4);
            request.setReadFlags((byte) 0x02);

            // Update file ID
            byte[] newFileId = new byte[16];
            Arrays.fill(newFileId, (byte) 0xEF);
            request.setFileId(newFileId);

            // Write and verify

        assertEquals(0x2, Smb2ChangeNotifyRequest.FILE_NOTIFY_CHANGE_DIR_NAME);
        assertEquals(0x4, Smb2ChangeNotifyRequest.FILE_NOTIFY_CHANGE_ATTRIBUTES);
        assertEquals(0x8, Smb2ChangeNotifyRequest.FILE_NOTIFY_CHANGE_SIZE);
        assertEquals(0x10, Smb2ChangeNotifyRequest.FILE_NOTIFY_CHANGE_LAST_WRITE);
        assertEquals(0x20, Smb2ChangeNotifyRequest.FILE_NOTIFY_CHANGE_LAST_ACCESS);

     *
     * Implementation note: An alternative to the following would be to make a map that simply
     * replaces the allowed ASCII whitespace characters with themselves and to set the minimum safe
     * character to 0x20. However this would slow down the escaping of simple strings that contain
     * \t, \n, or \r.
     */
    for (char c = MIN_ASCII_CONTROL_CHAR; c <= MAX_ASCII_CONTROL_CHAR; c++) {

                Arguments.of("too short header", new byte[] { 0x04, 0x01, 0x00 }, IllegalArgumentException.class),

                // Wrong TOK_ID
                Arguments.of("wrong TOK_ID", new byte[] { 0x00, 0x02, 0x00, 0x01 }, IllegalArgumentException.class),

                // OID length claims more than available

   * @return {@code true} if the argument is a 6to4 address
   */
  public static boolean is6to4Address(Inet6Address ip) {
    byte[] bytes = ip.getAddress();
    return (bytes[0] == (byte) 0x20) && (bytes[1] == (byte) 0x02);
  }

  /**
   * Returns the IPv4 address embedded in a 6to4 address.
   *
   * @param ip {@link Inet6Address} to be examined for embedded IPv4 in 6to4 address

     * Inheritance flag: child objects inherit this ACE
     */
    int FLAGS_OBJECT_INHERIT = 0x01;
    /**
     * Inheritance flag: child containers inherit this ACE
     */
    int FLAGS_CONTAINER_INHERIT = 0x02;
    /**
     * Inheritance flag: inheritance stops after one level
     */
    int FLAGS_NO_PROPAGATE = 0x04;
    /**
     * Inheritance flag: ACE applies only to children, not to the object itself
     */