FileChannelsTest

/*
 * 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
 *
 *      https://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.commons.io.channels;

import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.Files;
import java.nio.file.Path;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.file.AbstractTempDirTest;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.junitpioneer.jupiter.cartesian.CartesianTest;
import org.junitpioneer.jupiter.cartesian.CartesianTest.Values;

/**
 * Tests {@link FileChannels}.
 */
class FileChannelsTest extends AbstractTempDirTest {

    enum FileChannelType {
        STOCK, PROXY, NON_BLOCKING, FIXED_READ_SIZE
    }

    private static final int LARGE_FILE_SIZE = Integer.getInteger(FileChannelsTest.class.getSimpleName(), 100_000);

    private static final int SMALL_BUFFER_SIZE = 1024;
    private static final String CONTENT = StringUtils.repeat("x", SMALL_BUFFER_SIZE);

    @SuppressWarnings("resource") // Caller closes
    private static FileChannel getChannel(final FileInputStream inNotEmpty, final FileChannelType fileChannelType, final int readSize) throws IOException {
        return wrap(inNotEmpty.getChannel(), fileChannelType, readSize);
    }

    private static int half(final int bufferSize) {
        return Math.max(1, bufferSize / 2);
    }

    private static boolean isEmpty(final File empty) {
        return empty.length() == 0;
    }

    @SuppressWarnings("resource") // Caller closes
    private static FileChannel open(final Path path, final FileChannelType fileChannelType, final int readSize) throws IOException {
        return wrap(FileChannel.open(path), fileChannelType, readSize);
    }

    private static FileChannel reset(final FileChannel fc) throws IOException {
        return fc.position(0);
    }

    private static byte reverse(final byte b) {
        return (byte) (~b & 0xff);
    }

    private static FileChannel wrap(final FileChannel fc, final FileChannelType fileChannelType, final int readSize) throws IOException {
        switch (fileChannelType) {
        case NON_BLOCKING:
            return new NonBlockingFileChannelProxy(fc);
        case STOCK:
            return fc;
        case PROXY:
            return new FileChannelProxy(fc);
        case FIXED_READ_SIZE:
            return new FixedReadSizeFileChannelProxy(fc, readSize);
        default:
            throw new UnsupportedOperationException("Unexpected FileChannelType " + fileChannelType);
        }
    }

    private boolean contentEquals(final InputStream in1, final InputStream in2, final int bufferCapacity) throws IOException {
        return FileChannels.contentEquals(Channels.newChannel(in1), Channels.newChannel(in2), bufferCapacity);
    }

    private void testContentEquals(final String content1, final String content2, final int bufferSize, final FileChannelType fileChannelType)
            throws IOException {
        assertTrue(FileChannels.contentEquals(null, null, bufferSize));
        // Prepare test files with same size but different content
        // (first 3 bytes are different, followed by a large amount of equal content)
        final File file1 = new File(tempDirFile, "test1.txt");
        final File file2 = new File(tempDirFile, "test2.txt");
        FileUtils.writeStringToFile(file1, content1, US_ASCII);
        FileUtils.writeStringToFile(file2, content2, US_ASCII);
        // File checksums are different
        assertNotEquals(FileUtils.checksumCRC32(file1), FileUtils.checksumCRC32(file2));
        // content not equals
        try (FileInputStream in1 = new FileInputStream(file1);
                FileInputStream in2 = new FileInputStream(file2);
                FileChannel channel1 = getChannel(in1, fileChannelType, bufferSize);
                FileChannel channel2 = getChannel(in2, fileChannelType, half(bufferSize))) {
            assertFalse(FileChannels.contentEquals(channel1, channel2, bufferSize));
        }
        // content not equals
        try (FileInputStream in1 = new FileInputStream(file1);
                FileInputStream in2 = new FileInputStream(file2);
                FileChannel channel1 = getChannel(in1, fileChannelType, bufferSize);
                FileChannel channel2 = getChannel(in2, fileChannelType, half(bufferSize))) {
            assertTrue(FileChannels.contentEquals(channel1, channel1, bufferSize));
            assertTrue(FileChannels.contentEquals(channel2, channel2, bufferSize));
        }
    }

    @CartesianTest()
    void testContentEqualsDifferentPostfix(
            @Values(ints = { 1, 2, IOUtils.DEFAULT_BUFFER_SIZE / 10, IOUtils.DEFAULT_BUFFER_SIZE, IOUtils.DEFAULT_BUFFER_SIZE * 10 }) final int bufferSize,
            @CartesianTest.Enum final FileChannelType fileChannelType) throws IOException {
        testContentEquals(CONTENT + "ABC", CONTENT + "XYZ", bufferSize, fileChannelType);
    }

    @CartesianTest()
    void testContentEqualsDifferentPrefix(
            @Values(ints = { 1, 2, IOUtils.DEFAULT_BUFFER_SIZE / 10, IOUtils.DEFAULT_BUFFER_SIZE, IOUtils.DEFAULT_BUFFER_SIZE * 10 }) final int bufferSize,
            @CartesianTest.Enum final FileChannelType fileChannelType) throws IOException {
        testContentEquals("ABC" + CONTENT, "XYZ" + CONTENT, bufferSize, fileChannelType);
    }

