diff options
Diffstat (limited to 'other/java/client/src')
| -rw-r--r-- | other/java/client/src/test/java/seaweedfs/client/FilerClientIntegrationTest.java | 323 | ||||
| -rw-r--r-- | other/java/client/src/test/java/seaweedfs/client/SeaweedStreamIntegrationTest.java | 417 |
2 files changed, 740 insertions, 0 deletions
diff --git a/other/java/client/src/test/java/seaweedfs/client/FilerClientIntegrationTest.java b/other/java/client/src/test/java/seaweedfs/client/FilerClientIntegrationTest.java new file mode 100644 index 000000000..1015653bd --- /dev/null +++ b/other/java/client/src/test/java/seaweedfs/client/FilerClientIntegrationTest.java @@ -0,0 +1,323 @@ +package seaweedfs.client; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.List; + +import static org.junit.Assert.*; + +/** + * Integration tests for FilerClient. + * + * These tests verify FilerClient operations against a running SeaweedFS filer + * instance. + * + * Prerequisites: + * - SeaweedFS master, volume server, and filer must be running + * - Default ports: filer HTTP 8888, filer gRPC 18888 + * + * To run tests: + * export SEAWEEDFS_TEST_ENABLED=true + * mvn test -Dtest=FilerClientIntegrationTest + */ +public class FilerClientIntegrationTest { + + private FilerClient filerClient; + private static final String TEST_ROOT = "/test-client-integration"; + private static final boolean TESTS_ENABLED = "true".equalsIgnoreCase(System.getenv("SEAWEEDFS_TEST_ENABLED")); + + @Before + public void setUp() throws Exception { + if (!TESTS_ENABLED) { + return; + } + + filerClient = new FilerClient("localhost", 18888); + + // Clean up any existing test directory + if (filerClient.exists(TEST_ROOT)) { + filerClient.rm(TEST_ROOT, true, true); + } + + // Create test root directory + filerClient.mkdirs(TEST_ROOT, 0755); + } + + @After + public void tearDown() throws Exception { + if (!TESTS_ENABLED || filerClient == null) { + return; + } + + try { + // Clean up test directory + if (filerClient.exists(TEST_ROOT)) { + filerClient.rm(TEST_ROOT, true, true); + } + } finally { + filerClient.shutdown(); + } + } + + @Test + public void testMkdirs() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testDir = TEST_ROOT + "/testdir"; + boolean success = filerClient.mkdirs(testDir, 0755); + + assertTrue("Directory creation should succeed", success); + assertTrue("Directory should exist", filerClient.exists(testDir)); + } + + @Test + public void testTouch() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testFile = TEST_ROOT + "/testfile.txt"; + boolean success = filerClient.touch(testFile, 0644); + + assertTrue("Touch should succeed", success); + assertTrue("File should exist", filerClient.exists(testFile)); + } + + @Test + public void testExists() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + assertTrue("Root should exist", filerClient.exists("/")); + assertTrue("Test root should exist", filerClient.exists(TEST_ROOT)); + assertFalse("Non-existent path should not exist", + filerClient.exists(TEST_ROOT + "/nonexistent")); + } + + @Test + public void testListEntries() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + // Create some test files and directories + filerClient.touch(TEST_ROOT + "/file1.txt", 0644); + filerClient.touch(TEST_ROOT + "/file2.txt", 0644); + filerClient.mkdirs(TEST_ROOT + "/subdir", 0755); + + List<FilerProto.Entry> entries = filerClient.listEntries(TEST_ROOT); + + assertNotNull("Entries should not be null", entries); + assertEquals("Should have 3 entries", 3, entries.size()); + } + + @Test + public void testListEntriesWithPrefix() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + // Create test files + filerClient.touch(TEST_ROOT + "/test1.txt", 0644); + filerClient.touch(TEST_ROOT + "/test2.txt", 0644); + filerClient.touch(TEST_ROOT + "/other.txt", 0644); + + List<FilerProto.Entry> entries = filerClient.listEntries(TEST_ROOT, "test", "", 100, false); + + assertNotNull("Entries should not be null", entries); + assertEquals("Should have 2 entries starting with 'test'", 2, entries.size()); + } + + @Test + public void testDeleteFile() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testFile = TEST_ROOT + "/deleteme.txt"; + filerClient.touch(testFile, 0644); + + assertTrue("File should exist before delete", filerClient.exists(testFile)); + + boolean success = filerClient.rm(testFile, false, true); + + assertTrue("Delete should succeed", success); + assertFalse("File should not exist after delete", filerClient.exists(testFile)); + } + + @Test + public void testDeleteDirectoryRecursive() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testDir = TEST_ROOT + "/deletedir"; + filerClient.mkdirs(testDir, 0755); + filerClient.touch(testDir + "/file.txt", 0644); + + assertTrue("Directory should exist", filerClient.exists(testDir)); + assertTrue("File should exist", filerClient.exists(testDir + "/file.txt")); + + boolean success = filerClient.rm(testDir, true, true); + + assertTrue("Delete should succeed", success); + assertFalse("Directory should not exist after delete", filerClient.exists(testDir)); + } + + @Test + public void testRename() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String srcFile = TEST_ROOT + "/source.txt"; + String dstFile = TEST_ROOT + "/destination.txt"; + + filerClient.touch(srcFile, 0644); + assertTrue("Source file should exist", filerClient.exists(srcFile)); + + boolean success = filerClient.mv(srcFile, dstFile); + + assertTrue("Rename should succeed", success); + assertFalse("Source file should not exist after rename", filerClient.exists(srcFile)); + assertTrue("Destination file should exist after rename", filerClient.exists(dstFile)); + } + + @Test + public void testGetEntry() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testFile = TEST_ROOT + "/getentry.txt"; + filerClient.touch(testFile, 0644); + + FilerProto.Entry entry = filerClient.lookupEntry(TEST_ROOT, "getentry.txt"); + + assertNotNull("Entry should not be null", entry); + assertEquals("Entry name should match", "getentry.txt", entry.getName()); + assertFalse("Entry should not be a directory", entry.getIsDirectory()); + } + + @Test + public void testGetEntryForDirectory() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testDir = TEST_ROOT + "/testsubdir"; + filerClient.mkdirs(testDir, 0755); + + FilerProto.Entry entry = filerClient.lookupEntry(TEST_ROOT, "testsubdir"); + + assertNotNull("Entry should not be null", entry); + assertEquals("Entry name should match", "testsubdir", entry.getName()); + assertTrue("Entry should be a directory", entry.getIsDirectory()); + } + + @Test + public void testCreateAndListNestedDirectories() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String nestedPath = TEST_ROOT + "/level1/level2/level3"; + boolean success = filerClient.mkdirs(nestedPath, 0755); + + assertTrue("Nested directory creation should succeed", success); + assertTrue("Nested directory should exist", filerClient.exists(nestedPath)); + + // Verify each level exists + assertTrue("Level 1 should exist", filerClient.exists(TEST_ROOT + "/level1")); + assertTrue("Level 2 should exist", filerClient.exists(TEST_ROOT + "/level1/level2")); + assertTrue("Level 3 should exist", filerClient.exists(nestedPath)); + } + + @Test + public void testMultipleFilesInDirectory() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testDir = TEST_ROOT + "/multifiles"; + filerClient.mkdirs(testDir, 0755); + + // Create 10 files + for (int i = 0; i < 10; i++) { + filerClient.touch(testDir + "/file" + i + ".txt", 0644); + } + + List<FilerProto.Entry> entries = filerClient.listEntries(testDir); + + assertNotNull("Entries should not be null", entries); + assertEquals("Should have 10 files", 10, entries.size()); + } + + @Test + public void testRenameDirectory() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String srcDir = TEST_ROOT + "/sourcedir"; + String dstDir = TEST_ROOT + "/destdir"; + + filerClient.mkdirs(srcDir, 0755); + filerClient.touch(srcDir + "/file.txt", 0644); + + boolean success = filerClient.mv(srcDir, dstDir); + + assertTrue("Directory rename should succeed", success); + assertFalse("Source directory should not exist", filerClient.exists(srcDir)); + assertTrue("Destination directory should exist", filerClient.exists(dstDir)); + assertTrue("File should exist in destination", filerClient.exists(dstDir + "/file.txt")); + } + + @Test + public void testLookupNonExistentEntry() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + FilerProto.Entry entry = filerClient.lookupEntry(TEST_ROOT, "nonexistent.txt"); + + assertNull("Entry for non-existent file should be null", entry); + } + + @Test + public void testEmptyDirectory() { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String emptyDir = TEST_ROOT + "/emptydir"; + filerClient.mkdirs(emptyDir, 0755); + + List<FilerProto.Entry> entries = filerClient.listEntries(emptyDir); + + assertNotNull("Entries should not be null", entries); + assertTrue("Empty directory should have no entries", entries.isEmpty()); + } +} diff --git a/other/java/client/src/test/java/seaweedfs/client/SeaweedStreamIntegrationTest.java b/other/java/client/src/test/java/seaweedfs/client/SeaweedStreamIntegrationTest.java new file mode 100644 index 000000000..f384e059f --- /dev/null +++ b/other/java/client/src/test/java/seaweedfs/client/SeaweedStreamIntegrationTest.java @@ -0,0 +1,417 @@ +package seaweedfs.client; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Random; + +import static org.junit.Assert.*; + +/** + * Integration tests for SeaweedInputStream and SeaweedOutputStream. + * + * These tests verify stream operations against a running SeaweedFS instance. + * + * Prerequisites: + * - SeaweedFS master, volume server, and filer must be running + * - Default ports: filer HTTP 8888, filer gRPC 18888 + * + * To run tests: + * export SEAWEEDFS_TEST_ENABLED=true + * mvn test -Dtest=SeaweedStreamIntegrationTest + */ +public class SeaweedStreamIntegrationTest { + + private FilerClient filerClient; + private static final String TEST_ROOT = "/test-stream-integration"; + private static final boolean TESTS_ENABLED = + "true".equalsIgnoreCase(System.getenv("SEAWEEDFS_TEST_ENABLED")); + + @Before + public void setUp() throws Exception { + if (!TESTS_ENABLED) { + return; + } + + filerClient = new FilerClient("localhost", 18888); + + // Clean up any existing test directory + if (filerClient.exists(TEST_ROOT)) { + filerClient.rm(TEST_ROOT, true, true); + } + + // Create test root directory + filerClient.mkdirs(TEST_ROOT, 0755); + } + + @After + public void tearDown() throws Exception { + if (!TESTS_ENABLED || filerClient == null) { + return; + } + + try { + // Clean up test directory + if (filerClient.exists(TEST_ROOT)) { + filerClient.rm(TEST_ROOT, true, true); + } + } finally { + filerClient.shutdown(); + } + } + + @Test + public void testWriteAndReadSmallFile() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/small.txt"; + String testContent = "Hello, SeaweedFS!"; + + // Write file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(testContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Verify file exists + assertTrue("File should exist", filerClient.exists(testPath)); + + // Read file + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + assertNotNull("Entry should not be null", entry); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] buffer = new byte[testContent.length()]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + assertEquals("Should read all bytes", testContent.length(), bytesRead); + assertEquals("Content should match", testContent, new String(buffer, StandardCharsets.UTF_8)); + } + + @Test + public void testWriteAndReadLargeFile() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/large.bin"; + int fileSize = 10 * 1024 * 1024; // 10 MB + + // Generate random data + byte[] originalData = new byte[fileSize]; + new Random(42).nextBytes(originalData); // Use seed for reproducibility + + // Write file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(originalData); + outputStream.close(); + + // Verify file exists + assertTrue("File should exist", filerClient.exists(testPath)); + + // Read file + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + assertNotNull("Entry should not be null", entry); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + + // Read file in chunks to handle large files properly + byte[] readData = new byte[fileSize]; + int totalRead = 0; + int bytesRead; + byte[] buffer = new byte[8192]; // Read in 8KB chunks + + while ((bytesRead = inputStream.read(buffer)) > 0) { + System.arraycopy(buffer, 0, readData, totalRead, bytesRead); + totalRead += bytesRead; + } + inputStream.close(); + + assertEquals("Should read all bytes", fileSize, totalRead); + assertArrayEquals("Content should match", originalData, readData); + } + + @Test + public void testWriteInChunks() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/chunked.txt"; + String[] chunks = {"First chunk. ", "Second chunk. ", "Third chunk."}; + + // Write file in chunks + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + for (String chunk : chunks) { + outputStream.write(chunk.getBytes(StandardCharsets.UTF_8)); + } + outputStream.close(); + + // Read and verify + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] buffer = new byte[1024]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + String expected = String.join("", chunks); + String actual = new String(buffer, 0, bytesRead, StandardCharsets.UTF_8); + + assertEquals("Content should match", expected, actual); + } + + @Test + public void testReadWithOffset() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/offset.txt"; + String testContent = "0123456789ABCDEFGHIJ"; + + // Write file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(testContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Read with offset + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + inputStream.seek(10); // Skip first 10 bytes + + byte[] buffer = new byte[10]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + assertEquals("Should read 10 bytes", 10, bytesRead); + assertEquals("Should read from offset", "ABCDEFGHIJ", + new String(buffer, StandardCharsets.UTF_8)); + } + + @Test + public void testReadPartial() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/partial.txt"; + String testContent = "The quick brown fox jumps over the lazy dog"; + + // Write file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(testContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Read partial + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + + // Read only "quick brown" + inputStream.seek(4); + byte[] buffer = new byte[11]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + assertEquals("Should read 11 bytes", 11, bytesRead); + assertEquals("Should read partial content", "quick brown", + new String(buffer, StandardCharsets.UTF_8)); + } + + @Test + public void testEmptyFile() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/empty.txt"; + + // Write empty file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.close(); + + // Verify file exists + assertTrue("File should exist", filerClient.exists(testPath)); + + // Read empty file + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + assertNotNull("Entry should not be null", entry); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] buffer = new byte[100]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + assertEquals("Should read 0 bytes from empty file", -1, bytesRead); + } + + @Test + public void testOverwriteFile() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/overwrite.txt"; + String originalContent = "Original content"; + String newContent = "New content that overwrites the original"; + + // Write original file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(originalContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Overwrite file + outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(newContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Read and verify + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] buffer = new byte[1024]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + String actual = new String(buffer, 0, bytesRead, StandardCharsets.UTF_8); + assertEquals("Should have new content", newContent, actual); + } + + @Test + public void testMultipleReads() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/multireads.txt"; + String testContent = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + + // Write file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(testContent.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + // Read in multiple small chunks + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + + StringBuilder result = new StringBuilder(); + byte[] buffer = new byte[5]; + int bytesRead; + while ((bytesRead = inputStream.read(buffer)) > 0) { + result.append(new String(buffer, 0, bytesRead, StandardCharsets.UTF_8)); + } + inputStream.close(); + + assertEquals("Should read entire content", testContent, result.toString()); + } + + @Test + public void testBinaryData() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/binary.bin"; + byte[] binaryData = new byte[256]; + for (int i = 0; i < 256; i++) { + binaryData[i] = (byte) i; + } + + // Write binary file + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(binaryData); + outputStream.close(); + + // Read and verify + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] readData = new byte[256]; + int bytesRead = inputStream.read(readData); + inputStream.close(); + + assertEquals("Should read all bytes", 256, bytesRead); + assertArrayEquals("Binary data should match", binaryData, readData); + } + + @Test + public void testFlush() throws IOException { + if (!TESTS_ENABLED) { + System.out.println("Skipping test - SEAWEEDFS_TEST_ENABLED not set"); + return; + } + + String testPath = TEST_ROOT + "/flush.txt"; + String testContent = "Content to flush"; + + // Write file with flush + SeaweedOutputStream outputStream = new SeaweedOutputStream(filerClient, testPath); + outputStream.write(testContent.getBytes(StandardCharsets.UTF_8)); + outputStream.flush(); // Explicitly flush + outputStream.close(); + + // Verify file was written + assertTrue("File should exist after flush", filerClient.exists(testPath)); + + // Read and verify + FilerProto.Entry entry = filerClient.lookupEntry( + SeaweedOutputStream.getParentDirectory(testPath), + SeaweedOutputStream.getFileName(testPath) + ); + + SeaweedInputStream inputStream = new SeaweedInputStream(filerClient, testPath, entry); + byte[] buffer = new byte[testContent.length()]; + int bytesRead = inputStream.read(buffer); + inputStream.close(); + + assertEquals("Content should match", testContent, + new String(buffer, 0, bytesRead, StandardCharsets.UTF_8)); + } +} + |