Katbin

> Task :atrium-api-fluent:jvmTest
          0.6sec, ch.tutteli.atrium.api.fluent.en_GB.samples.PathExpectationSamples > toHaveTheSameBinaryContentAs(), toHaveTheSameBinaryContentAs()[jvm]
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.samples.PathExpectationSamples > toBeASymbolicLink(), toBeASymbolicLink()[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\PathAssertionSamples6363126619003035338\link: A required privilege is not held by the client.
    
        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.api.fluent.en_GB.samples.PathExpectationSamples.toBeASymbolicLink(PathExpectationSamples.kt:22)

FAILURE   1.3sec,   21 completed,   1 failed,   0 skipped, ch.tutteli.atrium.api.fluent.en_GB.samples.PathExpectationSamples > ch.tutteli.atrium.api.fluent.en_GB.samples.PathExpectationSamples, PathExpectationSamples[jvm]

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > non-existent path[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toExist - throws an AssertionError[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > non-existent path[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: notToExist - does not throw[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > toExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > toExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > toExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > toExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > toExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > notToExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > not accessible[jvm] > notToExist has failure hints[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > existing[jvm] > file[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toExist - does not throw[jvm] SKIPPED       

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > existing[jvm] > file[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: notToExist - throws an AssertionError[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > existing[jvm] > directory[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toExist - does not throw[jvm] SKIPPED  

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toExist` and `notToExist`[jvm] > existing[jvm] > directory[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: notToExist - throws an AssertionError[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED    

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED    

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > ACL: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeReadable`[jvm] > ACL: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED     

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > POSIX: not readable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > ACL: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeReadable`[jvm] > ACL: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED       

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED    

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED    

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeWritable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED     

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > POSIX: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > ACL: not writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > ACL: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeWritable`[jvm] > ACL: writable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED       

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm]
 SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED  

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > ACL: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > ACL: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED     

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > ACL: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED       

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeExecutable`[jvm] > ACL: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED      

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED 

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > POSIX: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED       

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > ACL: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > ACL: not executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > ACL: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a file[jvm] SKIPPED        

PathExpectationsSpec[jvm] > [Atrium] describe fun  `notToBeExecutable`[jvm] > ACL: executable[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED   

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > via symbolic link: does not throw for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeARegularFile`[jvm] > via symbolic link: throws an AssertionError for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeASymbolicLink`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED                                                                                                                                                                                                                             

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeASymbolicLink`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeASymbolicLink`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeASymbolicLink`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeASymbolicLink`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw for a symbolic link, does not throw for a symbolic link[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek7479658920341993104\link: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.spek.extensions.MemoizedTempFolder.newSymbolicLink(MemoizedTempFolder.kt:62)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$26$4.invoke(PathExpectationsSpec.kt:1220)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$26$4.invoke(PathExpectationsSpec.kt:30)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)

FAILURE   0.1sec,   12 completed,   1 failed,   5 skipped, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > [Atrium] describe fun  `toBeASymbolicLink`, [Atrium] describe fun  `toBeASymbolicLink`[jvm]

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm]
 SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED  

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeADirectory`[jvm] > via symbolic link: does not throw for a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: throws an AssertionError for a non-existent path[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: prints the closest existing parent if it is a directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: explains if a parent is a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.prints an explanation for link loops[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > not accessible[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: POSIX: prints parent permission error details[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > via symbolic link: throws an AssertionError for a file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > via symbolic link: throws an AssertionError for a non-empty directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > via symbolic link: throws an AssertionError for a directory that contains an empty directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toBeAnEmptyDirectory`[jvm] > via symbolic link: does not throw for an empty directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the parameter is a child directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the parameter is a child file[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if the parameter is a child symlink with existing target, does not throw if the parameter is a child symlink with existing target[jvm]       
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek9782493671015842935\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$31$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:1390)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$31$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the parameter is a child symlink with existing target[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if the parameter is a child symlink with non-existing target, does not throw if the parameter is a child symlink with non-existing target[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek11894966488805030192\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$31$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:1390)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$31$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the parameter is a child symlink with non-existing target[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: throws if the parameter does not exist[jvm] SKIPPED
FAILURE   0.0sec,   10 completed,   2 failed,   5 skipped, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > [Atrium] describe fun  `toHaveTheDirectoryEntries`, [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm]        

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the single parameter is a child directory[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if two parameters are child directories[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if three parameters are child directories[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first directory does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the second directory does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the third directory does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first and third directories do not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the single parameter is a child file[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if two parameters are child files[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if three parameters are child files[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first file does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the second file does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the third file does not exist[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first and third files do not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if the single parameter is a child symlink with existing target, does not throw if the single parameter is a child symlink with existing target[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek13570000477335677720\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:1412)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the single parameter is a child symlink with existing target[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if two parameters are child symlinks with existing targets, does not throw if two parameters are child symlinks with existing targets[jvm]   
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek10946560903428058728\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$2.invoke(PathExpectationsSpec.kt:1418)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$2.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if two parameters are child symlinks with existing targets[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if three parameters are child symlinks with existing targets, does not throw if three parameters are child symlinks with existing targets[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek3278980666641816269\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$3.invoke(PathExpectationsSpec.kt:1425)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if three parameters are child symlinks with existing targets[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the first symlink with existing target does not exist, it throws if the first symlink with existing target does not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek11560982744356209390\startDir\file2: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$4.invoke(PathExpectationsSpec.kt:1433)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first symlink with existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the second symlink with existing target does not exist, it throws if the second symlink with existing target does not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek18430839934740342743\startDir\file1: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$5.invoke(PathExpectationsSpec.kt:1447)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$5.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the second symlink with existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the third symlink with existing target does not exist, it throws if the third symlink with existing target does not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek12520364212193544158\startDir\file1: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$6.invoke(PathExpectationsSpec.kt:1461)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$6.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the third symlink with existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the first and third symlinks with existing targets do not exist, it throws if the first and third symlinks with existing targets do not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek3324699664017193017\startDir\file2: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$7.invoke(PathExpectationsSpec.kt:1475)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$7.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first and third symlinks with existing targets do not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if the single parameter is a child symlink with non-existing target, does not throw if the single parameter is a child symlink with non-existing target[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek7851174131357332806\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:1412)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$1.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if the single parameter is a child symlink with non-existing target[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if two parameters are child symlinks with non-existing targets, does not throw if two parameters are child symlinks with non-existing targets[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek13679236978984250530\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$2.invoke(PathExpectationsSpec.kt:1418)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$2.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if two parameters are child symlinks with non-existing targets[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw if three parameters are child symlinks with non-existing targets, does not throw if three parameters are child symlinks with non-existing targets[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek5247934885983645357\startDir\a: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$3.invoke(PathExpectationsSpec.kt:1425)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw if three parameters are child symlinks with non-existing targets[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the first symlink with non-existing target does not exist, it throws if the first symlink with non-existing target does not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek1807319759114427023\startDir\file2: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$4.invoke(PathExpectationsSpec.kt:1433)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first symlink with non-existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the second symlink with non-existing target does not exist, it throws if the second symlink with non-existing target does not exist[jvm]       
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek3935592658836288286\startDir\file1: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$5.invoke(PathExpectationsSpec.kt:1447)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$5.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the second symlink with non-existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the third symlink with non-existing target does not exist, it throws if the third symlink with non-existing target does not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek701771934584576394\startDir\file1: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$6.invoke(PathExpectationsSpec.kt:1461)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$6.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the third symlink with non-existing target does not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > it throws if the first and third symlinks with non-existing targets do not exist, it throws if the first and third symlinks with non-existing targets do not exist[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek10542813946342907016\startDir\file2: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$4.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$7.invoke(PathExpectationsSpec.kt:1475)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$$special$$inlined$forEach$lambda$7.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the first and third symlinks with non-existing targets do not exist[jvm] SKIPPED
FAILURE   0.0sec, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > does not throw when using all entry types, does not throw when using all entry types[jvm]
    java.nio.file.FileSystemException: C:\Users\anmol\AppData\Local\Temp\spek16552948481363135809\startDir\file3: A required privilege is not held by the client.

        at java.base/sun.nio.fs.WindowsException.translateToIOException(WindowsException.java:92)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:103)
        at java.base/sun.nio.fs.WindowsException.rethrowAsIOException(WindowsException.java:108)
        at java.base/sun.nio.fs.WindowsFileSystemProvider.createSymbolicLink(WindowsFileSystemProvider.java:585)
        at java.base/java.nio.file.Files.createSymbolicLink(Files.java:1059)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:2051)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$hasDirectoryEntryVariations$3.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$2.invoke(PathExpectationsSpec.kt:1491)
        at ch.tutteli.atrium.specs.integration.PathExpectationsSpec$1$32$2.invoke(PathExpectationsSpec.kt:30)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1963)
        at ch.tutteli.atrium.specs.integration.SymlinkTestBuilder$callWith$1.invoke(PathExpectationsSpec.kt:1936)
        at org.spekframework.spek2.runtime.scope.TestScopeImpl.execute(scopes.kt:136)
        at org.spekframework.spek2.runtime.Executor$execute$result$2$exception$1$job$1.invokeSuspend(Executor.kt:74)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:561)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:727)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:667)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:655)


PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: does not throw when using all entry types[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm] > via symbolic link: it throws if the directory does not exist[jvm] SKIPPED
FAILURE   0.4sec,   60 completed,  15 failed,  30 skipped, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > [Atrium] describe fun  `toHaveTheDirectoryEntries`, [Atrium] describe fun  `toHaveTheDirectoryEntries`[jvm]        

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameBinaryContentAs - does not throw[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if ISO_8859_1, ISO_8859_1 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-16, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-8, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-16, ISO_8859_1 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > empty content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameBinaryContentAs - does not throw[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-8, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-16, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-8, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-16, ISO_8859_1 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same binary content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-8, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same textual content in UTF-8 and UTF-16[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameBinaryContentAs - throws AssertionError[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same textual content in UTF-8 and UTF-16[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - does not throw if UTF-8, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same textual content in UTF-8 and UTF-16[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-8, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same textual content in UTF-8 and UTF-16[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-16, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has same textual content in UTF-8 and UTF-16[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-8, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has different textual content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameBinaryContentAs - throws AssertionError[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has different textual content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-8, UTF-8 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has different textual content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-16, UTF-16 is used[jvm] SKIPPED

PathExpectationsSpec[jvm] > [Atrium] describe fun  `toHaveTheSameBinaryContentAs`, `toHaveTheSameTextualContentAs` and `toHaveTheSameTextualContentAs`[jvm] > has different textual content[jvm] > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec.via symbolic link: toHaveTheSameTextualContentAs - throws AssertionError if UTF-8, UTF-8 is used[jvm] SKIPPED
FAILURE   1.9sec,  473 completed,  18 failed, 194 skipped, ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec > ch.tutteli.atrium.api.fluent.en_GB.PathExpectationsSpec, PathExpectationsSpec[jvm]
jvmTest Result: FAILURE (4452 succeeded, 19 failed, 194 skipped)
FAILURE  42.1sec, 4665 completed,  19 failed, 194 skipped, Gradle Test Run :atrium-api-fluent:jvmTest, Gradle Test Run :atrium-api-fluent:jvmTest[jvm]                                                                                  

4665 tests completed, 19 failed, 194 skipped
There were failing tests. See the report at: file:///C:/Users/anmol/Documents/atrium/apis/fluent/atrium-api-fluent/build/reports/tests/jvmTest/index.html

> Task :atrium-api-fluent:allTests FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':atrium-api-fluent:allTests'.
> There were failing tests. See the report at: file:///C:/Users/anmol/Documents/atrium/apis/fluent/atrium-api-fluent/build/reports/tests/allTests/index.html

* Try:
> Run with --info or --debug option to get more log output.
> Run with --scan to get full insights.

* Exception is:
org.gradle.api.tasks.TaskExecutionException: Execution failed for task ':atrium-api-fluent:allTests'.
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.lambda$executeIfValid$1(ExecuteActionsTaskExecuter.java:149)
        at org.gradle.internal.Try$Failure.ifSuccessfulOrElse(Try.java:282)
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeIfValid(ExecuteActionsTaskExecuter.java:147)
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:135)
        at org.gradle.api.internal.tasks.execution.FinalizePropertiesTaskExecuter.execute(FinalizePropertiesTaskExecuter.java:46)
        at org.gradle.api.internal.tasks.execution.ResolveTaskExecutionModeExecuter.execute(ResolveTaskExecutionModeExecuter.java:51)
        at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:57)
        at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:74)
        at org.gradle.api.internal.tasks.execution.CatchExceptionTaskExecuter.execute(CatchExceptionTaskExecuter.java:36)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.executeTask(EventFiringTaskExecuter.java:77)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.call(EventFiringTaskExecuter.java:55)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.call(EventFiringTaskExecuter.java:52)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter.execute(EventFiringTaskExecuter.java:52)
        at org.gradle.execution.plan.LocalTaskNodeExecutor.execute(LocalTaskNodeExecutor.java:42)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$InvokeNodeExecutorsAction.execute(DefaultTaskExecutionGraph.java:337)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$InvokeNodeExecutorsAction.execute(DefaultTaskExecutionGraph.java:324)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$BuildOperationAwareExecutionAction.execute(DefaultTaskExecutionGraph.java:317)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$BuildOperationAwareExecutionAction.execute(DefaultTaskExecutionGraph.java:303)
        at org.gradle.execution.plan.DefaultPlanExecutor$ExecutorWorker.execute(DefaultPlanExecutor.java:463)
        at org.gradle.execution.plan.DefaultPlanExecutor$ExecutorWorker.run(DefaultPlanExecutor.java:380)
        at org.gradle.execution.plan.DefaultPlanExecutor.process(DefaultPlanExecutor.java:116)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph.executeWithServices(DefaultTaskExecutionGraph.java:138)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph.execute(DefaultTaskExecutionGraph.java:123)
        at org.gradle.execution.SelectedTaskExecutionAction.execute(SelectedTaskExecutionAction.java:35)
        at org.gradle.execution.DryRunBuildExecutionAction.execute(DryRunBuildExecutionAction.java:51)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor$ExecuteTasks.call(BuildOperationFiringBuildWorkerExecutor.java:54)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor$ExecuteTasks.call(BuildOperationFiringBuildWorkerExecutor.java:43)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor.execute(BuildOperationFiringBuildWorkerExecutor.java:40)
        at org.gradle.internal.build.DefaultBuildLifecycleController.lambda$executeTasks$10(DefaultBuildLifecycleController.java:202)
        at org.gradle.internal.model.StateTransitionController.doTransition(StateTransitionController.java:266)
        at org.gradle.internal.model.StateTransitionController.lambda$tryTransition$8(StateTransitionController.java:177)
        at org.gradle.internal.work.DefaultSynchronizer.withLock(DefaultSynchronizer.java:44)
        at org.gradle.internal.model.StateTransitionController.tryTransition(StateTransitionController.java:177)
        at org.gradle.internal.build.DefaultBuildLifecycleController.executeTasks(DefaultBuildLifecycleController.java:202)
        at org.gradle.internal.build.DefaultBuildWorkGraphController$DefaultBuildWorkGraph.runWork(DefaultBuildWorkGraphController.java:209)
        at org.gradle.internal.work.DefaultWorkerLeaseService.withLocks(DefaultWorkerLeaseService.java:249)
        at org.gradle.internal.work.DefaultWorkerLeaseService.runAsWorkerThread(DefaultWorkerLeaseService.java:109)
        at org.gradle.composite.internal.DefaultBuildController.doRun(DefaultBuildController.java:172)
        at org.gradle.composite.internal.DefaultBuildController.access$000(DefaultBuildController.java:47)
        at org.gradle.composite.internal.DefaultBuildController$BuildOpRunnable.run(DefaultBuildController.java:191)
        at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:64)
        at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:49)
Caused by: org.gradle.api.GradleException: There were failing tests. See the report at: file:///C:/Users/anmol/Documents/atrium/apis/fluent/atrium-api-fluent/build/reports/tests/allTests/index.html
        at org.jetbrains.kotlin.gradle.testing.internal.KotlinTestReport.checkFailedTests(KotlinTestReport.kt:155)
        at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:104)
        at org.gradle.internal.reflect.JavaMethod.invoke(JavaMethod.java:125)
        at org.gradle.api.internal.project.taskfactory.StandardTaskAction.doExecute(StandardTaskAction.java:58)
        at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:51)
        at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:29)
        at org.gradle.api.internal.tasks.execution.TaskExecution$3.run(TaskExecution.java:242)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$1.execute(DefaultBuildOperationRunner.java:29)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$1.execute(DefaultBuildOperationRunner.java:26)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.run(DefaultBuildOperationRunner.java:47)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.run(DefaultBuildOperationExecutor.java:68)
        at org.gradle.api.internal.tasks.execution.TaskExecution.executeAction(TaskExecution.java:227)
        at org.gradle.api.internal.tasks.execution.TaskExecution.executeActions(TaskExecution.java:210)
        at org.gradle.api.internal.tasks.execution.TaskExecution.executeWithPreviousOutputFiles(TaskExecution.java:193)
        at org.gradle.api.internal.tasks.execution.TaskExecution.execute(TaskExecution.java:166)
        at org.gradle.internal.execution.steps.ExecuteStep.executeInternal(ExecuteStep.java:105)
        at org.gradle.internal.execution.steps.ExecuteStep.access$000(ExecuteStep.java:44)
        at org.gradle.internal.execution.steps.ExecuteStep$1.call(ExecuteStep.java:59)
        at org.gradle.internal.execution.steps.ExecuteStep$1.call(ExecuteStep.java:56)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
        at org.gradle.internal.execution.steps.ExecuteStep.execute(ExecuteStep.java:56)
        at org.gradle.internal.execution.steps.ExecuteStep.execute(ExecuteStep.java:44)
        at org.gradle.internal.execution.steps.RemovePreviousOutputsStep.execute(RemovePreviousOutputsStep.java:67)
        at org.gradle.internal.execution.steps.RemovePreviousOutputsStep.execute(RemovePreviousOutputsStep.java:37)
        at org.gradle.internal.execution.steps.CancelExecutionStep.execute(CancelExecutionStep.java:41)
        at org.gradle.internal.execution.steps.TimeoutStep.executeWithoutTimeout(TimeoutStep.java:74)
        at org.gradle.internal.execution.steps.TimeoutStep.execute(TimeoutStep.java:55)
        at org.gradle.internal.execution.steps.CreateOutputsStep.execute(CreateOutputsStep.java:50)
        at org.gradle.internal.execution.steps.CreateOutputsStep.execute(CreateOutputsStep.java:28)
        at org.gradle.internal.execution.steps.CaptureStateAfterExecutionStep.executeDelegateBroadcastingChanges(CaptureStateAfterExecutionStep.java:100)
        at org.gradle.internal.execution.steps.CaptureStateAfterExecutionStep.execute(CaptureStateAfterExecutionStep.java:72)
        at org.gradle.internal.execution.steps.CaptureStateAfterExecutionStep.execute(CaptureStateAfterExecutionStep.java:50)
        at org.gradle.internal.execution.steps.ResolveInputChangesStep.execute(ResolveInputChangesStep.java:40)
        at org.gradle.internal.execution.steps.ResolveInputChangesStep.execute(ResolveInputChangesStep.java:29)
        at org.gradle.internal.execution.steps.BuildCacheStep.executeWithoutCache(BuildCacheStep.java:166)
        at org.gradle.internal.execution.steps.BuildCacheStep.lambda$execute$1(BuildCacheStep.java:70)
        at org.gradle.internal.Either$Right.fold(Either.java:175)
        at org.gradle.internal.execution.caching.CachingState.fold(CachingState.java:59)
        at org.gradle.internal.execution.steps.BuildCacheStep.execute(BuildCacheStep.java:68)
        at org.gradle.internal.execution.steps.BuildCacheStep.execute(BuildCacheStep.java:46)
        at org.gradle.internal.execution.steps.StoreExecutionStateStep.execute(StoreExecutionStateStep.java:36)
        at org.gradle.internal.execution.steps.StoreExecutionStateStep.execute(StoreExecutionStateStep.java:25)
        at org.gradle.internal.execution.steps.RecordOutputsStep.execute(RecordOutputsStep.java:36)
        at org.gradle.internal.execution.steps.RecordOutputsStep.execute(RecordOutputsStep.java:22)
        at org.gradle.internal.execution.steps.SkipUpToDateStep.executeBecause(SkipUpToDateStep.java:91)
        at org.gradle.internal.execution.steps.SkipUpToDateStep.lambda$execute$2(SkipUpToDateStep.java:55)
        at org.gradle.internal.execution.steps.SkipUpToDateStep.execute(SkipUpToDateStep.java:55)
        at org.gradle.internal.execution.steps.SkipUpToDateStep.execute(SkipUpToDateStep.java:37)
        at org.gradle.internal.execution.steps.ResolveChangesStep.execute(ResolveChangesStep.java:65)
        at org.gradle.internal.execution.steps.ResolveChangesStep.execute(ResolveChangesStep.java:36)
        at org.gradle.internal.execution.steps.legacy.MarkSnapshottingInputsFinishedStep.execute(MarkSnapshottingInputsFinishedStep.java:37)
        at org.gradle.internal.execution.steps.legacy.MarkSnapshottingInputsFinishedStep.execute(MarkSnapshottingInputsFinishedStep.java:27)
        at org.gradle.internal.execution.steps.ResolveCachingStateStep.execute(ResolveCachingStateStep.java:76)
        at org.gradle.internal.execution.steps.ResolveCachingStateStep.execute(ResolveCachingStateStep.java:37)
        at org.gradle.internal.execution.steps.ValidateStep.execute(ValidateStep.java:94)
        at org.gradle.internal.execution.steps.ValidateStep.execute(ValidateStep.java:49)
        at org.gradle.internal.execution.steps.CaptureStateBeforeExecutionStep.execute(CaptureStateBeforeExecutionStep.java:71)
        at org.gradle.internal.execution.steps.CaptureStateBeforeExecutionStep.execute(CaptureStateBeforeExecutionStep.java:45)
        at org.gradle.internal.execution.steps.SkipEmptyWorkStep.executeWithNonEmptySources(SkipEmptyWorkStep.java:177)
        at org.gradle.internal.execution.steps.SkipEmptyWorkStep.execute(SkipEmptyWorkStep.java:86)
        at org.gradle.internal.execution.steps.SkipEmptyWorkStep.execute(SkipEmptyWorkStep.java:53)
        at org.gradle.internal.execution.steps.RemoveUntrackedExecutionStateStep.execute(RemoveUntrackedExecutionStateStep.java:32)
        at org.gradle.internal.execution.steps.RemoveUntrackedExecutionStateStep.execute(RemoveUntrackedExecutionStateStep.java:21)
        at org.gradle.internal.execution.steps.legacy.MarkSnapshottingInputsStartedStep.execute(MarkSnapshottingInputsStartedStep.java:38)
        at org.gradle.internal.execution.steps.LoadPreviousExecutionStateStep.execute(LoadPreviousExecutionStateStep.java:36)
        at org.gradle.internal.execution.steps.LoadPreviousExecutionStateStep.execute(LoadPreviousExecutionStateStep.java:23)
        at org.gradle.internal.execution.steps.CleanupStaleOutputsStep.execute(CleanupStaleOutputsStep.java:75)
        at org.gradle.internal.execution.steps.CleanupStaleOutputsStep.execute(CleanupStaleOutputsStep.java:41)
        at org.gradle.internal.execution.steps.AssignWorkspaceStep.lambda$execute$0(AssignWorkspaceStep.java:32)
        at org.gradle.api.internal.tasks.execution.TaskExecution$4.withWorkspace(TaskExecution.java:287)
        at org.gradle.internal.execution.steps.AssignWorkspaceStep.execute(AssignWorkspaceStep.java:30)
        at org.gradle.internal.execution.steps.AssignWorkspaceStep.execute(AssignWorkspaceStep.java:21)
        at org.gradle.internal.execution.steps.IdentityCacheStep.execute(IdentityCacheStep.java:37)
        at org.gradle.internal.execution.steps.IdentityCacheStep.execute(IdentityCacheStep.java:27)
        at org.gradle.internal.execution.steps.IdentifyStep.execute(IdentifyStep.java:47)
        at org.gradle.internal.execution.steps.IdentifyStep.execute(IdentifyStep.java:34)
        at org.gradle.internal.execution.impl.DefaultExecutionEngine$1.execute(DefaultExecutionEngine.java:64)
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeIfValid(ExecuteActionsTaskExecuter.java:146)
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:135)
        at org.gradle.api.internal.tasks.execution.FinalizePropertiesTaskExecuter.execute(FinalizePropertiesTaskExecuter.java:46)
        at org.gradle.api.internal.tasks.execution.ResolveTaskExecutionModeExecuter.execute(ResolveTaskExecutionModeExecuter.java:51)
        at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:57)
        at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:74)
        at org.gradle.api.internal.tasks.execution.CatchExceptionTaskExecuter.execute(CatchExceptionTaskExecuter.java:36)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.executeTask(EventFiringTaskExecuter.java:77)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.call(EventFiringTaskExecuter.java:55)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter$1.call(EventFiringTaskExecuter.java:52)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
        at org.gradle.api.internal.tasks.execution.EventFiringTaskExecuter.execute(EventFiringTaskExecuter.java:52)
        at org.gradle.execution.plan.LocalTaskNodeExecutor.execute(LocalTaskNodeExecutor.java:42)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$InvokeNodeExecutorsAction.execute(DefaultTaskExecutionGraph.java:337)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$InvokeNodeExecutorsAction.execute(DefaultTaskExecutionGraph.java:324)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$BuildOperationAwareExecutionAction.execute(DefaultTaskExecutionGraph.java:317)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph$BuildOperationAwareExecutionAction.execute(DefaultTaskExecutionGraph.java:303)
        at org.gradle.execution.plan.DefaultPlanExecutor$ExecutorWorker.execute(DefaultPlanExecutor.java:463)
        at org.gradle.execution.plan.DefaultPlanExecutor$ExecutorWorker.run(DefaultPlanExecutor.java:380)
        at org.gradle.execution.plan.DefaultPlanExecutor.process(DefaultPlanExecutor.java:116)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph.executeWithServices(DefaultTaskExecutionGraph.java:138)
        at org.gradle.execution.taskgraph.DefaultTaskExecutionGraph.execute(DefaultTaskExecutionGraph.java:123)
        at org.gradle.execution.SelectedTaskExecutionAction.execute(SelectedTaskExecutionAction.java:35)
        at org.gradle.execution.DryRunBuildExecutionAction.execute(DryRunBuildExecutionAction.java:51)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor$ExecuteTasks.call(BuildOperationFiringBuildWorkerExecutor.java:54)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor$ExecuteTasks.call(BuildOperationFiringBuildWorkerExecutor.java:43)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
        at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
        at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
        at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
        at org.gradle.execution.BuildOperationFiringBuildWorkerExecutor.execute(BuildOperationFiringBuildWorkerExecutor.java:40)
        at org.gradle.internal.build.DefaultBuildLifecycleController.lambda$executeTasks$10(DefaultBuildLifecycleController.java:202)
        at org.gradle.internal.model.StateTransitionController.doTransition(StateTransitionController.java:266)
        at org.gradle.internal.model.StateTransitionController.lambda$tryTransition$8(StateTransitionController.java:177)
        at org.gradle.internal.work.DefaultSynchronizer.withLock(DefaultSynchronizer.java:44)
        at org.gradle.internal.model.StateTransitionController.tryTransition(StateTransitionController.java:177)
        at org.gradle.internal.build.DefaultBuildLifecycleController.executeTasks(DefaultBuildLifecycleController.java:202)
        at org.gradle.internal.build.DefaultBuildWorkGraphController$DefaultBuildWorkGraph.runWork(DefaultBuildWorkGraphController.java:209)
        at org.gradle.internal.work.DefaultWorkerLeaseService.withLocks(DefaultWorkerLeaseService.java:249)
        at org.gradle.internal.work.DefaultWorkerLeaseService.runAsWorkerThread(DefaultWorkerLeaseService.java:109)
        at org.gradle.composite.internal.DefaultBuildController.doRun(DefaultBuildController.java:172)
        at org.gradle.composite.internal.DefaultBuildController.access$000(DefaultBuildController.java:47)
        at org.gradle.composite.internal.DefaultBuildController$BuildOpRunnable.run(DefaultBuildController.java:191)
        at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:64)
        at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:49)


* Get more help at https://help.gradle.org

BUILD FAILED in 1m 40s
180 actionable tasks: 24 executed, 156 up-to-date