package jnr.posix;

import jnr.constants.platform.Access;
import jnr.constants.platform.Fcntl;
import jnr.constants.platform.Errno;
import jnr.constants.platform.OpenFlags;
import jnr.ffi.Pointer;
import jnr.posix.util.Platform;
import org.junit.BeforeClass;
import org.junit.Test;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;

public class FileTest {
    private static POSIX posix;

    @BeforeClass
    public static void setUpClass() throws Exception {
        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
    }

    @Test
    public void utimesTest() throws Throwable {
        // FIXME: On Windows this is working but providing wrong numbers and therefore getting wrong results.
        if (!Platform.IS_WINDOWS) {
            File f = File.createTempFile("utimes", null);

            int rval = posix.utimes(f.getAbsolutePath(), new long[]{800, 200}, new long[]{900, 300});
            assertEquals("utimes did not return 0", 0, rval);

            FileStat stat = posix.stat(f.getAbsolutePath());

            assertEquals("atime seconds failed", 800, stat.atime());
            assertEquals("mtime seconds failed", 900, stat.mtime());

            // The nano secs part is available in other stat implementations. We really just want to verify that the
            // nsec portion of the timeval is passed through to the POSIX call.
            // Mac seems to fail this test sporadically.
            if (stat instanceof NanosecondFileStat && !Platform.IS_MAC) {
                NanosecondFileStat linuxStat = (NanosecondFileStat) stat;

                assertEquals("atime useconds failed", 200000, linuxStat.aTimeNanoSecs());
                assertEquals("mtime useconds failed", 300000, linuxStat.mTimeNanoSecs());
            }

            f.delete();
        }
    }

    @Test
    public void utimesDefaultValuesTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File f = File.createTempFile("utimes", null);

            long oldTime = posix.stat(f.getAbsolutePath()).mtime();
            Thread.sleep(2000);

            int rval = posix.utimes(f.getAbsolutePath(), null, null);
            assertEquals("utimes did not return 0", 0, rval);

            FileStat stat = posix.stat(f.getAbsolutePath());

            assertTrue("atime failed", stat.atime() > oldTime);
            assertTrue("mtime failed", stat.mtime() > oldTime);

