"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��#�#
�#�#�#�#�#�#�#�#	�#
L294:�#�#�#
�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�# �#!�#"�##�#$�#%�#&�#'�#(�#)�#*�#+�#,�#-�#.�#/�#0�#1�#2�#3�#4�#5�#6�#7�#8�PartETags��PartSizes�#8�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`...

        assertEquals("00FF", Hexdump.toHexString(255L, 4));

        // Test larger values
        assertEquals("0000000012345678", Hexdump.toHexString(0x12345678L, 16));
        assertEquals("12345678", Hexdump.toHexString(0x12345678L, 8));
        assertEquals("5678", Hexdump.toHexString(0x12345678L, 4));

        // Test negative values (treated as unsigned)
        assertEquals("FFFFFFFFFFFFFFFF", Hexdump.toHexString(-1L, 16));

        assertEquals("FFFFFFFFFFFFFFFF", Hexdump.toHexString(-1L, 16));

        // Test different sizes
        assertEquals("00000000", Hexdump.toHexString(0L, 8));
        assertEquals("12345678", Hexdump.toHexString(0x12345678L, 8));
    }

    @Test
    @DisplayName("Should handle special byte values correctly")
    void testSpecialByteValues() {
        // Test boundary values

        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };
        byte[] response = NtlmPasswordAuthentication.getPreNTLMResponse("password", challenge);
        assertNotNull(response);
        assertEquals(24, response.length);
    }

    // Test getNTLMResponse
    @Test
    void testGetNTLMResponse() {
        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };

		{"032033\x00 ", 032033, true},
		{"320330\x00 ", 0320330, true},
		{"0000660\x00 ", 0660, true},
		{"\x00 0000660\x00 ", 0660, true},
		{"0123456789abcdef", 0, false},
		{"0123456789\x00abcdef", 0, false},
		{"01234567\x0089abcdef", 342391, true},
		{"0123\x7e\x5f\x264123", 0, false},
	}

	for _, v := range vectors {
		var p parser
		got := p.parseNumeric([]byte(v.in))
		ok := (p.err == nil)

	"fmt"
	"io"
	"sync"
	"testing"
)

func TestReader(t *testing.T) {
	r := NewReader([]byte("0123456789"))
	tests := []struct {
		off     int64
		seek    int
		n       int
		want    string
		wantpos int64
		readerr error
		seekerr string
	}{
		{seek: io.SeekStart, off: 0, n: 20, want: "0123456789"},
		{seek: io.SeekStart, off: 1, n: 1, want: "1"},
		{seek: io.SeekCurrent, off: 1, wantpos: 3, n: 2, want: "34"},

        FullWidthToHalfWidthAlphabetNormalizer normalizer = new FullWidthToHalfWidthAlphabetNormalizer();

        String result = normalizer.normalize("０１２３４５６７８９", "field");

        assertEquals("0123456789", result);
    }

    @Test
    public void test_mixedFullWidthAlphanumeric() throws Exception {

 */
@NullUnmarked
public class AbstractByteHasherTest extends TestCase {

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~...

	testPath, locker, _ := createLockTestServer(ctx, t)
	defer os.RemoveAll(testPath)

	lockRequesterInfo1 := lockRequesterInfo{
		Owner:           "owner",
		Writer:          true,
		UID:             "0123-4567",
		Timestamp:       UTCNow().UnixNano(),
		TimeLastRefresh: UTCNow().UnixNano(),
	}
	lockRequesterInfo2 := lockRequesterInfo{
		Owner:           "owner",
		Writer:          true,
		UID:             "89ab-cdef",