    @CartesianTest()
    void testContentEqualsEmpty(
            @Values(ints = { 1, 2, IOUtils.DEFAULT_BUFFER_SIZE / 10, IOUtils.DEFAULT_BUFFER_SIZE, IOUtils.DEFAULT_BUFFER_SIZE * 10 }) final int bufferSize,
            @CartesianTest.Enum final FileChannelType fileChannelType) throws IOException {
        assertTrue(FileChannels.contentEquals(null, null, bufferSize));
        // setup fixtures
        final File empty = new File(tempDirFile, "empty.txt");
        final File notEmpty = new File(tempDirFile, "not-empty.txt");
        FileUtils.writeStringToFile(empty, StringUtils.EMPTY, US_ASCII);
        FileUtils.writeStringToFile(notEmpty, "X", US_ASCII);
        assertTrue(isEmpty(empty));
        assertFalse(isEmpty(notEmpty));
        // File checksums are different
        assertNotEquals(FileUtils.checksumCRC32(empty), FileUtils.checksumCRC32(notEmpty));
        try (FileInputStream inEmpty = new FileInputStream(empty);
                FileInputStream inNotEmpty = new FileInputStream(notEmpty);
                FileChannel channelEmpty = getChannel(inEmpty, fileChannelType, bufferSize);
                FileChannel channelNotEmpty = getChannel(inNotEmpty, fileChannelType, half(bufferSize))) {
            assertFalse(FileChannels.contentEquals(channelEmpty, channelNotEmpty, bufferSize));
            assertFalse(FileChannels.contentEquals(null, channelNotEmpty, bufferSize));
            assertFalse(FileChannels.contentEquals(channelNotEmpty, null, bufferSize));
            assertTrue(FileChannels.contentEquals(channelEmpty, channelEmpty, bufferSize));
            assertTrue(FileChannels.contentEquals(null, channelEmpty, bufferSize));
            assertTrue(FileChannels.contentEquals(channelEmpty, null, bufferSize));
            assertTrue(FileChannels.contentEquals(channelNotEmpty, channelNotEmpty, bufferSize));
        }
    }