            f.delete();
        }
    }

    @Test
    public void utimesPointerTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File f = File.createTempFile("utimes", null);

            Pointer times = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8 * 4); // long[2][2] == 4 longs.
            times.putLong(0, 800);
            times.putLong(8, 200);
            times.putLong(16, 900);
            times.putLong(24, 300);

            int rval = posix.utimes(f.getAbsolutePath(), times);
            assertEquals("utimes did not return 0", 0, rval);

            FileStat stat = posix.stat(f.getAbsolutePath());

            assertEquals("atime seconds failed", 800, stat.atime());
            assertEquals("mtime seconds failed", 900, stat.mtime());

            // The nano secs part is available in other stat implementations.  We use Linux x86_64 because it's
            // representative.  We really just want to verify that the usec portion of the timeval is passed throug
            // to the POSIX call.
            if (hasNanosecondPrecision(stat)) {
                NanosecondFileStat linuxStat = (NanosecondFileStat) stat;

//                assertEquals("atime useconds failed", 200000, linuxStat.aTimeNanoSecs());
                assertEquals("mtime useconds failed", 300000, linuxStat.mTimeNanoSecs());
            }

            f.delete();
        }
    }

    @Test
    public void utimensatAbsolutePath() throws Throwable {
        File file = File.createTempFile("utimensat", null);
        utimensat(file, 0);
    }

    @Test
    public void utimensatRelativePath() throws Throwable {
        String path = "utimensat";
        File file = new File(path);
        file.createNewFile();
        int parentFd = posix.open(".", OpenFlags.O_DIRECTORY.intValue(), 0444);
        utimensat(file, parentFd);
    }

    @Test
    public void futimens() throws Throwable {
        File file = File.createTempFile("futimens", null);
        FileStat fileStat = posix.stat(file.getPath());
        if (!hasNanosecondPrecision(fileStat)) {
            file.delete();
            return;
        }

        long atimeSeconds = fileStat.atime()+1;
        long mtimeSeconds = fileStat.mtime()-1;
        long atimeNanoSeconds = 123456789;
        long mtimeNanoSeconds = 135;
        int fd = posix.open(file.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0444);
        posix.futimens(fd,
                new long[] {atimeSeconds, atimeNanoSeconds},
                new long[] {mtimeSeconds, mtimeNanoSeconds});
        assertStatNanoSecond(file, atimeSeconds, atimeNanoSeconds, mtimeSeconds, mtimeNanoSeconds);
    }

    @Test
    public void lutimesTest() throws Throwable {
        // FIXME: On Windows this is working but providing wrong numbers and therefore getting wrong results.
        if (!Platform.IS_WINDOWS) {
            File f1 = File.createTempFile("lutimes", null);
            File f2 = new File(f1.getParentFile(), "lutimes-link");
            posix.symlink(f1.getAbsolutePath(), f2.getAbsolutePath());

            int rval = posix.utimes(f1.getAbsolutePath(), new long[]{800, 0}, new long[]{900, 0});
            assertEquals("utimes did not return 0", 0, rval);

            rval = posix.lutimes(f2.getAbsolutePath(), new long[]{1800, 0}, new long[]{1900, 0});
            assertEquals("lutimes did not return 0", 0, rval);

            FileStat stat = posix.stat(f1.getAbsolutePath());
            assertEquals("atime seconds failed", 800, stat.atime());
            assertEquals("mtime seconds failed", 900, stat.mtime());

            stat = posix.lstat(f2.getAbsolutePath());
            assertEquals("atime seconds failed", 1800, stat.atime());
            assertEquals("mtime seconds failed", 1900, stat.mtime());

            f1.delete();
            f2.delete();
        }
    }

    @Test
    public void futimeTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File f = File.createTempFile("jnr-posix-futime", "tmp");
            long oldTime = posix.stat(f.getAbsolutePath()).mtime();
            Thread.sleep(2000);
            int fd = posix.open(f.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
            int rval = posix.futimes(fd, null, null);
            assertEquals("futime did not return 0", 0, rval);
            long newTime = posix.stat(f.getAbsolutePath()).mtime();
            f.delete();
            assertTrue("mtime failed", newTime > oldTime);
        }
    }

    @Test
    public void linkTest() throws Throwable {
        File f1 = File.createTempFile("utime", null);
        File f2 = new File(f1.getAbsolutePath() + "link");
        int rval = posix.link(f1.getAbsolutePath(), f2.getAbsolutePath());
        assertEquals("link did not return 0", 0, rval);
        assertTrue("Link was not created", f2.exists());
        f1.delete();
        f2.delete();
    }

    @Test
    public void mkdirRelativeTest() throws Throwable {
        File dir = new File("tmp");
        int rval = posix.mkdir(dir.getPath(), 0);
        assertEquals("mkdir did not return 0", 0, rval);
        assertTrue("Directory was not created", dir.exists());
        dir.delete();
    }

    @Test
    public void mkdirAbsoluteTest() throws Throwable {
        File dir = new File("tmp");
        int rval = posix.mkdir(dir.getAbsolutePath(), 0);
        assertEquals("mkdir did not return 0", 0, rval);
        assertTrue("Directory was not created", dir.exists());
        dir.delete();
    }
    
    @Test
    public void flockTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("flockTest", "tmp");
            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
            RandomAccessFile raf2 = new RandomAccessFile(tmp, "rw");
            FileChannel fc = raf.getChannel();
            FileChannel fc2 = raf2.getChannel();
            FileDescriptor FD = JavaLibCHelper.getDescriptorFromChannel(fc);
            FileDescriptor FD2 = JavaLibCHelper.getDescriptorFromChannel(fc2);
            int fd = JavaLibCHelper.getfdFromDescriptor(FD);
            int fd2 = JavaLibCHelper.getfdFromDescriptor(FD2);

            assertEquals(0, posix.flock(fd, 1)); // LOCK_SH
            assertEquals(0, posix.flock(fd, 8)); // LOCK_UN
            assertEquals(0, posix.flock(fd, 2)); // LOCK_EX
            assertEquals(-1, posix.flock(fd2, 2 | 4)); // LOCK_EX | LOCK_NB
            assertEquals(0, posix.flock(fd, 8)); // LOCK_UN
        }
    }

    @Test
    public void dupTest() throws Throwable {
        File tmp = File.createTempFile("dupTest", "tmp");
        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
        FileChannel fileChannel = raf.getChannel();
        int fileDescriptor = getFdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(fileChannel));

        byte[] outContent = "foo".getBytes();

        FileDescriptor newFileDescriptor = toDescriptor(posix.dup(fileDescriptor));

        new FileOutputStream(toDescriptor(fileDescriptor)).write(outContent);
        raf.seek(0);

        byte[] inContent = new byte[outContent.length];
        new FileInputStream(newFileDescriptor).read(inContent, 0, 3);

        assertArrayEquals(inContent, outContent);
    }

    public static final int SEEK_SET = 0;

    @Test
    public void dup2Test() throws Throwable {
        File tmp = File.createTempFile("dupTest", "tmp");
        int oldFd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
        int newFd = 1000;

        byte[] outContent = "foo".getBytes();

        // NB: Windows differs a bit from POSIX's return value.  Both will return -1 on failure, but Windows will return
        // 0 upon success, while POSIX will return the new FD.  Since we already know what the FD will be if the call
        // is successful, it's easy to make code that works with both forms.  But it is something to watch out for.
        assertNotEquals(-1, posix.dup2(oldFd, newFd));
        FileDescriptor newFileDescriptor = toDescriptor(newFd);

        new FileOutputStream(toDescriptor(oldFd)).write(outContent);
        posix.lseek(newFd, SEEK_SET, 0);

        byte[] inContent = new byte[outContent.length];
        new FileInputStream(newFileDescriptor).read(inContent, 0, 3);

        assertArrayEquals(inContent, outContent);
    }

    @Test
    public void fcntlDupfdTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("fcntlTest", "tmp");
            int fd = posix.open(tmp.getPath(), OpenFlags.O_RDWR.intValue(), 0444);

            byte[] outContent = "foo".getBytes();

            // NOTE: This test used to call without the third argument, but this leads to undefined behavior.
            // See https://github.com/jnr/jnr-posix/issues/144
            int newFd = posix.fcntl(fd, Fcntl.F_DUPFD, 0);

            new FileOutputStream(JavaLibCHelper.toFileDescriptor(fd)).write(outContent);
            posix.lseek(fd, SEEK_SET, 0);

            byte[] inContent = new byte[outContent.length];
            new FileInputStream(JavaLibCHelper.toFileDescriptor(newFd)).read(inContent, 0, 3);

            assertArrayEquals(inContent, outContent);
        }
    }

    @Test
    public void fcntlDupfdWithArgTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("dupTest", "tmp");
            int oldFd = JavaLibCHelper.getfdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(
                    new RandomAccessFile(tmp, "rw").getChannel()));
            int newFd = JavaLibCHelper.getfdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(
                    new RandomAccessFile(tmp, "rw").getChannel()));

            byte[] outContent = "foo".getBytes();

            int expectedFd = 100;
            int dupFd = posix.fcntl(oldFd, Fcntl.F_DUPFD, expectedFd);

            new FileOutputStream(JavaLibCHelper.toFileDescriptor(newFd)).write(outContent);

            byte[] inContent = new byte[outContent.length];
            new FileInputStream(JavaLibCHelper.toFileDescriptor(dupFd)).read(inContent, 0, 3);

            assertTrue(dupFd >= expectedFd);
            assertArrayEquals(inContent, outContent);
        }
    }

    @Test
    public void closeTest() throws Throwable {
        File tmp = File.createTempFile("closeTest", "tmp");
        int fd = getFdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(new RandomAccessFile(tmp, "rw").getChannel()));

        int result;

        result = posix.close(fd);
        assertEquals(0, result);

        result = posix.close(fd);
        assertEquals(-1, result);

        // TODO (nirvdrum 06-May-15) We're not getting the correct errno value from Windows currently, so we need to skip this test.
        if (!Platform.IS_WINDOWS) {
            assertEquals(Errno.EBADF.intValue(), posix.errno());
        }
    }

    @Test
    public void unlinkTestNonWindows() throws Throwable {
        if (! Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("unlinkTest", "tmp");
            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");

            raf.write("hello".getBytes());

            int res = posix.unlink(tmp.getCanonicalPath());

            assertEquals(0, res);
            assertFalse(tmp.exists());

            raf.write("world".getBytes());
            raf.seek(0);

            byte[] actual = new byte[10];
            raf.read(actual);

            assertArrayEquals("helloworld".getBytes(), actual);
        }
    }

    @Test
    public void openTest() throws Throwable {
        int fd = posix.open("pom.xml", 0, 0666);

        assertNotEquals(-1, fd);

        int result = posix.close(fd);
        assertEquals(0, result);

        result = posix.close(fd);
        assertEquals(-1, result);

        fd = posix.open("jnr-posix-filetest.txt", OpenFlags.O_CREAT.intValue() | OpenFlags.O_RDWR.intValue(), 0600);

        assertEquals(0600, posix.stat("jnr-posix-filetest.txt").mode() & 0777);

        result = posix.close(fd);
        assertEquals(0, result);

        new File("jnr-posix-filetest.txt").delete();
    }

    @Test
    public void writeTest() throws Throwable {
        String str = "To thine own self be true";
        File tmp = File.createTempFile("writeTest", "tmp");
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());

        int fd = posix.open(tmp.getAbsolutePath(), 1, 066);
        posix.write(fd, buffer, str.length());
        posix.close(fd);

        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
        assertEquals(raf.readLine(), new String(buffer.array()));
        posix.unlink(tmp.getAbsolutePath());
    }

    @Test
    public void pwriteTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            String str = "Now is the winter of our discontent";
            File tmp = File.createTempFile("pwriteTest", "tmp");
            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
            raf.write(str.getBytes());
            raf.close();

            String str2 = "summer";
            ByteBuffer buffer = ByteBuffer.wrap(str2.getBytes());

            int fd = posix.open(tmp.getAbsolutePath(), 1, 066);
            posix.pwrite(fd, buffer, str2.length(), 11);
            posix.close(fd);

            raf = new RandomAccessFile(tmp, "r");
            assertEquals(raf.readLine(), "Now is the summer of our discontent");
            posix.unlink(tmp.getAbsolutePath());
        }
    }

    @Test
    public void truncateTest() throws Throwable {
        String str = "Beware the Jabberwock, my son!";
        File tmp = File.createTempFile("truncateTest", "tmp");
        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
        raf.write(str.getBytes());
        raf.close();

        int shorterLength = str.length() - 10;
        int longerLength = shorterLength * 2;

        // Truncate should make a file shorter if the new length is less than the old length.
        posix.truncate(tmp.getAbsolutePath(), shorterLength);
        assertEquals(shorterLength, tmp.length());

        // Truncate should extend a file if the new length is greater than the old length.
        posix.truncate(tmp.getAbsolutePath(), longerLength);
        assertEquals(longerLength, tmp.length());
    }

    @Test
    public void ftruncateTest() throws Throwable {
        String str = "Beware the Jabberwock, my son!";
        File tmp = File.createTempFile("ftruncateTest", "tmp");
        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
        raf.write(str.getBytes());
        raf.close();

        int fd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
        posix.ftruncate(fd, 21);
        posix.lseekLong(fd, 0, 0);
        byte[] buf = new byte[21];
        int read = posix.read(fd, buf, 31);
        assertEquals(21, read);
        assertArrayEquals(buf, "Beware the Jabberwock".getBytes());
    }

    @Test
    public void fcntlIntTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            int[] fds = new int[2];
            int ret = posix.pipe(fds);
            assertEquals(0, ret);
            int flags = posix.fcntlInt(fds[0], Fcntl.F_GETFD, 0);
            posix.fcntlInt(fds[0], Fcntl.F_SETFD, flags | 1); // FD_CLOEXEC
            assertEquals(flags | 1, posix.fcntlInt(fds[0], Fcntl.F_GETFD, 0));
        }
    }

    @Test
    public void fchmodTest() throws IOException {
        if (!Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("jnr-posix-chmod-test", "tmp");
            int fd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0600);

            assertEquals("chmod: ", 0, posix.fchmod(fd, 0));
            assertEquals("chmod: ", 0, posix.fchmod(fd, 0777));
            tmp.delete();
        }
    }


    @Test
    public void renameTest() throws IOException {
        File oldFile = File.createTempFile("jnr-posix-rename-test", "tmp");
        File newFile = new File(oldFile.getParent() + File.separatorChar + "jnr-posix-rename-test-new");

        assertTrue(oldFile.exists());
        assertFalse(newFile.exists());

        posix.rename(oldFile.getCanonicalPath(), newFile.getCanonicalPath());

        assertFalse(oldFile.exists());
        assertTrue(newFile.exists());

        newFile.delete();
    }

    @Test
    public void accessTest() throws IOException {
        File tmp = File.createTempFile("jnr-posix-access-test", "tmp");

        jnr.constants.platform.Access.F_OK.intValue();

        // Set permissions to read-only and verify we don't have permissions to write.
        String canonicalPath = tmp.getCanonicalPath();
        assertEquals("chmod 0400: ", 0, posix.chmod(canonicalPath, 0400));
        assertEquals("access " + canonicalPath + " for write: ", -1, posix.access(canonicalPath, Access.W_OK.intValue()));
        assertEquals("access " + canonicalPath + " for read: ", 0, posix.access(canonicalPath, Access.R_OK.intValue()));

        // Reset the permissions to read-write and verify we now have permissions to write.
        assertEquals("chmod 0600: ", 0, posix.chmod(canonicalPath, 0600));
        assertEquals("access " + canonicalPath + " for write: ", 0, posix.access(canonicalPath, Access.W_OK.intValue()));
        assertEquals("access " + canonicalPath + " for read: ", 0, posix.access(canonicalPath, Access.R_OK.intValue()));

        // F_OK just checks the file exists and should pass.
        assertEquals("access " + canonicalPath + " exists: ", 0, posix.access(canonicalPath, Access.F_OK.intValue()));
    }

    @Test
    public void readlinkTest() throws IOException {
        if (!Platform.IS_WINDOWS) {
            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
            File link = new File(file.getAbsolutePath() + "link");

            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());

            byte[] fileBytes = file.getAbsolutePath().getBytes();
            int fileLength = fileBytes.length;

            byte[] buffer = new byte[fileLength];

            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, buffer.length));

            assertArrayEquals(fileBytes, buffer);

            link.delete();
            file.delete();
        }
    }

    @Test
    public void readlinkByteBufferTest() throws IOException {
        if (!Platform.IS_WINDOWS) {
            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
            File link = new File(file.getAbsolutePath() + "link");

            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());

            byte[] fileBytes = file.getAbsolutePath().getBytes();
            int fileLength = fileBytes.length;
            ByteBuffer buffer = ByteBuffer.allocate(fileLength);

            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, buffer.capacity()));

            assertArrayEquals(buffer.array(), file.getAbsolutePath().getBytes());

            link.delete();
            file.delete();
        }
    }

    @Test
    public void readlinkPointerTest() throws IOException {
        if (!Platform.IS_WINDOWS) {
            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
            File link = new File(file.getAbsolutePath() + "link");

            int bufSize = 1024;

            Pointer buffer = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(bufSize);

            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());
            
            byte[] fileBytes = file.getAbsolutePath().getBytes();
            int fileLength = fileBytes.length;

            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, bufSize));

            assertEquals(file.getAbsolutePath(), buffer.getString(0, fileLength, Charset.defaultCharset()));

            link.delete();
            file.delete();
        }
    }

    @Test
    public void mkfifoTest() throws Throwable {
        if (!Platform.IS_WINDOWS) {
            File tmp = File.createTempFile("mkfifoTest", "tmp");
            tmp.deleteOnExit();

            int ret = posix.mkfifo(tmp.getAbsolutePath(), 0666);

            FileInputStream fis = new FileInputStream(tmp);
            FileOutputStream fos = new FileOutputStream(tmp);

            byte[] content = "hello".getBytes();

            fos.write(content);
            fis.read(content);

            assertArrayEquals("hello".getBytes(), content);
        }
    }

    @Test
    public void lseekTest() throws Throwable {
        if (Platform.IS_MAC) {
            int fd = posix.open("/dev/zero", 0, 0);

            // use 2^33 to ensure we're out of int range
            long offset = (long) Math.pow(2, 33);
            long seek = posix.lseekLong(fd, offset, 0);

            assertEquals(seek, offset);
        }
    }

    private int getFdFromDescriptor(FileDescriptor descriptor) {
        if (Platform.IS_WINDOWS) {
            HANDLE handle = JavaLibCHelper.gethandle(descriptor);
            return ((WindowsLibC) posix.libc())._open_osfhandle(handle, 0);
        } else {
            return JavaLibCHelper.getfdFromDescriptor(descriptor);
        }
    }

    private FileDescriptor toDescriptor(int fd) {
        if (Platform.IS_WINDOWS) {
            HANDLE handle = ((WindowsLibC) posix.libc())._get_osfhandle(fd);
            return JavaLibCHelper.toFileDescriptor(handle);
        } else {
            return JavaLibCHelper.toFileDescriptor(fd);
        }
    }

    private boolean hasNanosecondPrecision(FileStat fileStat) {
        return fileStat instanceof NanosecondFileStat && !Platform.IS_MAC;
    }

    private void utimensat(File file, int parentFd) {
        String path = file.getAbsolutePath();
        FileStat fileStat = posix.stat(path);
        if (!hasNanosecondPrecision(fileStat)) {
            file.delete();
            return;
        }

        long atimeSeconds = fileStat.atime()+2;
        long mtimeSeconds = fileStat.mtime()-2;
        long atimeNanoSeconds = 123456789;
        long mtimeNanoSeconds = 135;
        posix.utimensat(parentFd,
                path,
                new long[] {atimeSeconds, atimeNanoSeconds},
                new long[] {mtimeSeconds, mtimeNanoSeconds},
                0);
        assertStatNanoSecond(file, atimeSeconds, atimeNanoSeconds, mtimeSeconds, mtimeNanoSeconds);
    }

    private void assertStatNanoSecond(File file, long atimeSeconds, long atimeNanoSeconds, long mtimeSeconds, long mtimeNanoSeconds) {
        NanosecondFileStat nanosecondFileStat = (NanosecondFileStat) posix.stat(file.getPath());
        assertEquals("Access timestamp should be updated", atimeSeconds, nanosecondFileStat.atime());
        assertEquals("Modification timestamp should be updated", mtimeSeconds, nanosecondFileStat.mtime());
        assertEquals("Access time precision should be in ns", atimeNanoSeconds, nanosecondFileStat.aTimeNanoSecs());
        assertEquals("Modification time precision should be in ns", mtimeNanoSeconds, nanosecondFileStat.mTimeNanoSecs());
        file.delete();
    }
}