testBlock.setDigest(mockDigest);
        byte[] buffer = new byte[1024];

        int length = testBlock.encode(buffer, 0);

        assertTrue(length > 0);
        verify(mockDigest).sign(eq(buffer), eq(0), eq(length), eq(testBlock), any());
    }

    @Test
    @DisplayName("Test decode basic message")

    // A 4n+1 length string is never legal base64().
    assertFailsToDecode(base64(), "12345", "Invalid input length 5");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base64(), "AB=C", "Unrecognized character: =");
    assertFailsToDecode(base64(), "A=BCD", "Invalid input length 5");

      if (x.length() != (originalString.length() * count)) {
        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or
    // OutOfMemoryError is not far behind
    int len = string.length();
    int size = len * count;
    char[] array = new char[size];

      .assertLogEqual("Content-Length: 3")
      .assertLogEqual("--> END POST")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Length: 0")
      .assertLogEqual("<-- END HTTP")
      .assertNoMoreLogs()
    networkLogs
      .assertLogEqual("--> POST $url http/1.1")
      .assertLogEqual("Content-Length: 3")
      .assertLogEqual("Host: $host")

   * @param interfaceType the interface you wish the returned proxy to implement
   * @param timeoutDuration with timeoutUnit, the maximum length of time that callers are willing to
   *     wait on each method call to the proxy
   * @param timeoutUnit with timeoutDuration, the maximum length of time that callers are willing to
   *     wait on each method call to the proxy
   * @return a time-limiting proxy

        /**
         * Get the notification message length
         *
         * @return message length in bytes
         */
        public int getLength() {
            return length;
        }

        /**
         * Sets the notification message length.
         *
         * @param length the message length in bytes
         */
        public void setLength(int length) {
            this.length = length;

            long offset = 1024L;
            long length = 2048L;
            int flags = Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK;

            lock = new Smb2Lock(offset, length, flags);

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with zero offset and length")
        void testConstructorWithZeroValues() {

                Arguments.of((LongGetter) FileEntry::length, -100L, "negative length"),
                Arguments.of((LongGetter) FileEntry::length, 0L, "zero length"),
                Arguments.of((LongGetter) FileEntry::length, 1L, "small length"));
    }

    @ParameterizedTest(name = "Long getter {2} returns {1}")
    @MethodSource("longGetterProvider")

		uuid_t uuid;
	} policy_handle;

	/*
	 * typedef struct _UNICODE_STRING
	 *     USHORT Length;
	 *     USHORT MaximumLength;
	 *     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT *  Buffer;
	 * } UNICODE_STRING;
	 */

	typedef struct {
		uint16_t length;
		uint16_t maximum_length;
		[length_is(length / 2),size_is(maximum_length / 2)] uint16_t *buffer;
	} unicode_string;

	/* 

		uuid_t uuid;
	} policy_handle;

	/*
	 * typedef struct _UNICODE_STRING
	 *     USHORT Length;
	 *     USHORT MaximumLength;
	 *     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT *  Buffer;
	 * } UNICODE_STRING;
	 */

	typedef struct {
		uint16_t length;
		uint16_t maximum_length;
		[length_is(length / 2),size_is(maximum_length / 2)] uint16_t *buffer;
	} unicode_string;

	/*