assertEquals("", Strings.commonSuffix("xyz", "abcde"));
    assertEquals("", Strings.commonSuffix("xyz", "xyzabc"));
    assertEquals("c", Strings.commonSuffix("abc", "ccccc"));
    assertEquals("aa", Strings.commonSuffix("aa", "aaaaa"));
    assertEquals("abc", Strings.commonSuffix(new StringBuilder("xyzabc"), "xxxabc"));

    // Identical valid surrogate pairs.
    assertEquals(

            assertEquals(0x5678, testBlock.getPid());
        }

        @Test
        @DisplayName("Test UID property")
        void testUidProperty() {
            testBlock.setUid(0x9ABC);
            assertEquals(0x9ABC, testBlock.getUid());
        }

        @Test
        @DisplayName("Test MID property")
        void testMidProperty() {
            testBlock.setMid(0xDEF0L);

        void testUuidTEncode() throws NdrException {
            // Given: A UUID with test values
            rpc.uuid_t uuid = new rpc.uuid_t();
            uuid.time_low = 0x12345678;
            uuid.time_mid = (short) 0x9ABC;
            uuid.time_hi_and_version = (short) 0xDEF0;
            uuid.clock_seq_hi_and_reserved = (byte) 0x11;
            uuid.clock_seq_low = (byte) 0x22;

		tests: []testFnc{
			testRead{100, "\x00abc\x00\x00", errMissData},
		},
	}, {
		maker: makeSparse{makeReg{"abc", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
		tests: []testFnc{
			testRead{100, "\x00abc\x00\x00", io.ErrUnexpectedEOF},
		},
	}, {
		maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 5}}, 15},
		tests: []testFnc{
			testRead{100, "\x00abc\x00\x00de", errMissData},
		},
	}, {

        buffer[offset + 2] = 0x02; // PIPE
        buffer[offset + 3] = 0;
        SMBUtil.writeInt4(0x1234, buffer, offset + 4);
        SMBUtil.writeInt4(0x5678, buffer, offset + 8);
        SMBUtil.writeInt4(0x9ABC, buffer, offset + 12);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(16, bytesRead);

        assertEquals(0, cmd.readDataWireFormat(null, 0, 0));
    }

    @Test
    @DisplayName("toString includes information level in hex")
    void testToString() {
        int level = 0xABC;
        Trans2QueryFSInformation cmd = new Trans2QueryFSInformation(level);
        String str = cmd.toString();
        // toString uses Hexdump.toHexString(informationLevel, 3)

			testRemaining{5, 5},
			testWrite{"abc", 3, nil},
			testRemaining{2, 2},
			testReadFrom{fileOps{"\x00\x00"}, 2, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeReg{5, "\x00\x00abc"},
		tests: []testFnc{
			testRemaining{5, 5},
			testWrite{"\x00\x00", 2, nil},
			testRemaining{3, 3},
			testWrite{"abc", 3, nil},
			testReadFrom{fileOps{"z"}, 0, ErrWriteTooLong},

		}
	}
}

var scanTests = []string{
	"",
	"a",
	"¼",
	"☹",
	"\x81",   // UTF-8 error
	"\uFFFD", // correctly encoded RuneError
	"abcdefgh",
	"abc def\n\t\tgh    ",
	"abc¼☹\x81\uFFFD日本語\x82abc",
}

func TestScanByte(t *testing.T) {
	for n, test := range scanTests {
		buf := strings.NewReader(test)
		s := NewScanner(buf)
		s.Split(ScanBytes)
		var i int
		for i = 0; s.Scan(); i++ {

	{"a☺b☻c☹d", "cx", len("a☺b☻")},
	{"a☺b☻c☹d", "uvw☻xyz", len("a☺b")},
	{"aRegExp*", ".(|)*+?^$[]", 7},
	{dots + dots + dots, " ", -1},
	{"012abcba210", "\xffb", 4},
	{"012\x80bcb\x80210", "\xffb", 3},
	{"0123456\xcf\x80abc", "\xcfb\x80", 10},
}

var lastIndexAnyTests = []BinOpTest{
	{"", "", -1},
	{"", "a", -1},
	{"", "abc", -1},
	{"a", "", -1},
	{"a", "a", 0},
	{"\x80", "\xffb", 0},
	{"aaa", "a", 2},

integer, even if it starts with a leading <code>0</code>.
</p>

<pre>
0i
0123i         // == 123i for backward-compatibility
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i
</pre>


<h3 id="Rune_literals">Rune literals</h3>

<p>