    @CartesianTest
    void testContentEqualsFileChannel(
            @Values(ints = { 1, 2, IOUtils.DEFAULT_BUFFER_SIZE / 10, IOUtils.DEFAULT_BUFFER_SIZE, IOUtils.DEFAULT_BUFFER_SIZE * 10 }) final int bufferSize)
            throws IOException {
        final FileChannelType fileChannelType = FileChannelType.STOCK;
        final Path bigFile1 = Files.createTempFile(getClass().getSimpleName(), "-1.bin");
        final Path bigFile2 = Files.createTempFile(getClass().getSimpleName(), "-2.bin");
        final Path bigFile3 = Files.createTempFile(getClass().getSimpleName(), "-3.bin");
        try {
            // This length must match any restriction from the Surefire configuration.
            final int newLength = LARGE_FILE_SIZE;
            final byte[] bytes1 = new byte[newLength];
            final byte[] bytes2 = new byte[newLength];
            // Make sure bytes1 and bytes2 are different despite the shuffle
            ArrayUtils.shuffle(bytes1);
            bytes1[0] = 1;
            ArrayUtils.shuffle(bytes2);
            bytes2[0] = 2;
            Files.write(bigFile1, bytes1);
            Files.write(bigFile2, bytes2);
            try (FileChannel fc1 = open(bigFile1, fileChannelType, bufferSize); FileChannel fc2 = open(bigFile2, fileChannelType, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals(fc1, fc2, bufferSize));
                assertFalse(FileChannels.contentEquals(reset(fc2), reset(fc1), bufferSize));
                assertTrue(FileChannels.contentEquals(reset(fc1), reset(fc1), bufferSize));
            }
            // Make the LAST byte different.
            byte[] bytes3 = bytes1.clone();
            final int last = bytes3.length - 1;
            bytes3[last] = reverse(bytes3[last]);
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals(fc1, fc3, bufferSize));
                assertFalse(FileChannels.contentEquals(reset(fc3), reset(fc1), bufferSize));
                // Test just the last byte
                fc1.position(last);
                fc3.position(last);
                assertFalse(FileChannels.contentEquals(fc1, fc3, bufferSize));
            }
            // Make the LAST byte equal.
            bytes3 = bytes1.clone();
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType, half(bufferSize))) {
                // Test just the last byte
                fc1.position(last);
                fc3.position(last);
                assertTrue(FileChannels.contentEquals(fc1, fc3, bufferSize));
            }
            // Make a byte in the middle different
            bytes3 = bytes1.clone();
            final int middle = bytes3.length / 2;
            bytes3[middle] = reverse(bytes3[middle]);
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals(fc1, fc3, bufferSize));
                assertFalse(FileChannels.contentEquals(reset(fc3), reset(fc1), bufferSize));
            }
        } finally {
            // Delete ASAP
            Files.deleteIfExists(bigFile1);
            Files.deleteIfExists(bigFile2);
            Files.deleteIfExists(bigFile3);
        }
    }

    @CartesianTest()
    void testContentEqualsSeekableByteChannel(
            @Values(ints = { 1, 2, IOUtils.DEFAULT_BUFFER_SIZE / 10, IOUtils.DEFAULT_BUFFER_SIZE, IOUtils.DEFAULT_BUFFER_SIZE * 10 }) final int bufferSize,
            @CartesianTest.Enum final FileChannelType fileChannelType1, @CartesianTest.Enum final FileChannelType fileChannelType2) throws IOException {
        final Path bigFile1 = Files.createTempFile(getClass().getSimpleName(), "-1.bin");
        final Path bigFile2 = Files.createTempFile(getClass().getSimpleName(), "-2.bin");
        final Path bigFile3 = Files.createTempFile(getClass().getSimpleName(), "-3.bin");
        try {
            // This length must match any restriction from the Surefire configuration.
            final int newLength = LARGE_FILE_SIZE;
            final byte[] bytes1 = new byte[newLength];
            final byte[] bytes2 = new byte[newLength];
            // Make sure bytes1 and bytes2 are different despite the shuffle
            ArrayUtils.shuffle(bytes1);
            bytes1[0] = 1;
            ArrayUtils.shuffle(bytes2);
            bytes2[0] = 2;
            Files.write(bigFile1, bytes1);
            Files.write(bigFile2, bytes2);
            try (FileChannel fc1 = open(bigFile1, fileChannelType1, bufferSize); FileChannel fc2 = open(bigFile2, fileChannelType2, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) fc1, fc2, bufferSize));
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) reset(fc2), reset(fc1), bufferSize));
                assertTrue(FileChannels.contentEquals((SeekableByteChannel) reset(fc1), reset(fc1), bufferSize));
            }
            // Make the LAST byte different.
            byte[] bytes3 = bytes1.clone();
            final int last = bytes3.length - 1;
            bytes3[last] = reverse(bytes3[last]);
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType1, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType2, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) fc1, fc3, bufferSize));
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) reset(fc3), reset(fc1), bufferSize));
                // Test just the last byte
                fc1.position(last);
                fc3.position(last);
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) fc1, fc3, bufferSize));
            }
            // Make the LAST byte equal.
            bytes3 = bytes1.clone();
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType1, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType2, half(bufferSize))) {
                // Test just the last byte
                fc1.position(last);
                fc3.position(last);
                assertTrue(FileChannels.contentEquals((SeekableByteChannel) fc1, fc3, bufferSize));
            }
            // Make a byte in the middle different
            bytes3 = bytes1.clone();
            final int middle = bytes3.length / 2;
            bytes3[middle] = reverse(bytes3[middle]);
            Files.write(bigFile3, bytes3);
            try (FileChannel fc1 = open(bigFile1, fileChannelType1, bufferSize); FileChannel fc3 = open(bigFile3, fileChannelType2, half(bufferSize))) {
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) fc1, fc3, bufferSize));
                assertFalse(FileChannels.contentEquals((SeekableByteChannel) reset(fc3), reset(fc1), bufferSize));
            }
        } finally {
            // Delete ASAP
            Files.deleteIfExists(bigFile1);
            Files.deleteIfExists(bigFile2);
            Files.deleteIfExists(bigFile3);
        }
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 2, 4, 8, 16, 1024, 4096, 8192 })
    void testContentEqualsSequenceInputStream(final int bufferCapacity) throws Exception {
        // not equals
        // @formatter:off
        assertFalse(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("a".getBytes()),
                    new ByteArrayInputStream("b-".getBytes())), bufferCapacity));
        assertFalse(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("a-".getBytes()),
                    new ByteArrayInputStream("b".getBytes())), bufferCapacity));
        assertFalse(contentEquals(
                new ByteArrayInputStream("ab-".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("a".getBytes()),
                    new ByteArrayInputStream("b".getBytes())), bufferCapacity));
        assertFalse(contentEquals(
                new ByteArrayInputStream("".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("a".getBytes()),
                    new ByteArrayInputStream("b".getBytes())), bufferCapacity));
        assertFalse(contentEquals(
                new ByteArrayInputStream("".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("".getBytes()),
                    new ByteArrayInputStream("b".getBytes())), bufferCapacity));
        assertFalse(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("".getBytes()),
                    new ByteArrayInputStream("".getBytes())), bufferCapacity));
        // equals
        assertTrue(contentEquals(
                new ByteArrayInputStream("".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("".getBytes()),
                    new ByteArrayInputStream("".getBytes())), bufferCapacity));
        assertTrue(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("a".getBytes()),
                    new ByteArrayInputStream("b".getBytes())), bufferCapacity));
        assertTrue(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("ab".getBytes()),
                    new ByteArrayInputStream("".getBytes())), bufferCapacity));
        assertTrue(contentEquals(
                new ByteArrayInputStream("ab".getBytes()),
                new SequenceInputStream(
                    new ByteArrayInputStream("".getBytes()),
                    new ByteArrayInputStream("ab".getBytes())), bufferCapacity));
        // @formatter:on
    }
}