t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestNameUnmarshalXML(t *testing.T) {
	var blankName Name

	testCases := []struct {
		data         []byte

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

    @Test
    void testReadDataWireFormatExceedsBuffer() {
        // Test when data length exceeds outputBuffer size

      },
    )
  }

  @Test fun maxLengthDataFrame() {
    val expectedData = ByteArray(Http2.INITIAL_MAX_FRAME_SIZE)
    Arrays.fill(expectedData, 2.toByte())
    writeMedium(frame, expectedData.size)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.write(expectedData)

    // Check writer sends the same bytes.

        // Then
        assertEquals(dataLength, bytesWritten);
        byte[] expectedData = Arrays.copyOfRange(TEST_DATA, dataOffset, dataOffset + dataLength);
        byte[] writtenData = Arrays.copyOfRange(dst, dstIndex, dstIndex + dataLength);
        assertArrayEquals(expectedData, writtenData);
    }

    @Test
    @DisplayName("Test writeDataWireFormat with insufficient buffer space")

        // Prepare buffer with specific pattern
        byte[] buffer = new byte[32];
        byte[] expectedData = new byte[16];

        // Fill data section with pattern
        for (int i = 0; i < 16; i++) {
            expectedData[i] = (byte) (0xA0 + i);
            buffer[16 + i] = expectedData[i];
        }

        // Set header values
        SMBUtil.writeInt4(0x100, buffer, 0);

        // Verify correct portion of data is copied
        byte[] expectedData = new byte[partialLength];
        System.arraycopy(TEST_DATA, partialOffset, expectedData, 0, partialLength);
        byte[] copiedData = new byte[partialLength];
        System.arraycopy(dst, dstIndex, copiedData, 0, partialLength);
        assertArrayEquals(expectedData, copiedData);
    }

    @Test

        // Test with mock
        String expectedPath = "/share/folder/file.txt";
        when(requestWithPath.getPath()).thenReturn(expectedPath);

        assertEquals(expectedPath, requestWithPath.getPath());
        verify(requestWithPath, times(1)).getPath();

        // Test with implementation
        testImplementation.setPath(expectedPath);
        assertEquals(expectedPath, testImplementation.getPath());
    }

    @Test

		errs             []error
		dataErrs         map[int][]int
		expectedMeta     FileInfo
		expectedDangling bool
	}{
		{
			name: "FileInfoExists-case1",
			metaArr: []FileInfo{
				{},
				{},
				fi,
				fi,
			},
			errs: []error{
				errFileNotFound,
				errDiskNotFound,
				nil,
				nil,
			},
			dataErrs:         nil,
			expectedMeta:     fi,
			expectedDangling: false,
		},
		{

                            + "=== Cross-Platform Path Test [" + fsName + "] ===\n"
                            + "Expected path pattern: " + expectedPath + "\n"
                            + "Actual location: " + actualLocation + "\n"
                            + "Contains expected pattern: " + actualLocation.contains(expectedPath) + "\n"
                            + "File.separator on this system: '" + File.separator + "'");
        }
    }

    /**

            // The implementation returns empty strings as empty strings, not null
            assertEquals(expectedShare.isEmpty() ? "" : expectedShare, result.getShare());
            assertEquals(expectedPath.isEmpty() ? "" : expectedPath, result.getPath());
        }

        @Test
        @DisplayName("Should handle path with multiple backslashes")
        void testPathWithMultipleBackslashes() {