computer-test/src/main/java/com/baidu/hugegraph/computer/core/io/BufferedFileTest.java - incubator-hugegraph-computer - Git at Google

 /*
  * Copyright 2017 HugeGraph Authors
  *
  * 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 com.baidu.hugegraph.computer.core.io;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.EOFException;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.util.Random;
 import java.util.UUID;

 import org.apache.commons.io.FileUtils;
 import org.junit.Test;
 import org.slf4j.Logger;

 import com.baidu.hugegraph.computer.core.common.Constants;
 import com.baidu.hugegraph.computer.core.store.entry.EntriesUtil;
 import com.baidu.hugegraph.computer.suite.unit.UnitTestBase;
 import com.baidu.hugegraph.testutil.Assert;
 import com.baidu.hugegraph.util.Log;

 public class BufferedFileTest {

     private static final Logger LOG = Log.logger(
                                           BufferedFileTest.class);
     private static final int BUFFER_SIZE = 128;

     @Test
     public void testConstructor() throws IOException {
         File file  = createTempFile();
         try {
             try (BufferedFileOutput output = new BufferedFileOutput(file)) {
                 Assert.assertEquals(0, output.position());
             }
             try (BufferedFileInput input = new BufferedFileInput(file)) {
                 Assert.assertEquals(0, input.position());
             }
             Assert.assertThrows(IllegalArgumentException.class, () -> {
                 new BufferedFileOutput(new RandomAccessFile(file,
                                        Constants.FILE_MODE_WRITE),
                                        1);
             }, e -> {
                 Assert.assertContains("The parameter bufferSize must be >= 8",
                                       e.getMessage());
             });
             Assert.assertThrows(IllegalArgumentException.class, () -> {
                 new BufferedFileInput(new RandomAccessFile(file,
                                       Constants.FILE_MODE_READ),
                                       1);
             }, e -> {
                 Assert.assertContains("The parameter bufferSize must be >= 8",
                                       e.getMessage());
             });
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testInt() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     output.writeInt(i);
                 }
                 output.writeInt(Integer.MAX_VALUE);
                 output.writeInt(Integer.MIN_VALUE);
             }
             try (BufferedFileInput input = createInput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     Assert.assertEquals(i, input.readInt());
                 }
                 Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
                 Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testWriteIntWithPosition() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     output.writeInt(i);
                 }
                 output.writeFixedInt(0, 1);
                 output.writeFixedInt(12, 2);
                 // Next buffer
                 output.writeFixedInt(200, 3);
                 // Previous buffer
                 output.writeFixedInt(100, 4);
                 output.writeInt(Integer.MAX_VALUE);
                 output.writeInt(Integer.MIN_VALUE);
                 // Current buffer
                 output.writeInt(5);
                 output.writeFixedInt(output.position() - Integer.BYTES, 6);
             }

             try (BufferedFileInput input = createInput(file)) {
                 for (int i = 0; i < 256; i++) {
                     int expectValue = i - 128;
                     int position = i * 4;
                     int readValue = input.readInt();
                     if (position != 0 && position != 12 &&
                         position != 200 && position != 100 &&
                         position != 1000) {
                         Assert.assertEquals(expectValue, readValue);
                     }
                 }
                 input.seek(0);
                 Assert.assertEquals(1, input.readInt());
                 input.seek(12);
                 Assert.assertEquals(2, input.readInt());
                 input.seek(200);
                 Assert.assertEquals(3, input.readInt());
                 input.seek(100);
                 Assert.assertEquals(4, input.readInt());
                 input.seek(256 * 4);
                 Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
                 Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
                 Assert.assertEquals(6, input.readInt());
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testByteArray() throws IOException {
         int loopTimes = 129;
         byte[] array = UnitTestBase.randomBytes(10);
         File file = createTempFile();
         try (BufferedFileOutput output = createOutput(file)) {
             for (int i = 0; i < loopTimes; i++) {
                 output.write(array);
             }
         }

         byte[] arrayRead = new byte[10];
         try (DataInputStream dis = new DataInputStream(
                                    new FileInputStream(file))) {
             for (int i = 0; i < loopTimes; i++) {
                 dis.readFully(arrayRead);
                 Assert.assertArrayEquals(array, arrayRead);
             }
         }
         try (BufferedFileInput input = createInput(file)) {
             for (int i = 0; i < loopTimes; i++) {
                 input.readFully(arrayRead);
                 Assert.assertArrayEquals(array, arrayRead);
             }
         }
         FileUtils.deleteQuietly(file);
     }

     @Test
     public void testLargeByteArray() throws IOException {
         int loopTimes = 10;
         int arraySize = 1280; // large than buffer size
         byte[] array = UnitTestBase.randomBytes(arraySize);
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = 0; i < loopTimes; i++) {
                     output.write(array);
                 }
             }

             byte[] arrayRead = new byte[arraySize];
             try (BufferedFileInput input = createInput(file)) {
                 for (int i = 0; i < loopTimes; i++) {
                     input.readFully(arrayRead);
                     Assert.assertArrayEquals(array, arrayRead);
                 }
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testInputSeekAtRandom() throws IOException {
         int size = 128;
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = 0; i < size; i++) {
                     output.writeInt(i);
                 }
                 for (int i = size; i >= 0; i--) {
                     output.seek(i * 4);
                     output.writeInt(size - i);
                 }
             }
             Random random = new Random(1001);
             try (BufferedFileInput input = createInput(file)) {
                 for (int i = 0; i <= 10; i++) {
                     long position = 4 * random.nextInt(size);
                     input.seek(position);
                     Assert.assertEquals(size - position / 4, input.readInt());
                 }
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testInputSeekOutRange() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 output.writeInt(1);
                 output.writeInt(2);
                 output.writeInt(3);
             }

             try (BufferedFileInput input = createInput(file)) {
                 Assert.assertEquals(1, input.readInt());
                 input.skip(4);
                 Assert.assertThrows(EOFException.class, () -> {
                     input.seek(13); // Out of range
                 }, e -> {
                     Assert.assertContains("reach the end of file",
                                           e.getMessage());
                 });
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testOutputSeekOutRange() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 output.seek(100L);
                 output.writeInt(1);
                 output.seek(511L);
                 output.writeInt(2);
             }

             try (BufferedFileInput input = createInput(file)) {
                 input.seek(100L);
                 Assert.assertEquals(1, input.readInt());
                 input.seek(511L);
                 Assert.assertEquals(2, input.readInt());
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testSeekAtEnd() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     output.writeInt(i);
                 }
                 // Overwrite last 2 elements
                 output.seek(256 * 4 - 8);
                 output.writeInt(Integer.MAX_VALUE);
                 output.writeInt(Integer.MIN_VALUE);
             }

             try (BufferedFileInput input = createInput(file)) {
                 for (int i = -128; i <= 125; i++) {
                     Assert.assertEquals(i, input.readInt());
                 }
                 Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
                 Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
                 input.seek(input.position() - 8);
                 Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
                 Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testSkip() throws IOException {
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     output.writeByte(i);
                 }
                 output.skip(4L);
                 output.writeByte(127);
                 output.skip(4L);
                 output.skip(1280L);
                 output.writeByte(1);
                 Assert.assertThrows(IllegalArgumentException.class, () -> {
                     output.skip(-1);
                 }, e -> {
                     e.getMessage().contains("The parameter bytesToSkip must " +
                                             "be >= 0");
                 });
             }

             try (BufferedFileInput input = createInput(file)) {
                 for (int i = -128; i <= 127; i++) {
                     Assert.assertEquals(i, input.readByte());
                 }
                 input.skip(4);
                 Assert.assertEquals(127, input.readByte());
                 input.skip(4);
                 input.skip(1280);
                 Assert.assertEquals((byte) 1, input.readByte());
                 Assert.assertThrows(IllegalArgumentException.class, () -> {
                     input.skip(-1);
                 }, e -> {
                     e.getMessage().contains("The parameter bytesToSkip must " +
                                             "be >= 0");
                 });
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testPosition() throws IOException {
         int size = 1024;
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = 0; i < size; i++) {
                     Assert.assertEquals(i * 4, output.position());
                     output.writeInt(i);
                 }
             }
             try (BufferedFileInput input = createInput(file)) {
                 for (int i = 0; i < size; i++) {
                     Assert.assertEquals(i * 4, input.position());
                     Assert.assertEquals(i, input.readInt());
                 }

                 Random random = new Random();
                 for (int i = 0; i < 10; i++) {
                     long position = 4 * random.nextInt(size);
                     input.seek(position);
                     Assert.assertEquals(position / 4, input.readInt());
                     Assert.assertEquals(position + 4, input.position());
                 }
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testAvailable() throws IOException {
         int size = 1024;
         File file = createTempFile();
         try {
             try (BufferedFileOutput output = createOutput(file)) {
                 for (int i = 0; i < size; i++) {
                     output.writeInt(i);
                 }
             }
             try (BufferedFileInput input = createInput(file)) {
                 for (int i = 0; i < size; i++) {
                     Assert.assertEquals(4096 - i * 4, input.available());
                     Assert.assertEquals(i, input.readInt());
                 }
             }
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testLongPerformanceUnsafe() throws IOException {
         long size = 1024;
         long startTime;
         long endTime;
         long time;
         File file = new File("long-unsafe.bin");
         try {
             startTime = System.currentTimeMillis();
             try (BufferedFileOutput output = new BufferedFileOutput(file)) {
                 for (long i = 0; i < size / 8; i++) {
                     output.writeLong(i);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Write {} bytes use BufferedFileOutput.writeLong " +
                      "takes {} ms", size, time);

             startTime = System.currentTimeMillis();
             try (BufferedFileInput input = new BufferedFileInput(file)) {
                 for (long i = 0; i < size / 8; i++) {
                     input.readLong();
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use BufferedFileInput.readLong " +
                      "takes {} ms", size, time);
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testLongPerformanceNormal() throws IOException {
         long size = 1024;
         long startTime;
         long endTime;
         long time;

         File file = new File("long-data.bin");
         try {
             startTime = System.currentTimeMillis();
             try (DataOutputStream output = new DataOutputStream(
                                            new BufferedOutputStream(
                                            new FileOutputStream(file)))) {
                 for (long i = 0; i < size / 8; i++) {
                     output.writeLong(i);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Write {} bytes use DataOutputStream.writeLong" +
                      " takes {} ms", size, time);

             startTime = System.currentTimeMillis();
             try (DataInputStream input = new DataInputStream(
                                          new BufferedInputStream(
                                          new FileInputStream(file)))) {
                 for (long i = 0; i < size / 8; i++) {
                     input.readLong();
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use DataInputStream.readLong " +
                      "takes {} ms", size, time);
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testIntPerformanceIntUnsafe() throws IOException {
         int size = 1024;
         long startTime;
         long endTime;
         File file = new File("int-unsafe.bin");
         try {
             startTime = System.currentTimeMillis();
             try (BufferedFileOutput output = new BufferedFileOutput(file)) {
                 for (int i = 0; i < size / 4; i++) {
                     output.writeInt(i);
                 }
             }
             endTime = System.currentTimeMillis();
             long time = endTime - startTime;
             LOG.info("Write {} bytes use BufferedFileOutput.writeInt " +
                      "takes {} ms", size, time);

             startTime = System.currentTimeMillis();
             try (BufferedFileInput input = new BufferedFileInput(file)) {
                 for (int i = 0; i < size / 4; i++) {
                     input.readInt();
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use BufferedFileInput.readInt " +
                      "takes {} ms", size, time);
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testIntPerformanceNormal() throws IOException {
         int size = 1024;
         long startTime;
         long endTime;
         long time;
         File dataFile = new File("int-data-out.bin");
         try {
             startTime = System.currentTimeMillis();
             try (DataOutputStream output = new DataOutputStream(
                                            new BufferedOutputStream(
                                            new FileOutputStream(dataFile)))) {
                 for (int i = 0; i < size / 4; i++) {
                     output.writeInt(i);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Write {} bytes use DataOutputStream.writeInt " +
                      "takes {} ms", size, time);

             startTime = System.currentTimeMillis();
             try (DataInputStream input = new DataInputStream(
                                          new BufferedInputStream(
                                          new FileInputStream(dataFile)))) {
                 for (int i = 0; i < size / 4; i++) {
                     input.readInt();
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use DataInputStream.readInt " +
                      "takes {} ms", size, time);
         } finally {
             FileUtils.deleteQuietly(dataFile);
         }
     }

     @Test
     public void testByteArrayPerformanceUnsafe() throws IOException {
         int size = 1024;
         long startTime;
         long endTime;
         long time;
         byte[] writeArray = UnitTestBase.randomBytes(16);
         byte[] readArray = new byte[16];

         File file = new File("int-unsafe-out.bin");
         try {
             startTime = System.currentTimeMillis();
             try (BufferedFileOutput output = new BufferedFileOutput(file)) {
                 for (int i = 0; i < size / writeArray.length; i++) {
                     output.write(writeArray);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Write {} bytes use BufferedFileOutput" +
                      ".write takes {} ms", size, time);

             startTime = System.currentTimeMillis();
             try (BufferedFileInput input = new BufferedFileInput(file)) {
                 for (int i = 0; i < size / readArray.length; i++) {
                     input.readFully(readArray);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use BufferedFileInput.readFully " +
                      "takes {} ms", size, time);
         } finally {
             FileUtils.deleteQuietly(file);
         }
     }

     @Test
     public void testByteArrayPerformanceNormal() throws IOException {
         int size = 1024;
         long startTime;
         long endTime;
         long time;
         byte[] writeArray = UnitTestBase.randomBytes(16);
         byte[] readArray = new byte[16];
         File dataFile = new File("int-data-out.bin");
         try {
             startTime = System.currentTimeMillis();
             try (DataOutputStream output = new DataOutputStream(
                                            new BufferedOutputStream(
                                            new FileOutputStream(dataFile)))) {
                 for (int i = 0; i < size / writeArray.length; i++) {
                     output.write(writeArray);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Write {} bytes use DataOutputStream.write takes {} ms",
                      size, time);

             startTime = System.currentTimeMillis();
             try (DataInputStream input = new DataInputStream(
                                          new BufferedInputStream(
                                          new FileInputStream(dataFile)))) {
                 for (int i = 0; i < size / writeArray.length; i++) {
                     input.readFully(readArray);
                 }
             }
             endTime = System.currentTimeMillis();
             time = endTime - startTime;
             LOG.info("Read {} bytes use DataInputStream.readFully takes {} ms",
                      size, time);
         } finally {
             FileUtils.deleteQuietly(dataFile);
         }
     }

     @Test
     public void testCompare() throws IOException {
         // BufferedFileInput compare to BufferedFileInput
         File file1 = createTempFile();
         File file2 = createTempFile();
         try (BufferedFileInput input1 = inputByString(file1, "apple");
              BufferedFileInput input2 = inputByString(file2, "banana")) {
             int result = input1.compare(0, input1.available(), input2, 0,
                                         input2.available());
             Assert.assertLt(0, result);
         } finally {
             FileUtils.deleteQuietly(file1);
             FileUtils.deleteQuietly(file2);
         }

         // UnsafeBytesInput compare to BufferedFileInput
         File file3 = createTempFile();
         try (BufferedFileInput fileInput = inputByString(file3, "apple")) {
             @SuppressWarnings("resource")
             UnsafeBytesOutput output = new UnsafeBytesOutput(
                                        Constants.SMALL_BUF_SIZE);
             output.writeBytes("banana");
             @SuppressWarnings("resource")
             RandomAccessInput input = new UnsafeBytesInput(output.buffer());
             int result = input.compare(0, input.available(), fileInput, 0,
                                         fileInput.available());
             Assert.assertGt(0, result);
         } finally {
             FileUtils.deleteQuietly(file3);
         }
     }

     @Test
     public void testCompareDiffRange() throws IOException {
         File file1, file2;

         // BufferedFileInput compare to other RandomAccessInput
         file1 = createTempFile();
         try (BufferedFileInput input1 = inputByString(file1, "hugegraph")) {
             UnsafeBytesOutput output = new UnsafeBytesOutput(
                                        Constants.SMALL_BUF_SIZE);
             output.writeBytes("banana");
             RandomAccessInput input = EntriesUtil.inputFromOutput(output);

             int result = input1.compare(0, input1.available(), input, 0,
                                         input.available());
             Assert.assertGt(0, result);
         } finally {
             FileUtils.deleteQuietly(file1);
         }

         // Compare two BufferedFileInput
         file1 = createTempFile();
         file2 = createTempFile();
         String content = "let's make baidu great again";

         try (BufferedFileInput input1 = inputByString(file1, content, 10);
              BufferedFileInput input2 = inputByString(file1, content, 10)) {
             int result;
             /*
              * Compare range in buffer
              * "le" compare to "et"
              */
             result = input1.compare(0, 2, input2, 1, 2);
             Assert.assertGt(0, result);

             /*
              * Compare range in input1 buffer but not in input2 buffer
              * "le" compare to "aid"
              */
             result = input1.compare(0, 2, input2, 12, 2);
             Assert.assertGt(0, result);

             /*
              * Compare range not in buffer
              * "aid" compare to "aid"
              */
             result = input1.compare(12, 3, input2, 12, 3);
             Assert.assertEquals(0, result);

             /*
              * Compare range not in input1 buffer but in input2 buffer
              * "aid" compare to "let"
              */
             result = input1.compare(12, 3, input2, 0, 3);
             Assert.assertLt(0, result);
         } finally {
             FileUtils.deleteQuietly(file1);
             FileUtils.deleteQuietly(file2);
         }
     }

     private static File createTempFile() throws IOException {
         return File.createTempFile(UUID.randomUUID().toString(), null);
     }

     private static BufferedFileOutput createOutput(File file)
                                       throws FileNotFoundException {
         return new BufferedFileOutput(new RandomAccessFile(file,
                                       Constants.FILE_MODE_WRITE),
                                       BUFFER_SIZE);
     }

     private static BufferedFileInput createInput(File file)
                                                  throws IOException {
         return new BufferedFileInput(new RandomAccessFile(file,
                                      Constants.FILE_MODE_READ),
                                      BUFFER_SIZE);
     }

     private static BufferedFileInput inputByString(File file, String s)
                                                    throws IOException {
         BufferedFileOutput output = new BufferedFileOutput(file);
         output.writeBytes(s);
         output.close();
         return new BufferedFileInput(file);
     }

     private static BufferedFileInput inputByString(File file, String s,
                                                    int bufferCapacity)
                                                    throws IOException {
         BufferedFileOutput output = new BufferedFileOutput(file);
         output.writeBytes(s);
         output.close();
         RandomAccessFile randomAccessFile = new RandomAccessFile(
                                             file, Constants.FILE_MODE_READ);
         return new BufferedFileInput(randomAccessFile, bufferCapacity);
     }
 }
	/*
	* Copyright 2017 HugeGraph Authors
	*
	* 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 com.baidu.hugegraph.computer.core.io;

	import java.io.BufferedInputStream;
	import java.io.BufferedOutputStream;
	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.EOFException;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.util.Random;
	import java.util.UUID;

	import org.apache.commons.io.FileUtils;
	import org.junit.Test;
	import org.slf4j.Logger;

	import com.baidu.hugegraph.computer.core.common.Constants;
	import com.baidu.hugegraph.computer.core.store.entry.EntriesUtil;
	import com.baidu.hugegraph.computer.suite.unit.UnitTestBase;
	import com.baidu.hugegraph.testutil.Assert;
	import com.baidu.hugegraph.util.Log;

	public class BufferedFileTest {

	private static final Logger LOG = Log.logger(
	BufferedFileTest.class);
	private static final int BUFFER_SIZE = 128;

	@Test
	public void testConstructor() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = new BufferedFileOutput(file)) {
	Assert.assertEquals(0, output.position());
	}
	try (BufferedFileInput input = new BufferedFileInput(file)) {
	Assert.assertEquals(0, input.position());
	}
	Assert.assertThrows(IllegalArgumentException.class, () -> {
	new BufferedFileOutput(new RandomAccessFile(file,
	Constants.FILE_MODE_WRITE),
	1);
	}, e -> {
	Assert.assertContains("The parameter bufferSize must be >= 8",
	e.getMessage());
	});
	Assert.assertThrows(IllegalArgumentException.class, () -> {
	new BufferedFileInput(new RandomAccessFile(file,
	Constants.FILE_MODE_READ),
	1);
	}, e -> {
	Assert.assertContains("The parameter bufferSize must be >= 8",
	e.getMessage());
	});
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testInt() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = -128; i <= 127; i++) {
	output.writeInt(i);
	}
	output.writeInt(Integer.MAX_VALUE);
	output.writeInt(Integer.MIN_VALUE);
	}
	try (BufferedFileInput input = createInput(file)) {
	for (int i = -128; i <= 127; i++) {
	Assert.assertEquals(i, input.readInt());
	}
	Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
	Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testWriteIntWithPosition() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = -128; i <= 127; i++) {
	output.writeInt(i);
	}
	output.writeFixedInt(0, 1);
	output.writeFixedInt(12, 2);
	// Next buffer
	output.writeFixedInt(200, 3);
	// Previous buffer
	output.writeFixedInt(100, 4);
	output.writeInt(Integer.MAX_VALUE);
	output.writeInt(Integer.MIN_VALUE);
	// Current buffer
	output.writeInt(5);
	output.writeFixedInt(output.position() - Integer.BYTES, 6);
	}

	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i < 256; i++) {
	int expectValue = i - 128;
	int position = i * 4;
	int readValue = input.readInt();
	if (position != 0 && position != 12 &&
	position != 200 && position != 100 &&
	position != 1000) {
	Assert.assertEquals(expectValue, readValue);
	}
	}
	input.seek(0);
	Assert.assertEquals(1, input.readInt());
	input.seek(12);
	Assert.assertEquals(2, input.readInt());
	input.seek(200);
	Assert.assertEquals(3, input.readInt());
	input.seek(100);
	Assert.assertEquals(4, input.readInt());
	input.seek(256 * 4);
	Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
	Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
	Assert.assertEquals(6, input.readInt());
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testByteArray() throws IOException {
	int loopTimes = 129;
	byte[] array = UnitTestBase.randomBytes(10);
	File file = createTempFile();
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = 0; i < loopTimes; i++) {
	output.write(array);
	}
	}

	byte[] arrayRead = new byte[10];
	try (DataInputStream dis = new DataInputStream(
	new FileInputStream(file))) {
	for (int i = 0; i < loopTimes; i++) {
	dis.readFully(arrayRead);
	Assert.assertArrayEquals(array, arrayRead);
	}
	}
	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i < loopTimes; i++) {
	input.readFully(arrayRead);
	Assert.assertArrayEquals(array, arrayRead);
	}
	}
	FileUtils.deleteQuietly(file);
	}

	@Test
	public void testLargeByteArray() throws IOException {
	int loopTimes = 10;
	int arraySize = 1280; // large than buffer size
	byte[] array = UnitTestBase.randomBytes(arraySize);
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = 0; i < loopTimes; i++) {
	output.write(array);
	}
	}

	byte[] arrayRead = new byte[arraySize];
	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i < loopTimes; i++) {
	input.readFully(arrayRead);
	Assert.assertArrayEquals(array, arrayRead);
	}
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testInputSeekAtRandom() throws IOException {
	int size = 128;
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = 0; i < size; i++) {
	output.writeInt(i);
	}
	for (int i = size; i >= 0; i--) {
	output.seek(i * 4);
	output.writeInt(size - i);
	}
	}
	Random random = new Random(1001);
	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i <= 10; i++) {
	long position = 4 * random.nextInt(size);
	input.seek(position);
	Assert.assertEquals(size - position / 4, input.readInt());
	}
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testInputSeekOutRange() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	output.writeInt(1);
	output.writeInt(2);
	output.writeInt(3);
	}

	try (BufferedFileInput input = createInput(file)) {
	Assert.assertEquals(1, input.readInt());
	input.skip(4);
	Assert.assertThrows(EOFException.class, () -> {
	input.seek(13); // Out of range
	}, e -> {
	Assert.assertContains("reach the end of file",
	e.getMessage());
	});
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testOutputSeekOutRange() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	output.seek(100L);
	output.writeInt(1);
	output.seek(511L);
	output.writeInt(2);
	}

	try (BufferedFileInput input = createInput(file)) {
	input.seek(100L);
	Assert.assertEquals(1, input.readInt());
	input.seek(511L);
	Assert.assertEquals(2, input.readInt());
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testSeekAtEnd() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = -128; i <= 127; i++) {
	output.writeInt(i);
	}
	// Overwrite last 2 elements
	output.seek(256 * 4 - 8);
	output.writeInt(Integer.MAX_VALUE);
	output.writeInt(Integer.MIN_VALUE);
	}

	try (BufferedFileInput input = createInput(file)) {
	for (int i = -128; i <= 125; i++) {
	Assert.assertEquals(i, input.readInt());
	}
	Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
	Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
	input.seek(input.position() - 8);
	Assert.assertEquals(Integer.MAX_VALUE, input.readInt());
	Assert.assertEquals(Integer.MIN_VALUE, input.readInt());
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testSkip() throws IOException {
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = -128; i <= 127; i++) {
	output.writeByte(i);
	}
	output.skip(4L);
	output.writeByte(127);
	output.skip(4L);
	output.skip(1280L);
	output.writeByte(1);
	Assert.assertThrows(IllegalArgumentException.class, () -> {
	output.skip(-1);
	}, e -> {
	e.getMessage().contains("The parameter bytesToSkip must " +
	"be >= 0");
	});
	}

	try (BufferedFileInput input = createInput(file)) {
	for (int i = -128; i <= 127; i++) {
	Assert.assertEquals(i, input.readByte());
	}
	input.skip(4);
	Assert.assertEquals(127, input.readByte());
	input.skip(4);
	input.skip(1280);
	Assert.assertEquals((byte) 1, input.readByte());
	Assert.assertThrows(IllegalArgumentException.class, () -> {
	input.skip(-1);
	}, e -> {
	e.getMessage().contains("The parameter bytesToSkip must " +
	"be >= 0");
	});
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testPosition() throws IOException {
	int size = 1024;
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = 0; i < size; i++) {
	Assert.assertEquals(i * 4, output.position());
	output.writeInt(i);
	}
	}
	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i < size; i++) {
	Assert.assertEquals(i * 4, input.position());
	Assert.assertEquals(i, input.readInt());
	}

	Random random = new Random();
	for (int i = 0; i < 10; i++) {
	long position = 4 * random.nextInt(size);
	input.seek(position);
	Assert.assertEquals(position / 4, input.readInt());
	Assert.assertEquals(position + 4, input.position());
	}
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testAvailable() throws IOException {
	int size = 1024;
	File file = createTempFile();
	try {
	try (BufferedFileOutput output = createOutput(file)) {
	for (int i = 0; i < size; i++) {
	output.writeInt(i);
	}
	}
	try (BufferedFileInput input = createInput(file)) {
	for (int i = 0; i < size; i++) {
	Assert.assertEquals(4096 - i * 4, input.available());
	Assert.assertEquals(i, input.readInt());
	}
	}
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testLongPerformanceUnsafe() throws IOException {
	long size = 1024;
	long startTime;
	long endTime;
	long time;
	File file = new File("long-unsafe.bin");
	try {
	startTime = System.currentTimeMillis();
	try (BufferedFileOutput output = new BufferedFileOutput(file)) {
	for (long i = 0; i < size / 8; i++) {
	output.writeLong(i);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Write {} bytes use BufferedFileOutput.writeLong " +
	"takes {} ms", size, time);

	startTime = System.currentTimeMillis();
	try (BufferedFileInput input = new BufferedFileInput(file)) {
	for (long i = 0; i < size / 8; i++) {
	input.readLong();
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use BufferedFileInput.readLong " +
	"takes {} ms", size, time);
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testLongPerformanceNormal() throws IOException {
	long size = 1024;
	long startTime;
	long endTime;
	long time;

	File file = new File("long-data.bin");
	try {
	startTime = System.currentTimeMillis();
	try (DataOutputStream output = new DataOutputStream(
	new BufferedOutputStream(
	new FileOutputStream(file)))) {
	for (long i = 0; i < size / 8; i++) {
	output.writeLong(i);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Write {} bytes use DataOutputStream.writeLong" +
	" takes {} ms", size, time);

	startTime = System.currentTimeMillis();
	try (DataInputStream input = new DataInputStream(
	new BufferedInputStream(
	new FileInputStream(file)))) {
	for (long i = 0; i < size / 8; i++) {
	input.readLong();
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use DataInputStream.readLong " +
	"takes {} ms", size, time);
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testIntPerformanceIntUnsafe() throws IOException {
	int size = 1024;
	long startTime;
	long endTime;
	File file = new File("int-unsafe.bin");
	try {
	startTime = System.currentTimeMillis();
	try (BufferedFileOutput output = new BufferedFileOutput(file)) {
	for (int i = 0; i < size / 4; i++) {
	output.writeInt(i);
	}
	}
	endTime = System.currentTimeMillis();
	long time = endTime - startTime;
	LOG.info("Write {} bytes use BufferedFileOutput.writeInt " +
	"takes {} ms", size, time);

	startTime = System.currentTimeMillis();
	try (BufferedFileInput input = new BufferedFileInput(file)) {
	for (int i = 0; i < size / 4; i++) {
	input.readInt();
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use BufferedFileInput.readInt " +
	"takes {} ms", size, time);
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testIntPerformanceNormal() throws IOException {
	int size = 1024;
	long startTime;
	long endTime;
	long time;
	File dataFile = new File("int-data-out.bin");
	try {
	startTime = System.currentTimeMillis();
	try (DataOutputStream output = new DataOutputStream(
	new BufferedOutputStream(
	new FileOutputStream(dataFile)))) {
	for (int i = 0; i < size / 4; i++) {
	output.writeInt(i);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Write {} bytes use DataOutputStream.writeInt " +
	"takes {} ms", size, time);

	startTime = System.currentTimeMillis();
	try (DataInputStream input = new DataInputStream(
	new BufferedInputStream(
	new FileInputStream(dataFile)))) {
	for (int i = 0; i < size / 4; i++) {
	input.readInt();
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use DataInputStream.readInt " +
	"takes {} ms", size, time);
	} finally {
	FileUtils.deleteQuietly(dataFile);
	}
	}

	@Test
	public void testByteArrayPerformanceUnsafe() throws IOException {
	int size = 1024;
	long startTime;
	long endTime;
	long time;
	byte[] writeArray = UnitTestBase.randomBytes(16);
	byte[] readArray = new byte[16];

	File file = new File("int-unsafe-out.bin");
	try {
	startTime = System.currentTimeMillis();
	try (BufferedFileOutput output = new BufferedFileOutput(file)) {
	for (int i = 0; i < size / writeArray.length; i++) {
	output.write(writeArray);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Write {} bytes use BufferedFileOutput" +
	".write takes {} ms", size, time);

	startTime = System.currentTimeMillis();
	try (BufferedFileInput input = new BufferedFileInput(file)) {
	for (int i = 0; i < size / readArray.length; i++) {
	input.readFully(readArray);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use BufferedFileInput.readFully " +
	"takes {} ms", size, time);
	} finally {
	FileUtils.deleteQuietly(file);
	}
	}

	@Test
	public void testByteArrayPerformanceNormal() throws IOException {
	int size = 1024;
	long startTime;
	long endTime;
	long time;
	byte[] writeArray = UnitTestBase.randomBytes(16);
	byte[] readArray = new byte[16];
	File dataFile = new File("int-data-out.bin");
	try {
	startTime = System.currentTimeMillis();
	try (DataOutputStream output = new DataOutputStream(
	new BufferedOutputStream(
	new FileOutputStream(dataFile)))) {
	for (int i = 0; i < size / writeArray.length; i++) {
	output.write(writeArray);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Write {} bytes use DataOutputStream.write takes {} ms",
	size, time);

	startTime = System.currentTimeMillis();
	try (DataInputStream input = new DataInputStream(
	new BufferedInputStream(
	new FileInputStream(dataFile)))) {
	for (int i = 0; i < size / writeArray.length; i++) {
	input.readFully(readArray);
	}
	}
	endTime = System.currentTimeMillis();
	time = endTime - startTime;
	LOG.info("Read {} bytes use DataInputStream.readFully takes {} ms",
	size, time);
	} finally {
	FileUtils.deleteQuietly(dataFile);
	}
	}

	@Test
	public void testCompare() throws IOException {
	// BufferedFileInput compare to BufferedFileInput
	File file1 = createTempFile();
	File file2 = createTempFile();
	try (BufferedFileInput input1 = inputByString(file1, "apple");
	BufferedFileInput input2 = inputByString(file2, "banana")) {
	int result = input1.compare(0, input1.available(), input2, 0,
	input2.available());
	Assert.assertLt(0, result);
	} finally {
	FileUtils.deleteQuietly(file1);
	FileUtils.deleteQuietly(file2);
	}

	// UnsafeBytesInput compare to BufferedFileInput
	File file3 = createTempFile();
	try (BufferedFileInput fileInput = inputByString(file3, "apple")) {
	@SuppressWarnings("resource")
	UnsafeBytesOutput output = new UnsafeBytesOutput(
	Constants.SMALL_BUF_SIZE);
	output.writeBytes("banana");
	@SuppressWarnings("resource")
	RandomAccessInput input = new UnsafeBytesInput(output.buffer());
	int result = input.compare(0, input.available(), fileInput, 0,
	fileInput.available());
	Assert.assertGt(0, result);
	} finally {
	FileUtils.deleteQuietly(file3);
	}
	}

	@Test
	public void testCompareDiffRange() throws IOException {
	File file1, file2;

	// BufferedFileInput compare to other RandomAccessInput
	file1 = createTempFile();
	try (BufferedFileInput input1 = inputByString(file1, "hugegraph")) {
	UnsafeBytesOutput output = new UnsafeBytesOutput(
	Constants.SMALL_BUF_SIZE);
	output.writeBytes("banana");
	RandomAccessInput input = EntriesUtil.inputFromOutput(output);

	int result = input1.compare(0, input1.available(), input, 0,
	input.available());
	Assert.assertGt(0, result);
	} finally {
	FileUtils.deleteQuietly(file1);
	}

	// Compare two BufferedFileInput
	file1 = createTempFile();
	file2 = createTempFile();
	String content = "let's make baidu great again";

	try (BufferedFileInput input1 = inputByString(file1, content, 10);
	BufferedFileInput input2 = inputByString(file1, content, 10)) {
	int result;
	/*
	* Compare range in buffer
	* "le" compare to "et"
	*/
	result = input1.compare(0, 2, input2, 1, 2);
	Assert.assertGt(0, result);

	/*
	* Compare range in input1 buffer but not in input2 buffer
	* "le" compare to "aid"
	*/
	result = input1.compare(0, 2, input2, 12, 2);
	Assert.assertGt(0, result);

	/*
	* Compare range not in buffer
	* "aid" compare to "aid"
	*/
	result = input1.compare(12, 3, input2, 12, 3);
	Assert.assertEquals(0, result);

	/*
	* Compare range not in input1 buffer but in input2 buffer
	* "aid" compare to "let"
	*/
	result = input1.compare(12, 3, input2, 0, 3);
	Assert.assertLt(0, result);
	} finally {
	FileUtils.deleteQuietly(file1);
	FileUtils.deleteQuietly(file2);
	}
	}

	private static File createTempFile() throws IOException {
	return File.createTempFile(UUID.randomUUID().toString(), null);
	}

	private static BufferedFileOutput createOutput(File file)
	throws FileNotFoundException {
	return new BufferedFileOutput(new RandomAccessFile(file,
	Constants.FILE_MODE_WRITE),
	BUFFER_SIZE);
	}

	private static BufferedFileInput createInput(File file)
	throws IOException {
	return new BufferedFileInput(new RandomAccessFile(file,
	Constants.FILE_MODE_READ),
	BUFFER_SIZE);
	}

	private static BufferedFileInput inputByString(File file, String s)
	throws IOException {
	BufferedFileOutput output = new BufferedFileOutput(file);
	output.writeBytes(s);
	output.close();
	return new BufferedFileInput(file);
	}

	private static BufferedFileInput inputByString(File file, String s,
	int bufferCapacity)
	throws IOException {
	BufferedFileOutput output = new BufferedFileOutput(file);
	output.writeBytes(s);
	output.close();
	RandomAccessFile randomAccessFile = new RandomAccessFile(
	file, Constants.FILE_MODE_READ);
	return new BufferedFileInput(randomAccessFile, bufferCapacity);
	}
	}