You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@ignite.apache.org by GitBox <gi...@apache.org> on 2022/05/17 09:10:58 UTC
[GitHub] [ignite-3] tkalkirill opened a new pull request, #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
tkalkirill opened a new pull request, #808:
URL: https://github.com/apache/ignite-3/pull/808
https://issues.apache.org/jira/browse/IGNITE-16988
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r876871058
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -560,7 +296,151 @@ void testTransferFrom() throws Exception {
assertArrayEquals(expectedBytes, toByteArray(test1FilePath));
}
- // TODO: IGNITE-16988 continue write tests
+ private void checkReadOperation(IoOperation<ByteBuffer, Integer> readOperation) throws Exception {
Review Comment:
Fix it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] ibessonov commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
ibessonov commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875662316
##########
modules/file-io/pom.xml:
##########
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-parent</artifactId>
+ <version>1</version>
+ <relativePath>../../parent/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>ignite-file-io</artifactId>
+ <version>3.0.0-SNAPSHOT</version>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ </dependency>
+
+ <!-- Test dependencies -->
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
+ </dependency>
+
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-engine</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+</project>
Review Comment:
Empty line forgotten
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
Review Comment:
Can we also test slices? Also, this piece of code can be extracted in to a method, like "ByteBuffer rangeBuffer(arr, from, to)"
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testMap() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ MappedByteBuffer mmap = fileIo.map(1024);
+
+ assertNotNull(mmap);
+
+ assertEquals(0, mmap.position());
+
+ assertEquals(1024, mmap.capacity());
+ }
+
+ @Test
+ void testForce() throws Exception {
Review Comment:
This one is kinda pointless, but let's leave it. How do you even test that sync has actually been invoked? I've no idea!
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/FileIoTest.java:
##########
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ThreadLocalRandom;
+import org.junit.jupiter.api.Test;
+
+/**
+ * For {@link FileIo} testing.
+ */
+public class FileIoTest {
Review Comment:
I don't really understand, why do we need this test if there's already AbstractFileIoTest?
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/FileIoTest.java:
##########
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ThreadLocalRandom;
+import org.junit.jupiter.api.Test;
+
+/**
+ * For {@link FileIo} testing.
+ */
+public class FileIoTest {
Review Comment:
I think you should reflect the answer in javadoc so people would understand the difference
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
Review Comment:
Why does this exist?
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testMap() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ MappedByteBuffer mmap = fileIo.map(1024);
+
+ assertNotNull(mmap);
+
+ assertEquals(0, mmap.position());
+
+ assertEquals(1024, mmap.capacity());
+ }
+
+ @Test
+ void testForce() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ ByteBuffer randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes));
+
+ fileIo.force();
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+
+ randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0));
+
+ fileIo.force(true);
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+
+ randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0));
+
+ fileIo.force(false);
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+ }
+
+ @Test
+ void testSize() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(0, fileIo.size());
+
+ ByteBuffer randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes));
+
+ assertEquals(1024, fileIo.size());
+
+ assertEquals(1024, fileIoFactory.create(testFilePath).size());
+ }
+
+ @Test
+ void testClear() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ fileIo.clear();
+
+ assertEquals(0, fileIo.position());
+ assertEquals(0, fileIo.size());
+ assertArrayEquals(new byte[0], toByteArray(testFilePath));
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(randomByteArray(1024))));
+
+ fileIo.clear();
+
+ assertEquals(0, fileIo.position());
+ assertEquals(0, fileIo.size());
+ assertArrayEquals(new byte[0], toByteArray(testFilePath));
+ }
+
+ @Test
+ void testClose() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo0 = fileIoFactory.create(testFilePath);
+
+ fileIo0.close();
+
+ assertThrows(IOException.class, () -> fileIo0.read(ByteBuffer.allocate(0)));
+
+ FileIo fileIo1 = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo1.writeFully(ByteBuffer.wrap(randomByteArray(1024))));
+
+ fileIo1.close();
+
+ assertThrows(IOException.class, () -> fileIo1.read(ByteBuffer.allocate(0)));
+ }
+
+ @Test
+ void testTransferTo() throws Exception {
+ Path test0FilePath = workDir.resolve("test0");
+
+ byte[] randomByteArray = randomByteArray(1024);
+
+ writeBytes(test0FilePath, randomByteArray);
+
+ FileIo fileIo = fileIoFactory.create(test0FilePath);
+
+ Path test1FilePath = workDir.resolve("test1");
+
+ try (FileChannel fh = FileChannel.open(test1FilePath, CREATE, WRITE, READ)) {
+ assertEquals(512, fileIo.transferTo(512, 512, fh));
+ assertEquals(0, fileIo.position());
+
+ fh.force(true);
+ }
+
+ assertArrayEquals(copyOfRange(randomByteArray, 512, 1024), toByteArray(test1FilePath));
+ }
+
+ @Test
+ void testTransferFrom() throws Exception {
+ Path test0FilePath = workDir.resolve("test0");
+
+ byte[] randomByteArray = randomByteArray(1024);
+
+ writeBytes(test0FilePath, randomByteArray);
+
+ Path test1FilePath = workDir.resolve("test1");
+
+ FileIo fileIo = fileIoFactory.create(test1FilePath);
+
+ try (FileChannel fh = FileChannel.open(test0FilePath, CREATE, WRITE, READ)) {
+ assertEquals(0, fileIo.transferFrom(fh, 512, 512));
+ assertEquals(0, fileIo.position());
+
+ fileIo.writeFully(ByteBuffer.allocate(1024));
+
+ assertEquals(512, fileIo.transferFrom(fh, 512, 512));
+ assertEquals(1024, fileIo.position());
+
+ fileIo.force();
+ }
+
+ byte[] expectedBytes = new byte[1024];
+
+ System.arraycopy(randomByteArray, 0, expectedBytes, 512, 512);
+
+ assertArrayEquals(expectedBytes, toByteArray(test1FilePath));
+ }
+
+ // TODO: IGNITE-16988 continue write tests
Review Comment:
Points to the same issue
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875715159
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
Review Comment:
Modify it
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875790906
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
Review Comment:
Fix it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875791364
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testMap() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ MappedByteBuffer mmap = fileIo.map(1024);
+
+ assertNotNull(mmap);
+
+ assertEquals(0, mmap.position());
+
+ assertEquals(1024, mmap.capacity());
+ }
+
+ @Test
+ void testForce() throws Exception {
Review Comment:
Added a comment.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] ibessonov commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
ibessonov commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875934832
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -560,7 +296,151 @@ void testTransferFrom() throws Exception {
assertArrayEquals(expectedBytes, toByteArray(test1FilePath));
}
- // TODO: IGNITE-16988 continue write tests
+ private void checkReadOperation(IoOperation<ByteBuffer, Integer> readOperation) throws Exception {
Review Comment:
A little comment would be nice, like "this operation is expected to read exactly 1024 bytes from the current position" or something. This relates to other methods as well
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875690681
##########
modules/file-io/pom.xml:
##########
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-parent</artifactId>
+ <version>1</version>
+ <relativePath>../../parent/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>ignite-file-io</artifactId>
+ <version>3.0.0-SNAPSHOT</version>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ </dependency>
+
+ <!-- Test dependencies -->
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
+ </dependency>
+
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-engine</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+</project>
Review Comment:
Fix it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875692879
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/FileIoTest.java:
##########
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ThreadLocalRandom;
+import org.junit.jupiter.api.Test;
+
+/**
+ * For {@link FileIo} testing.
+ */
+public class FileIoTest {
Review Comment:
At the beginning, I ported it from 2.0, but you're right, it's no longer needed, I'll delete it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875691142
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testMap() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ MappedByteBuffer mmap = fileIo.map(1024);
+
+ assertNotNull(mmap);
+
+ assertEquals(0, mmap.position());
+
+ assertEquals(1024, mmap.capacity());
+ }
+
+ @Test
+ void testForce() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ ByteBuffer randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes));
+
+ fileIo.force();
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+
+ randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0));
+
+ fileIo.force(true);
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+
+ randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0));
+
+ fileIo.force(false);
+
+ assertArrayEquals(toByteArray(randomBytes), toByteArray(testFilePath));
+ }
+
+ @Test
+ void testSize() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(0, fileIo.size());
+
+ ByteBuffer randomBytes = ByteBuffer.wrap(randomByteArray(1024));
+
+ assertEquals(1024, fileIo.writeFully(randomBytes));
+
+ assertEquals(1024, fileIo.size());
+
+ assertEquals(1024, fileIoFactory.create(testFilePath).size());
+ }
+
+ @Test
+ void testClear() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ fileIo.clear();
+
+ assertEquals(0, fileIo.position());
+ assertEquals(0, fileIo.size());
+ assertArrayEquals(new byte[0], toByteArray(testFilePath));
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(randomByteArray(1024))));
+
+ fileIo.clear();
+
+ assertEquals(0, fileIo.position());
+ assertEquals(0, fileIo.size());
+ assertArrayEquals(new byte[0], toByteArray(testFilePath));
+ }
+
+ @Test
+ void testClose() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo0 = fileIoFactory.create(testFilePath);
+
+ fileIo0.close();
+
+ assertThrows(IOException.class, () -> fileIo0.read(ByteBuffer.allocate(0)));
+
+ FileIo fileIo1 = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo1.writeFully(ByteBuffer.wrap(randomByteArray(1024))));
+
+ fileIo1.close();
+
+ assertThrows(IOException.class, () -> fileIo1.read(ByteBuffer.allocate(0)));
+ }
+
+ @Test
+ void testTransferTo() throws Exception {
+ Path test0FilePath = workDir.resolve("test0");
+
+ byte[] randomByteArray = randomByteArray(1024);
+
+ writeBytes(test0FilePath, randomByteArray);
+
+ FileIo fileIo = fileIoFactory.create(test0FilePath);
+
+ Path test1FilePath = workDir.resolve("test1");
+
+ try (FileChannel fh = FileChannel.open(test1FilePath, CREATE, WRITE, READ)) {
+ assertEquals(512, fileIo.transferTo(512, 512, fh));
+ assertEquals(0, fileIo.position());
+
+ fh.force(true);
+ }
+
+ assertArrayEquals(copyOfRange(randomByteArray, 512, 1024), toByteArray(test1FilePath));
+ }
+
+ @Test
+ void testTransferFrom() throws Exception {
+ Path test0FilePath = workDir.resolve("test0");
+
+ byte[] randomByteArray = randomByteArray(1024);
+
+ writeBytes(test0FilePath, randomByteArray);
+
+ Path test1FilePath = workDir.resolve("test1");
+
+ FileIo fileIo = fileIoFactory.create(test1FilePath);
+
+ try (FileChannel fh = FileChannel.open(test0FilePath, CREATE, WRITE, READ)) {
+ assertEquals(0, fileIo.transferFrom(fh, 512, 512));
+ assertEquals(0, fileIo.position());
+
+ fileIo.writeFully(ByteBuffer.allocate(1024));
+
+ assertEquals(512, fileIo.transferFrom(fh, 512, 512));
+ assertEquals(1024, fileIo.position());
+
+ fileIo.force();
+ }
+
+ byte[] expectedBytes = new byte[1024];
+
+ System.arraycopy(randomByteArray, 0, expectedBytes, 512, 512);
+
+ assertArrayEquals(expectedBytes, toByteArray(test1FilePath));
+ }
+
+ // TODO: IGNITE-16988 continue write tests
Review Comment:
Remove it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] ibessonov merged pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
ibessonov merged PR #808:
URL: https://github.com/apache/ignite-3/pull/808
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875695822
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
+
+ @Test
+ void testPosition() throws Exception {
+ FileIo fileIo = fileIoFactory.create(workDir.resolve("test"));
+
+ assertEquals(0, fileIo.position());
+
+ fileIo.position(100);
+
+ assertEquals(100, fileIo.position());
+ }
+
+ @Test
+ void testRead() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.read(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.read(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), toByteArray(buffer));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind()));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), toByteArray(buffer));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind()));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testReadByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer.rewind(), 2 * 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), toByteArray(buffer));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer.rewind(), 4 * 1024));
+ assertEquals(0, fileIo.position());
+ }
+
+ @Test
+ void testReadToByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ writeBytes(testFilePath, randomBytes);
+
+ byte[] buffer = new byte[1024];
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 0, 1024), buffer);
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 1024, 2 * 1024), buffer);
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 2 * 1024, 3 * 1024), buffer);
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.readFully(buffer, 0, 1024));
+ assertArrayEquals(copyOfRange(randomBytes, 3 * 1024, 4 * 1024), buffer);
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(-1, fileIo.readFully(buffer, 0, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+ }
+
+ @Test
+ void testWrite() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPosition() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.write(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.write(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArray() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.write(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.write(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.write(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 0, 1024))));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024))));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 2 * 1024, 3 * 1024))));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024))));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0])));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteByPositionFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 1024, 2 * 1024)), 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(ByteBuffer.wrap(copyOfRange(randomBytes, 3 * 1024, 4 * 1024)), 2 * 1024));
+ assertEquals(0, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(ByteBuffer.wrap(new byte[0]), 3 * 1024));
+ assertEquals(0, fileIo.position());
+
+ fileIo.force();
+
+ byte[] expectedBytes = new byte[3 * 1024];
+
+ System.arraycopy(randomBytes, 1024, expectedBytes, 1024, 1024);
+ System.arraycopy(randomBytes, 3 * 1024, expectedBytes, 2 * 1024, 1024);
+
+ assertArrayEquals(expectedBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testWriteFromByteArrayFully() throws Exception {
+ byte[] randomBytes = randomByteArray(4 * 1024);
+
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 0, 1024));
+ assertEquals(1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 1024, 1024));
+ assertEquals(2 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 2 * 1024, 1024));
+ assertEquals(3 * 1024, fileIo.position());
+
+ assertEquals(1024, fileIo.writeFully(randomBytes, 3 * 1024, 1024));
+ assertEquals(4 * 1024, fileIo.position());
+
+ assertEquals(0, fileIo.writeFully(randomBytes, 4 * 1024, 0));
+ assertEquals(4 * 1024, fileIo.position());
+
+ fileIo.force();
+
+ assertArrayEquals(randomBytes, toByteArray(testFilePath));
+ }
+
+ @Test
+ void testMap() throws Exception {
+ Path testFilePath = workDir.resolve("test");
+
+ FileIo fileIo = fileIoFactory.create(testFilePath);
+
+ MappedByteBuffer mmap = fileIo.map(1024);
+
+ assertNotNull(mmap);
+
+ assertEquals(0, mmap.position());
+
+ assertEquals(1024, mmap.capacity());
+ }
+
+ @Test
+ void testForce() throws Exception {
Review Comment:
Here I check only the basic functionality: that there will be no errors when calling **FileIo#force** and that the data will actually be flushed to disk.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] tkalkirill commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
tkalkirill commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875697618
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
Review Comment:
For a simple check that the factory returns the correct instance.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [ignite-3] ibessonov commented on a diff in pull request #808: IGNITE-16988 [Native Persistence 3.0] Porting FileIO from 2.0
Posted by GitBox <gi...@apache.org>.
ibessonov commented on code in PR #808:
URL: https://github.com/apache/ignite-3/pull/808#discussion_r875778067
##########
modules/file-io/src/test/java/org/apache/ignite/internal/fileio/AbstractFileIoTest.java:
##########
@@ -0,0 +1,588 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.fileio;
+
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+import static java.util.Arrays.copyOfRange;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadLocalRandom;
+import org.apache.ignite.internal.testframework.WorkDirectory;
+import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * An abstract class for testing {@link FileIo} implementations.
+ */
+@ExtendWith(WorkDirectoryExtension.class)
+public abstract class AbstractFileIoTest {
+ protected FileIoFactory fileIoFactory;
+
+ @WorkDirectory
+ protected Path workDir;
+
+ @Test
+ abstract void testFileIoFactory() throws Exception;
Review Comment:
Can you generify this test by introducing method like "abstract Class<? extends FileIoFactory> getIoFactoryClass()"?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org