Add File-based Java Functional Tests

Signed-off-by: Nidhi Gupta <itsnidhi16@gmail.com>

9 files changed, 659 insertions, 7 deletions

diff --git a/test/javaTests/README.md b/test/javaTests/README.md
index cb779285e..670741677 100644
--- a/test/javaTests/README.md
+++ b/test/javaTests/README.md
@@ -23,6 +23,14 @@ CAP_SETUID
 
 Here we test the File-Based Java APIs by checkpointing the application in the following scenarios and verifying the contents of the file after restore:
 - Reading and writing in the same file. (FileRead.java)
+- Read from a file and write its content to another file. (ReadWrite.java)
+- Reading from multiple files and writing their content to another file. (MultipleFileRead)
+- Reading from a file and writing its content to multiple files. (MultipleFileWrite)
+
+## Memory mapping Java APIs
+
+Here we test the Memory Mapping APIs by checkpointing the application in following scenario and verifying the contents after restore:
+- Memory-mapping a file and writing its content to another file. (MemoryMappings.java)
 
 ### Prerequisites for running the tests:
 - Maven
diff --git a/test/javaTests/src/org/criu/java/tests/CheckpointRestore.java b/test/javaTests/src/org/criu/java/tests/CheckpointRestore.java
index 968488191..b848c9938 100644
--- a/test/javaTests/src/org/criu/java/tests/CheckpointRestore.java
+++ b/test/javaTests/src/org/criu/java/tests/CheckpointRestore.java
@@ -77,7 +77,7 @@ public class CheckpointRestore {
 	private void testSetup(String testName) throws IOException {
 		Path testFolderPath = Paths.get(outputFolder + testName + "/");
 		if (!Files.exists(testFolderPath)) {
-			System.out.println("Test Folder does not exist creating it");
+			System.out.println("Creating the test folder");
 			Files.createDirectory(testFolderPath);
 		}
 	}
@@ -245,7 +245,7 @@ public class CheckpointRestore {
 		Assert.assertNotEquals(currentState, Helper.STATE_TERMINATE, testName + ": ERROR: Checkpoint-Restore failed");
 		Assert.assertNotEquals(currentState, Helper.STATE_FAIL, testName + ": ERROR: Test Failed, Check Log for details");
 		Assert.assertEquals(currentState, Helper.STATE_PASS, testName + " ERROR: Unexpected State of Mapped Buffer");
-		System.out.println("-----" + "PASS" + "-----");
+		System.out.println("----- " + "PASS" + " -----");
 
 	}
 
diff --git a/test/javaTests/src/org/criu/java/tests/FileRead.java b/test/javaTests/src/org/criu/java/tests/FileRead.java
index d94a14112..d8851a73e 100644
--- a/test/javaTests/src/org/criu/java/tests/FileRead.java
+++ b/test/javaTests/src/org/criu/java/tests/FileRead.java
@@ -50,7 +50,7 @@ class FileRead {
 			/*
 			 * Mapped Byte Buffer should be in init state at the beginning of test
 			 */
-			if ('I' != b.getChar(Helper.MAPPED_INDEX)) {
+			if (Helper.STATE_INIT != b.getChar(Helper.MAPPED_INDEX)) {
 				logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
 				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
 				System.exit(1);
diff --git a/test/javaTests/src/org/criu/java/tests/Helper.java b/test/javaTests/src/org/criu/java/tests/Helper.java
index d608fba47..fdf20bb52 100644
--- a/test/javaTests/src/org/criu/java/tests/Helper.java
+++ b/test/javaTests/src/org/criu/java/tests/Helper.java
@@ -1,9 +1,6 @@
 package org.criu.java.tests;
 
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
+import java.io.*;
 import java.nio.MappedByteBuffer;
 import java.util.logging.FileHandler;
 import java.util.logging.Level;
@@ -96,4 +93,38 @@ class Helper {
 			System.exit(1);
 		}
 	}
+
+
+	/**
+	 * Compare two files and return true if their content is similar.
+	 *
+	 * @param readFile  File 1 whose content has to be compared.
+	 * @param writeFile File 2 whose content has to be compared.
+	 * @return true if the files are similar, false otherwise.
+	 * @throws IOException
+	 */
+	static boolean compare(File readFile, File writeFile) throws IOException {
+		BufferedReader bir = new BufferedReader(new FileReader(readFile));
+		BufferedReader bor = new BufferedReader(new FileReader(writeFile));
+		String si, so;
+		si = bir.readLine();
+		so = bor.readLine();
+		while (null != si && null != so) {
+			if (!si.equals(so)) {
+				return false;
+			}
+
+			si = bir.readLine();
+			so = bor.readLine();
+		}
+
+		if ((null == si) && (null == so)) {
+			return true;
+		}
+		bir.close();
+		bor.close();
+
+		return false;
+	}
+
 }
diff --git a/test/javaTests/src/org/criu/java/tests/MemoryMappings.java b/test/javaTests/src/org/criu/java/tests/MemoryMappings.java
new file mode 100644
index 000000000..4ac6f4a17
--- /dev/null
+++ b/test/javaTests/src/org/criu/java/tests/MemoryMappings.java
@@ -0,0 +1,121 @@
+package org.criu.java.tests;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.StandardOpenOption;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class MemoryMappings {
+	private static String TESTNAME = "MemoryMappings";
+
+	/**
+	 * Map a file to memory and write the mapped data into a file,
+	 * checkpointing and restoring in between.
+	 *
+	 * @param args Not used
+	 */
+	public static void main(String[] args) {
+		MappedByteBuffer b = null;
+		Logger logger = null;
+
+		try {
+			MappedByteBuffer testBuffer;
+			char ch;
+			int i = 1;
+			boolean similar;
+			logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
+			File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
+			File readFile = new File(Helper.SOURCE_FOLDER + "/" + "ReadWrite.java");
+			File writeFile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/" + "MemoryMappings_file.txt");
+			RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
+			String pid = bean.getName();
+			int val = Helper.init(TESTNAME, pid, logger);
+			if (0 != val) {
+				logger.log(Level.SEVERE, "Helper.init returned a non-zero code.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
+
+			FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+			b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
+			channel.close();
+			/*
+			 * Mapped Byte Buffer should be in init state at the beginning of test
+			 */
+			if (Helper.STATE_INIT != b.getChar(Helper.MAPPED_INDEX)) {
+				logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Checking existence of file to be memory mapped");
+			if (!readFile.exists()) {
+				logger.log(Level.SEVERE, "Error: File from which to read does not exist");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			channel = FileChannel.open(readFile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+			testBuffer = channel.map(MapMode.READ_WRITE, 0, readFile.length());
+			channel.close();
+
+			if (writeFile.exists()) {
+				writeFile.delete();
+			}
+			boolean newFile = writeFile.createNewFile();
+			if (!newFile) {
+				logger.log(Level.SEVERE, "Error: Cannot create a new file to write to.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			BufferedWriter brw = new BufferedWriter(new FileWriter(writeFile));
+
+			while (testBuffer.hasRemaining()) {
+				ch = (char) testBuffer.get();
+				brw.write(ch);
+				i++;
+				if (200 == i) {
+					logger.log(Level.INFO, "Going to checkpoint");
+					Helper.checkpointAndWait(b, logger);
+					logger.log(Level.INFO, "Test has been restored!");
+				}
+			}
+
+			brw.close();
+			logger.log(Level.INFO, "Comparing contents of the file");
+
+			similar = Helper.compare(readFile, writeFile);
+			if (!similar) {
+				logger.log(Level.SEVERE, "Error: Files are not similar after writing");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Data was read and written correctly!");
+			logger.log(Level.INFO, Helper.PASS_MESSAGE);
+			brw.close();
+			b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
+			System.exit(0);
+
+		} catch (Exception e) {
+			if (null != logger) {
+
+				StringWriter writer = new StringWriter();
+				PrintWriter printWriter = new PrintWriter(writer);
+				e.printStackTrace(printWriter);
+				logger.log(Level.SEVERE, "Exception occurred:" + e);
+				logger.log(Level.FINE, writer.toString());
+			}
+
+			if (null != b) {
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+			}
+			System.exit(5);
+		}
+	}
+}
diff --git a/test/javaTests/src/org/criu/java/tests/MultipleFileRead.java b/test/javaTests/src/org/criu/java/tests/MultipleFileRead.java
new file mode 100644
index 000000000..7b023673e
--- /dev/null
+++ b/test/javaTests/src/org/criu/java/tests/MultipleFileRead.java
@@ -0,0 +1,203 @@
+package org.criu.java.tests;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.StandardOpenOption;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class MultipleFileRead {
+	private static String TESTNAME = "MultipleFileRead";
+
+	/**
+	 * @param readFile1 File 1 whose contents are read.
+	 * @param readFile2 File 2 whose contents are read.
+	 * @param writeFile File in which data has been written to.
+	 * @return true if the data written is as expected, false otherwise.
+	 * @throws IOException
+	 */
+	private static boolean compare(File readFile1, File readFile2, File writeFile) throws IOException {
+		BufferedReader br1 = new BufferedReader(new FileReader(readFile1));
+		BufferedReader br2 = new BufferedReader(new FileReader(readFile2));
+		BufferedReader brw = new BufferedReader(new FileReader(writeFile));
+		boolean eof1, eof2;
+		eof1 = false;
+		eof2 = false;
+		String inpString, wrtString;
+
+		while (!eof1 || !eof2) {
+			if (!eof1) {
+				inpString = br1.readLine();
+				if (null == inpString) {
+					eof1 = true;
+				} else {
+					wrtString = brw.readLine();
+					if (null == wrtString) {
+						return false;
+					}
+					if (!wrtString.equals(inpString)) {
+						return false;
+					}
+				}
+			}
+			if (!eof2) {
+				inpString = br2.readLine();
+				if (null == inpString) {
+					eof2 = true;
+				} else {
+					wrtString = brw.readLine();
+					if (null == wrtString) {
+						return false;
+					}
+					if (!wrtString.equals(inpString)) {
+						return false;
+					}
+				}
+			}
+		}
+
+		wrtString = brw.readLine();
+		if (null != wrtString) {
+			return false;
+		}
+
+		br1.close();
+		br2.close();
+		brw.close();
+
+		return true;
+	}
+
+	/**
+	 * Read from multiple files and write their content into another file,
+	 * checkpointing and restoring in between.
+	 *
+	 * @param args Not used.
+	 */
+	public static void main(String[] args) {
+		MappedByteBuffer b = null;
+		String s;
+		int i = 0;
+		Logger logger = null;
+		try {
+			logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
+			File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
+			File readFile1 = new File(Helper.SOURCE_FOLDER + "/" + "FileRead.java");
+			File readFile2 = new File(Helper.SOURCE_FOLDER + "/" + "ReadWrite.java");
+			File writeFile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/" + "MultipleFileRead_file.txt");
+			boolean eofFile1 = false, eofFile2 = false, check;
+			RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
+			String pid = bean.getName();
+			int val = Helper.init(TESTNAME, pid, logger);
+			if (0 != val) {
+				logger.log(Level.SEVERE, "Helper.init returned a non-zero code.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
+
+			FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+			b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
+			channel.close();
+			/*
+			 * Mapped Byte Buffer should be in init state at the beginning of test
+			 */
+			if (b.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
+				logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Checking existence of the read files");
+
+			if (!readFile1.exists()) {
+				logger.log(Level.SEVERE, "Error: File from which to read does not exist");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			if (!readFile2.exists()) {
+				logger.log(Level.SEVERE, "Error: File from which to read does not exist");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			if (writeFile.exists()) {
+				writeFile.delete();
+			}
+			logger.log(Level.INFO, "Creating writeFile");
+			boolean newFile = writeFile.createNewFile();
+			if (!newFile) {
+				logger.log(Level.SEVERE, "Error: Cannot create a new file to write to.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			BufferedReader br1 = new BufferedReader(new FileReader(readFile1));
+			BufferedReader br2 = new BufferedReader(new FileReader(readFile2));
+			BufferedWriter brw = new BufferedWriter(new FileWriter(writeFile));
+
+			logger.log(Level.INFO, "Writing in file");
+
+			while (!eofFile1 || !eofFile2) {
+				if (!eofFile1) {
+					s = br1.readLine();
+					i++;
+					if (null == s) {
+						eofFile1 = true;
+					} else {
+						brw.write(s + "\n");
+					}
+				}
+				if (!eofFile2) {
+					s = br2.readLine();
+					i++;
+					if (null == s) {
+						eofFile2 = true;
+					} else {
+						brw.write(s + "\n");
+					}
+				}
+				if (10 == i) {
+					/*
+					 * Checkpoint and Restore
+					 */
+					logger.log(Level.INFO, "Going to checkpoint");
+					Helper.checkpointAndWait(b, logger);
+					logger.log(Level.INFO, "Test has been restored!");
+				}
+			}
+			brw.flush();
+			logger.log(Level.INFO, "Checking the content of the file");
+			check = compare(readFile1, readFile2, writeFile);
+
+			if (!check) {
+				logger.log(Level.SEVERE, "Error: Files are not similar after writing");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "The file has been written as expected");
+			logger.log(Level.INFO, Helper.PASS_MESSAGE);
+			br1.close();
+			br2.close();
+			brw.close();
+			b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
+			System.exit(0);
+
+		} catch (Exception e) {
+			if (null != logger) {
+				StringWriter writer = new StringWriter();
+				PrintWriter printWriter = new PrintWriter(writer);
+				e.printStackTrace(printWriter);
+				logger.log(Level.SEVERE, "Exception occurred:" + e);
+				logger.log(Level.FINE, writer.toString());
+			}
+
+			if (null != b) {
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+			}
+			System.exit(5);
+		}
+	}
+}
diff --git a/test/javaTests/src/org/criu/java/tests/MultipleFileWrite.java b/test/javaTests/src/org/criu/java/tests/MultipleFileWrite.java
new file mode 100644
index 000000000..76d287a07
--- /dev/null
+++ b/test/javaTests/src/org/criu/java/tests/MultipleFileWrite.java
@@ -0,0 +1,140 @@
+package org.criu.java.tests;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.StandardOpenOption;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class MultipleFileWrite {
+	private static String TESTNAME = "MultipleFileWrite";
+
+	/**
+	 * Reads from a file and write its content into multiple files,
+	 * checkpointing and restoring in between.
+	 *
+	 * @param args Not used.
+	 */
+	public static void main(String[] args) {
+		MappedByteBuffer b = null;
+		String s, pid;
+		int i = 1;
+		Logger logger = null;
+		boolean similar1, similar2;
+		try {
+			File readFile = new File(Helper.SOURCE_FOLDER + "/" + "FileRead.java");
+			File writeFile1 = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/" + TESTNAME + "1_file.txt");
+			File writeFile2 = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/" + TESTNAME + "2_file.txt");
+			logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
+			File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
+			RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
+			pid = bean.getName();
+			int val = Helper.init(TESTNAME, pid, logger);
+			if (0 != val) {
+				logger.log(Level.SEVERE, "Helper.init returned a non-zero code.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
+
+			FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+			b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
+			channel.close();
+			/*
+			 * Mapped Byte Buffer should be in init state at the beginning of test
+			 */
+			if (Helper.STATE_INIT != b.getChar(Helper.MAPPED_INDEX)) {
+				logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Checking existence of read files!");
+
+			if (!readFile.exists()) {
+				logger.log(Level.SEVERE, "Error: File from which to read does not exist");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			if (writeFile1.exists()) {
+				writeFile1.delete();
+			}
+			boolean newFile = writeFile1.createNewFile();
+			if (!newFile) {
+				logger.log(Level.SEVERE, "Error: Cannot create a new file to write to.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			if (writeFile2.exists()) {
+				writeFile2.delete();
+			}
+			newFile = writeFile2.createNewFile();
+			if (!newFile) {
+				logger.log(Level.SEVERE, "Error: Cannot create a new file to write to.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Created write files");
+
+			BufferedReader br = new BufferedReader(new FileReader(readFile));
+			BufferedWriter bw1 = new BufferedWriter(new FileWriter(writeFile1));
+			BufferedWriter bw2 = new BufferedWriter(new FileWriter(writeFile2));
+
+			s = br.readLine();
+
+			while (null != s) {
+				bw1.write(s + "\n");
+				bw2.write(s + "\n");
+				if (90 == i) {
+					/*
+					 * Checkpoint and Restore
+					 */
+					logger.log(Level.INFO, "Going to checkpoint");
+					Helper.checkpointAndWait(b, logger);
+					logger.log(Level.INFO, "Test has been restored!");
+				}
+
+				i++;
+				s = br.readLine();
+			}
+
+			bw1.flush();
+			bw2.flush();
+			logger.log(Level.INFO, "Checking files have been written correctly");
+
+			similar1 = Helper.compare(readFile, writeFile1);
+			similar2 = Helper.compare(readFile, writeFile2);
+
+			if (!similar1 || !similar2) {
+				logger.log(Level.SEVERE, "Error: Written data is not identical to the data read");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Content of files is as expected");
+			logger.log(Level.INFO, Helper.PASS_MESSAGE);
+			br.close();
+			bw1.close();
+			bw2.close();
+			b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
+			System.exit(0);
+
+		} catch (Exception e) {
+			if (null != logger) {
+				StringWriter writer = new StringWriter();
+				PrintWriter printWriter = new PrintWriter(writer);
+				e.printStackTrace(printWriter);
+				logger.log(Level.SEVERE, "Exception occurred:" + e);
+				logger.log(Level.FINE, writer.toString());
+			}
+
+			if (null != b) {
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+			}
+			System.exit(5);
+		}
+	}
+}
diff --git a/test/javaTests/src/org/criu/java/tests/ReadWrite.java b/test/javaTests/src/org/criu/java/tests/ReadWrite.java
new file mode 100644
index 000000000..fa98447ed
--- /dev/null
+++ b/test/javaTests/src/org/criu/java/tests/ReadWrite.java
@@ -0,0 +1,119 @@
+package org.criu.java.tests;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.StandardOpenOption;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class ReadWrite {
+	private static String TESTNAME = "ReadWrite";
+
+	/**
+	 * Read from a file and write its content into another file,
+	 * checkpointing and restoring in between.
+	 *
+	 * @param args Not used.
+	 */
+	public static void main(String[] args) {
+		int i = 0;
+		String s, pid;
+		boolean similar;
+		MappedByteBuffer b = null;
+		Logger logger = null;
+		try {
+			File readFile = new File(Helper.SOURCE_FOLDER + "/" + "FileRead.java");
+			File writeFile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/" + "ReadWrite_file.txt");
+			logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
+			File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
+			RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
+			pid = bean.getName();
+			int val = Helper.init(TESTNAME, pid, logger);
+			if (0 != val) {
+				logger.log(Level.SEVERE, "Helper.init returned a non-zero code.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
+			FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+			b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
+			channel.close();
+			/*
+			 * Mapped Byte Buffer should be in init state at the beginning of test
+			 */
+			if (Helper.STATE_INIT != b.getChar(Helper.MAPPED_INDEX)) {
+				logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Checking existence of files to be read!");
+			if (!readFile.exists()) {
+				logger.log(Level.SEVERE, "Error: File from which to read does not exist");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			if (writeFile.exists()) {
+				writeFile.delete();
+			}
+			logger.log(Level.INFO, "Creating the writeFile");
+			boolean newFile = writeFile.createNewFile();
+			if (!newFile) {
+				logger.log(Level.SEVERE, "Error: Cannot create a new file to write to.");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
+				System.exit(1);
+			}
+
+			BufferedReader brr = new BufferedReader(new FileReader(readFile));
+			BufferedWriter brw = new BufferedWriter(new FileWriter(writeFile));
+			logger.log(Level.INFO, "Start writing");
+
+			s = brr.readLine();
+
+			while (null != s) {
+				i++;
+				brw.write(s + "\n");
+
+				if (50 == i) {
+					/*
+					 * Checkpoint and Restore
+					 */
+					logger.log(Level.INFO, "Going to checkpoint");
+					Helper.checkpointAndWait(b, logger);
+					logger.log(Level.INFO, "Test has been restored!");
+				}
+				s = brr.readLine();
+			}
+
+			brw.flush();
+			logger.log(Level.INFO, "Checking content of the files.");
+			similar = Helper.compare(readFile, writeFile);
+
+			if (!similar) {
+				logger.log(Level.SEVERE, "Error: Files are not similar after writing");
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+				System.exit(1);
+			}
+			logger.log(Level.INFO, "Content of file is as expected");
+			logger.log(Level.INFO, Helper.PASS_MESSAGE);
+			b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
+			System.exit(0);
+		} catch (Exception e) {
+			if (null != logger) {
+				StringWriter writer = new StringWriter();
+				PrintWriter printWriter = new PrintWriter(writer);
+				e.printStackTrace(printWriter);
+				logger.log(Level.SEVERE, "Exception occurred:" + e);
+				logger.log(Level.FINE, writer.toString());
+			}
+			if (null != b) {
+				b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
+			}
+			System.exit(5);
+		}
+	}
+}
diff --git a/test/javaTests/test.xml b/test/javaTests/test.xml
index 8ff67c5e0..b73a31db2 100644
--- a/test/javaTests/test.xml
+++ b/test/javaTests/test.xml
@@ -4,10 +4,40 @@
 <suite name = "Suite1">
 	<parameter name="checkpointOpt" value=""/>
 	<parameter name="restoreOpt" value=""/>
+
 	<test name = "test1-FileRead">
 		<parameter name="testname" value="FileRead"/>
 		<classes>
 			<class name = "org.criu.java.tests.CheckpointRestore"/>
 		</classes>
 	</test>
+
+	<test name = "test2-ReadWrite">
+		<parameter name="testname" value="ReadWrite"/>
+		<classes>
+			<class name = "org.criu.java.tests.CheckpointRestore"/>
+		</classes>
+	</test>
+
+	<test name = "test3-MemoryMappings">
+		<parameter name="testname" value="MemoryMappings"/>
+		<classes>
+			<class name = "org.criu.java.tests.CheckpointRestore"/>
+		</classes>
+	</test>
+
+	<test name = "test4-MultipleFileRead">
+		<parameter name="testname" value="MultipleFileRead"/>
+		<classes>
+			<class name = "org.criu.java.tests.CheckpointRestore"/>
+		</classes>
+	</test>
+
+	<test name = "test5-MultipleFileWrite">
+		<parameter name="testname" value="MultipleFileWrite"/>
+		<classes>
+			<class name = "org.criu.java.tests.CheckpointRestore"/>
+		</classes>
+	</test>
+
 </suite>