final byte[] clientChallenge = new byte[24];
                tc.getConfig().getRandom().nextBytes(clientChallenge);
                java.util.Arrays.fill(clientChallenge, 8, 24, (byte) 0x00);

                final byte[] ntlm2Response = NtlmUtil.getNTLM2Response(passwordHash, type2.getChallenge(), clientChallenge);

                setLMResponse(clientChallenge);

		tw := NewWriter(new(bytes.Buffer))
		hdr := &Header{Name: "dir/", Typeflag: TypeDir}
		if err := tw.WriteHeader(hdr); err != nil {
			t.Fatalf("WriteHeader() = %v, want nil", err)
		}
		if _, err := tw.Write([]byte{0x00}); err != ErrWriteTooLong {
			t.Fatalf("Write() = %v, want %v", err, ErrWriteTooLong)
		}
	})

	t.Run("NegativeSize", func(t *testing.T) {
		tw := NewWriter(new(bytes.Buffer))

    assertThat(Shorts.toByteArray((short) 0x2345)).isEqualTo(new byte[] {0x23, 0x45});
    assertThat(Shorts.toByteArray((short) 0xFEDC)).isEqualTo(new byte[] {(byte) 0xFE, (byte) 0xDC});
  }

  @GwtIncompatible // Shorts.fromByteArray
  public void testFromByteArray() {
    assertThat(Shorts.fromByteArray(new byte[] {0x23, 0x45})).isEqualTo((short) 0x2345);

import com.google.common.annotations.GwtCompatible;
import java.nio.charset.StandardCharsets;

/**
 * Static methods pertaining to ASCII characters (those in the range of values {@code 0x00} through
 * {@code 0x7F}), and to strings containing such characters.
 *
 * <p>ASCII utilities also exist in other classes of this package:
 *
 * <ul>

            // When: Creating close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // Then: Should have correct opnum and handle
            assertEquals(0x01, message.getOpnum());
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test
        @DisplayName("Should encode input parameters correctly")

	s := blk.toGNU().sparse()
	spd := make(sparseDatas, 0, s.maxEntries())
	for {
		for i := 0; i < s.maxEntries(); i++ {
			// This termination condition is identical to GNU and BSD tar.
			if s.entry(i).offset()[0] == 0x00 {
				break // Don't return, need to process extended headers (even if empty)
			}
			offset := p.parseNumeric(s.entry(i).offset())
			length := p.parseNumeric(s.entry(i).length())
			if p.err != nil {

    }

    /**
     * LSA close handle message.
     */
    public static class LsarClose extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x00;
        }

        /** Return value from the RPC call. */
        public int retval;
        /** Policy handle to be closed. */
        public rpc.policy_handle handle;

        /**

0103          ; valid                                  # 1.1  LATIN SMALL LETTER A WITH BREVE
0104          ; mapped                 ; 0105          # 1.1  LATIN CAPITAL LETTER A WITH OGONEK
0105          ; valid                                  # 1.1  LATIN SMALL LETTER A WITH OGONEK
0106          ; mapped                 ; 0107          # 1.1  LATIN CAPITAL LETTER C WITH ACUTE

                                "content": {"application/x-level-5": {"schema": {}}},
                            },
                            "400": {"description": "Client error level 0"},
                            "405": {"description": "Client error level 5"},
                            "422": {
                                "description": "Validation Error",
                                "content": {

        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);
        lsarpc.LsarClose lsarClose = new lsarpc.LsarClose(mockHandle);

        assertEquals(mockHandle, lsarClose.handle);
        assertEquals(0x00, lsarClose.getOpnum());
    }

    @Test
    void testLsarCloseEncodeIn() throws NdrException {
        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);