java.lang.Object
- org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
- - org.assertj.core.api.AbstractObjectAssert<SELF,ACTUAL>
  - - org.assertj.core.api.AbstractComparableAssert<SELF,Path>
    - - org.assertj.core.api.AbstractPathAssert<SELF>

Type Parameters:

SELF - self type

All Implemented Interfaces:

Assert<SELF,Path>, ComparableAssert<SELF,Path>, Descriptable<SELF>, ExtensionPoints<SELF,Path>

Direct Known Subclasses:

PathAssert
```
public abstract class AbstractPathAssert<SELF extends AbstractPathAssert<SELF>>
extends AbstractComparableAssert<SELF,Path>
```
Assertions for Path objects
Note that some assertions have two versions: a normal one and a "raw" one (for instance, hasParent() and hasParentRaw(). The difference is that normal assertions will canonicalize or normalize the tested path and, where applicable, the path argument, before performing the actual test. Canonicalization includes normalization.

Canonicalization may lead to an I/O error if a path does not exist, in which case the given assertions will fail with a PathsException. Also note that symbolic links will be followed if the filesystem supports them. Finally, if a path is not absolute, canonicalization will resolve the path against the process' current working directory.

These assertions are filesystem independent. You may use them on Path instances issued from the default filesystem (ie, instances you get when using Paths.get(String, String...)) or from other filesystems. For more information, see the javadoc for FileSystem.

Furthermore:
- Unless otherwise noted, assertions which accept arguments will not accept null arguments; if a null argument is passed, these assertions will throw a NullPointerException.
- It is the caller's responsibility to ensure that paths used in assertions are issued from valid filesystems which are not closed. If a filesystems is closed, assertions will throw a ClosedFileSystemException.
- Some assertions take another Path as an argument. If this path is not issued from the same provider as the tested path, assertions will throw a ProviderMismatchException.
- Some assertions may need to perform I/O on the path's underlying filesystem; if an I/O error occurs when accessing the filesystem, these assertions will throw a PathsException.
Author:

Valeriy Vyrva

See Also:

Path, Paths.get(String, String...), FileSystem, FileSystem.getPath(String, String...), FileSystems.getDefault(), Files

Field Summary

Fields
Modifier and Type Field Description

(package private) Charset charset

protected Paths paths
- Fields inherited from class org.assertj.core.api.AbstractComparableAssert
  comparables
- Fields inherited from class org.assertj.core.api.AbstractAssert
  actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors
Constructor Description

AbstractPathAssert(Path actual, Class<?> selfType)

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`SELF`	`doesNotExist()`	Assert that the tested `Path` does not exist.
`SELF`	`endsWith(Path other)`	Assert that the tested `Path` ends with the given path.
`SELF`	`endsWithRaw(Path other)`	Assert that the tested `Path` ends with the given path.
`SELF`	`exists()`	Assert that the tested `Path` exists according to `Files#exists(Path)`)
`SELF`	`existsNoFollowLinks()`	Assert that the tested `Path` exists, not following symbolic links, by calling `Files#exists(Path, LinkOption.NOFOLLOW_LINKS)`).
`SELF`	`hasBinaryContent(byte[] expected)`	Verifies that the binary content of the actual `Path` is exactly equal to the given one.
`SELF`	`hasContent(String expected)`	Verifies that the text content of the actual `Path` (which must be a readable file) is exactly equal to the given one. The charset to use when reading the actual path should be provided with `usingCharset(Charset)` or `usingCharset(String)` prior to calling this method; if not, the platform's default charset (as returned by `Charset.defaultCharset()`) will be used.
`SELF`	`hasDigest(String algorithm, byte[] expected)`	Verifies that the tested `Path` digest (calculated with the specified algorithm) is equal to the given one.
`SELF`	`hasDigest(String algorithm, String expected)`	Verifies that the tested `Path` digest (calculated with the specified algorithm) is equal to the given one.
`SELF`	`hasDigest(MessageDigest digest, byte[] expected)`	Verifies that the tested `Path` digest (calculated with the specified `MessageDigest`) is equal to the given one.
`SELF`	`hasDigest(MessageDigest digest, String expected)`	Verifies that the tested `Path` digest (calculated with the specified `MessageDigest`) is equal to the given one.
`SELF`	`hasFileName(String fileName)`	Assert that the tested `Path` last element String representation is equal to the given filename.
`SELF`	`hasNoParent()`	Assert that the tested `Path` has no parent.
`SELF`	`hasNoParentRaw()`	Assert that the tested `Path` has no parent.
`SELF`	`hasParent(Path expected)`	Assert that the tested `Path` has the expected parent path.
`SELF`	`hasParentRaw(Path expected)`	Assert that the tested `Path` has the expected parent path.
`SELF`	`hasSameBinaryContentAs(Path expected)`	Verifies that the content of the actual `Path` is equal to the content of the given one, the comparison is done at the binary level. For text files, use `hasSameTextualContentAs(Path)` or `hasSameTextualContentAs(Path, Charset)`.
`SELF`	`hasSameContentAs(Path expected)`	Deprecated. use `hasSameTextualContentAs(Path)` instead
`SELF`	`hasSameContentAs(Path expected, Charset expectedCharset)`	Deprecated. use `hasSameTextualContentAs(Path, Charset)` instead
`SELF`	`hasSameTextualContentAs(Path expected)`	Verifies that the content of the actual `Path` is the same as the given one (both paths must be a readable files).
`SELF`	`hasSameTextualContentAs(Path expected, Charset expectedCharset)`	Verifies that the content of the actual `Path` is the same as the expected one, the expected `Path` being read with the given charset while the charset used to read the actual path can be provided with `usingCharset(Charset)` or `usingCharset(String)` prior to calling this method; if not, the platform's default charset (as returned by `Charset.defaultCharset()`) will be used.
`SELF`	`isAbsolute()`	Assert that the tested `Path` is absolute (the path does not have to exist).
`SELF`	`isCanonical()`	Assert that the tested `Path` is canonical by comparing it to its `real path`.
`SELF`	`isDirectory()`	Assert that the tested `Path` is a directory.
`SELF`	`isDirectoryContaining(String syntaxAndPattern)`	Verify that the actual `Path` is a directory containing at least one file matching the given `String` interpreted as a path matcher (as per `FileSystem.getPathMatcher(String)`).
`SELF`	`isDirectoryContaining(Predicate<Path> filter)`	Verify that the actual `Path` is a directory containing at least one file matching the given `Predicate<Path>`.
`SELF`	`isDirectoryNotContaining(String syntaxAndPattern)`	Verify that the actual `Path` is a directory that does not contain any files matching the given `String` interpreted as a path matcher (as per `FileSystem.getPathMatcher(String)`).
`SELF`	`isDirectoryNotContaining(Predicate<Path> filter)`	Verify that the actual `Path` is a directory that does not contain any files matching the given `Predicate<Path>`.
`SELF`	`isDirectoryRecursivelyContaining(String syntaxAndPattern)`	Verify that the actual `Path` directory or any of its subdirectories (recursively) contains at least one file matching the given `String` interpreted as a path matcher (as per `FileSystem.getPathMatcher(String)`).
`SELF`	`isDirectoryRecursivelyContaining(Predicate<Path> filter)`	Verify that the actual `Path` directory or any of its subdirectories (recursively) contains at least one file matching the given `Predicate<Path>`.
`SELF`	`isEmptyDirectory()`	Verify that the actual `Path` is an empty directory.
`SELF`	`isExecutable()`	Assert that the tested `Path` is an executable file, it checks that the file exists (according to `Files.exists(Path, LinkOption...)`) and that it is executable(according to `Files.isExecutable(Path)` ).
`SELF`	`isNormalized()`	Assert that the tested `Path` is normalized.
`SELF`	`isNotEmptyDirectory()`	Verify that the actual `Path` is a non empty directory.
`SELF`	`isReadable()`	Assert that the tested `Path` is a readable file, it checks that the file exists (according to `Files.exists(Path, LinkOption...)`) and that it is readable(according to `Files.isReadable(Path)`).
`SELF`	`isRegularFile()`	Assert that the tested `Path` is a regular file.
`SELF`	`isRelative()`	Assert that the tested `Path` is relative (opposite to `Path.isAbsolute()`).
`SELF`	`isSymbolicLink()`	Assert that the tested `Path` is a symbolic link.
`SELF`	`isWritable()`	Assert that the tested `Path` is a writable file, it checks that the file exists (according to `Files.exists(Path, LinkOption...)`) and that it is writable(according to `Files.isWritable(Path)`).
`SELF`	`startsWith(Path other)`	Assert that the tested `Path` starts with the given path.
`SELF`	`startsWithRaw(Path other)`	Assert that the tested `Path` starts with the given path.
`SELF`	`usingCharset(String charsetName)`	Specifies the name of the charset to use for text-based assertions on the path's contents (path must be a readable file).
`SELF`	`usingCharset(Charset charset)`	Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file).

Methods inherited from class org.assertj.core.api.AbstractComparableAssert
inBinary, inHexadecimal, isBetween, isEqualByComparingTo, isGreaterThan, isGreaterThanOrEqualTo, isLessThan, isLessThanOrEqualTo, isNotEqualByComparingTo, isStrictlyBetween, usingComparator, usingComparator, usingDefaultComparator

Methods inherited from class org.assertj.core.api.AbstractAssert
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, extracting, extracting, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.core.api.Descriptable
describedAs

Field Detail
- paths
```
protected Paths paths
```
- charset
```
Charset charset
```

Constructor Detail

AbstractPathAssert

public AbstractPathAssert(Path actual,
                          Class<?> selfType)

Method Detail

hasSameContentAs

@Deprecated
public SELF hasSameContentAs(Path expected)

Deprecated.

use hasSameTextualContentAs(Path) instead

Verifies that the content of the actual Path is the same as the given one (both paths must be a readable files). The charset to use when reading the actual path can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset.defaultCharset()) will be used. Examples:

 // use the default charset
 Path xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes());
 Path xFileUTF8 = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes("UTF-8"));
 Path xFileClone = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes());
 Path xFileFrench = Files.write(Paths.get("xfile-french.txt"), "La Vérité Est Ailleurs".getBytes());

 // The following assertion succeeds (default charset is used):
 assertThat(xFile).hasSameContentAs(xFileClone);
 // The following assertion succeeds (UTF-8 charset is used to read xFile):
 assertThat(xFileUTF8).usingCharset("UTF-8").hasContent(xFileClone);

 // The following assertion fails:
 assertThat(xFile).hasSameContentAs(xFileFrench);

Parameters:: expected - the given Path to compare the actual Path to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given Path is null.; AssertionError - if the actual or given Path is not an existing readable file.; AssertionError - if the actual Path is null.; AssertionError - if the content of the actual Path is not equal to the content of the given one.; PathsException - if an I/O error occurs.

hasSameTextualContentAs

public SELF hasSameTextualContentAs(Path expected)

Verifies that the content of the actual Path is the same as the given one (both paths must be a readable files). The charset to use when reading the actual path can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset.defaultCharset()) will be used.

Examples:

 // use the default charset
 Path xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes());
 Path xFileUTF8 = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes("UTF-8"));
 Path xFileClone = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes());
 Path xFileFrench = Files.write(Paths.get("xfile-french.txt"), "La Vérité Est Ailleurs".getBytes());

 // The following assertion succeeds (default charset is used):
 assertThat(xFile).hasSameTextualContentAs(xFileClone);
 // The following assertion succeeds (UTF-8 charset is used to read xFile):
 assertThat(xFileUTF8).usingCharset("UTF-8").hasContent(xFileClone);

 // The following assertion fails:
 assertThat(xFile).hasSameTextualContentAs(xFileFrench);

Parameters:: expected - the given Path to compare the actual Path to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given Path is null.; AssertionError - if the actual or given Path is not an existing readable file.; AssertionError - if the actual Path is null.; AssertionError - if the content of the actual Path is not equal to the content of the given one.; PathsException - if an I/O error occurs.
Since:: 3.15

hasSameTextualContentAs
```
public SELF hasSameTextualContentAs(Path expected,
                                    Charset expectedCharset)
```
Verifies that the content of the actual Path is the same as the expected one, the expected Path being read with the given charset while the charset used to read the actual path can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset.defaultCharset()) will be used.
Examples:
```
 Path fileUTF8Charset = Files.write(Paths.get("actual"), Collections.singleton("Gerçek"), StandardCharsets.UTF_8);
 Charset turkishCharset = Charset.forName("windows-1254");
 Path fileTurkischCharset = Files.write(Paths.get("expected"), Collections.singleton("Gerçek"), turkishCharset);

 // The following assertion succeeds:
 assertThat(fileUTF8Charset).usingCharset(StandardCharsets.UTF_8).hasSameTextualContentAs(fileTurkischCharset, turkishCharset);

 // The following assertion fails:
 assertThat(fileUTF8Charset).usingCharset(StandardCharsets.UTF_8).hasSameTextualContentAs(fileTurkischCharset, StandardCharsets.UTF_8);
```
Parameters:

expected - the given Path to compare the actual Path to.

expectedCharset - the Charset used to read the content of the expected Path.

Returns:

this assertion object.

Throws:

NullPointerException - if the given Path is null.

AssertionError - if the actual or given Path is not an existing readable file.

AssertionError - if the actual Path is null.

AssertionError - if the content of the actual Path is not equal to the content of the given one.

PathsException - if an I/O error occurs.

Since:

3.15

hasSameContentAs
```
@Deprecated
public SELF hasSameContentAs(Path expected,
                             Charset expectedCharset)
```
Deprecated.
use hasSameTextualContentAs(Path, Charset) instead
Verifies that the content of the actual Path is the same as the expected one, the expected Path being read with the given charset while the charset used to read the actual path can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset.defaultCharset()) will be used.
Examples:
```
 Path fileUTF8Charset = Files.write(Paths.get("actual"), Collections.singleton("Gerçek"), StandardCharsets.UTF_8);
 Charset turkishCharset = Charset.forName("windows-1254");
 Path fileTurkischCharset = Files.write(Paths.get("expected"), Collections.singleton("Gerçek"), turkishCharset);

 // The following assertion succeeds:
 assertThat(fileUTF8Charset).usingCharset(StandardCharsets.UTF_8).hasSameContentAs(fileTurkischCharset, turkishCharset);

 // The following assertion fails:
 assertThat(fileUTF8Charset).usingCharset(StandardCharsets.UTF_8).hasSameContentAs(fileTurkischCharset, StandardCharsets.UTF_8);
```
Parameters:

expected - the given Path to compare the actual Path to.

expectedCharset - the Charset used to read the content of the expected Path.

Returns:

this assertion object.

Throws:

NullPointerException - if the given Path is null.

AssertionError - if the actual or given Path is not an existing readable file.

AssertionError - if the actual Path is null.

AssertionError - if the content of the actual Path is not equal to the content of the given one.

PathsException - if an I/O error occurs.

hasBinaryContent

public SELF hasBinaryContent(byte[] expected)

Verifies that the binary content of the actual Path is exactly equal to the given one. Examples:

 // using the default charset, the following assertion succeeds:
 Path xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes());
 assertThat(xFile).hasBinaryContent("The Truth Is Out There".getBytes());

 // using a specific charset
 Charset turkishCharset = Charset.forName("windows-1254");
 Path xFileTurkish = Files.write(Paths.get("xfile.turk"), Collections.singleton("Gerçek Başka bir yerde mi"), turkishCharset);

 // The following assertion succeeds:
 String expectedContent = "Gerçek Başka bir yerde mi" + org.assertj.core.util.Compatibility.System.lineSeparator();
 byte[] binaryContent = expectedContent.getBytes(turkishCharset.name());
 assertThat(xFileTurkish).hasBinaryContent(binaryContent);

 // The following assertion fails ... unless you are in Turkey ;-):
 assertThat(xFileTurkish).hasBinaryContent("Gerçek Başka bir yerde mi".getBytes());

Parameters:: expected - the expected binary content to compare the actual Path's content to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given content is null.; AssertionError - if the actual Path is null.; AssertionError - if the actual Path is not an existing file.; UncheckedIOException - if an I/O error occurs.; AssertionError - if the content of the actual Path is not equal to the given binary content.

hasSameBinaryContentAs
```
public SELF hasSameBinaryContentAs(Path expected)
```
Verifies that the content of the actual Path is equal to the content of the given one, the comparison is done at the binary level.
For text files, use hasSameTextualContentAs(Path) or hasSameTextualContentAs(Path, Charset).
Examples:
```
 // The first two paths have the same contents, the third does not
 Path aPath = Files.write(Paths.get("a-file.bin"), new byte[] { 42 });
 Path bPath = Files.write(Paths.get("b-file.bin"), new byte[] { 42 });
 Path cPath = Files.write(Paths.get("c-file.bin"), new byte[] { 24 });

 // The following assertion succeeds:
 assertThat(aPath).hasSameBinaryContentAs(bPath);

 // The following assertion fails:
 assertThat(aPath).hasSameBinaryContent(cPath);
```
Parameters:

expected - the given Path to compare the actual Path to.

Returns:

this assertion object.

Throws:

NullPointerException - if the given Path is null.

IllegalArgumentException - if the given Path is not an existing file.

AssertionError - if the actual Path is null.

AssertionError - if the actual Path is not an existing file.

UncheckedIOException - if any I/O error occurs.

AssertionError - if the content of the actual Path is not equal to the content of the given one.

Since:

3.15

usingCharset

public SELF usingCharset(String charsetName)

Specifies the name of the charset to use for text-based assertions on the path's contents (path must be a readable file). Examples:

 Charset turkishCharset = Charset.forName("windows-1254");
 Path xFileTurkish = Files.write(Paths.get("xfile.turk"), Collections.singleton("Gerçek Başka bir yerde mi"), turkishCharset);

 // The following assertion succeeds:
 assertThat(xFileTurkish).usingCharset("windows-1254").hasContent("Gerçek Başka bir yerde mi");

Parameters:: charsetName - the name of the charset to use.
Returns:: this assertion object.
Throws:: IllegalArgumentException - if the given encoding is not supported on this platform.

usingCharset

public SELF usingCharset(Charset charset)

Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file). Examples:

 Charset turkishCharset = Charset.forName("windows-1254");
 Path xFileTurkish = Files.write(Paths.get("xfile.turk"), Collections.singleton("Gerçek Başka bir yerde mi"), turkishCharset);

 // The following assertion succeeds:
 assertThat(xFileTurkish).usingCharset(turkishCharset).hasContent("Gerçek Başka bir yerde mi");

Parameters:: charset - the charset to use.
Returns:: this assertion object.
Throws:: NullPointerException - if the given charset is null.

hasContent

public SELF hasContent(String expected)

Verifies that the text content of the actual Path (which must be a readable file) is exactly equal to the given one.
The charset to use when reading the actual path should be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset.defaultCharset()) will be used. Examples:

 // use the default charset
 Path xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes());

 // The following assertion succeeds (default charset is used):
 assertThat(xFile).hasContent("The Truth Is Out There");

 // The following assertion fails:
 assertThat(xFile).hasContent("La Vérité Est Ailleurs");

 // using a specific charset
 Charset turkishCharset = Charset.forName("windows-1254");

 Path xFileTurkish = Files.write(Paths.get("xfile.turk"), Collections.singleton("Gerçek Başka bir yerde mi"), turkishCharset);

 // The following assertion succeeds:
 assertThat(xFileTurkish).usingCharset(turkishCharset).hasContent("Gerçek Başka bir yerde mi");

 // The following assertion fails ... unless you are in Turkey ;-):
 assertThat(xFileTurkish).hasContent("Gerçek Başka bir yerde mi");

Parameters:: expected - the expected text content to compare the actual Path's content to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given content is null.; UncheckedIOException - if an I/O error occurs.; AssertionError - if the actual Path is null.; AssertionError - if the actual Path is not a readable file.; AssertionError - if the content of the actual Path is not equal to the given content.

isReadable

public SELF isReadable()

Assert that the tested Path is a readable file, it checks that the file exists (according to Files.exists(Path, LinkOption...)) and that it is readable(according to Files.isReadable(Path)). Examples:

 // Create a file and set permissions to be readable by all.
 Path readableFile = Paths.get("readableFile");
 Set<PosixFilePermission> perms = PosixFilePermissions.fromString("r--r--r--");
 Files.createFile(readableFile, PosixFilePermissions.asFileAttribute(perms));

 final Path symlinkToReadableFile = FileSystems.getDefault().getPath("symlinkToReadableFile");
 Files.createSymbolicLink(symlinkToReadableFile, readableFile);

 // Create a file and set permissions not to be readable.
 Path nonReadableFile = Paths.get("nonReadableFile");
 Set<PosixFilePermission> notReadablePerms = PosixFilePermissions.fromString("-wx------");
 Files.createFile(nonReadableFile, PosixFilePermissions.asFileAttribute(notReadablePerms));

 final Path nonExistentPath = FileSystems.getDefault().getPath("nonexistent");

 // The following assertions succeed:
 assertThat(readableFile).isReadable();
 assertThat(symlinkToReadableFile).isReadable();

 // The following assertions fail:
 assertThat(nonReadableFile).isReadable();
 assertThat(nonExistentPath).isReadable();

Returns:: self
See Also:: Files.isReadable(Path)

isWritable

public SELF isWritable()

Assert that the tested Path is a writable file, it checks that the file exists (according to Files.exists(Path, LinkOption...)) and that it is writable(according to Files.isWritable(Path)). Examples:

 Create a file and set permissions to be writable by all.
 Path writableFile = Paths.get("writableFile");
 Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-rw-rw-");
 Files.createFile(writableFile, PosixFilePermissions.asFileAttribute(perms));

 final Path symlinkToWritableFile = FileSystems.getDefault().getPath("symlinkToWritableFile");
 Files.createSymbolicLink(symlinkToWritableFile, writableFile);

 // Create a file and set permissions not to be writable.
 Path nonWritableFile = Paths.get("nonWritableFile");
 perms = PosixFilePermissions.fromString("r--r--r--");
 Files.createFile(nonWritableFile, PosixFilePermissions.asFileAttribute(perms));

 final Path nonExistentPath = FileSystems.getDefault().getPath("nonexistent");

 // The following assertions succeed:
 assertThat(writableFile).isWritable();
 assertThat(symlinkToWritableFile).isWritable();

 // The following assertions fail:
 assertThat(nonWritableFile).isWritable();
 assertThat(nonExistentPath).isWritable();

Returns:: self
See Also:: Files.isWritable(Path)

isExecutable

public SELF isExecutable()

Assert that the tested Path is an executable file, it checks that the file exists (according to Files.exists(Path, LinkOption...)) and that it is executable(according to Files.isExecutable(Path) ). Examples:

 // Create a file and set permissions to be executable by all.
 Path executableFile = Paths.get("executableFile");
 Set<PosixFilePermission> perms = PosixFilePermissions.fromString("r-xr-xr-x");
 Files.createFile(executableFile, PosixFilePermissions.asFileAttribute(perms));

 final Path symlinkToExecutableFile = FileSystems.getDefault().getPath("symlinkToExecutableFile");
 Files.createSymbolicLink(symlinkToExecutableFile, executableFile);

 // Create a file and set permissions not to be executable.
 Path nonExecutableFile = Paths.get("nonExecutableFile");
 perms = PosixFilePermissions.fromString("rw-------");
 Files.createFile(nonExecutableFile, PosixFilePermissions.asFileAttribute(perms));

 final Path nonExistentPath = FileSystems.getDefault().getPath("nonexistent");

 // The following assertions succeed:
 assertThat(executableFile).isExecutable();
 assertThat(symlinkToExecutableFile).isExecutable();

 // The following assertions fail:
 assertThat(nonExecutableFile).isExecutable();
 assertThat(nonExistentPath).isExecutable();

Returns:: self
See Also:: Files.isExecutable(Path)

exists

public SELF exists()

Assert that the tested Path exists according to Files#exists(Path))

Note that this assertion will follow symbolic links before asserting the path's existence.

On Windows system, this has no influence. On Unix systems, this means the assertion result will fail if the path is a symbolic link whose target does not exist. If you want to assert the existence of the symbolic link itself, use existsNoFollowLinks() instead.

Examples:

 // fs is a Unix filesystem
 // Create a regular file, and a symbolic link pointing to it
 final Path existingFile = fs.getPath("somefile");
 Files.createFile(existingFile);
 final Path symlinkToExistingFile = fs.getPath("symlinkToExistingFile");
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a symbolic link whose target does not exist
 final Path nonExistentPath = fs.getPath("nonexistent");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // The following assertions succeed:
 assertThat(existingFile).exists();
 assertThat(symlinkToExistingFile).exists();

 // The following assertions fail:
 assertThat(nonExistentPath).exists();
 assertThat(symlinkToNonExistentPath).exists();

Returns:: self
See Also:: Files.exists(Path, LinkOption...)

existsNoFollowLinks

public SELF existsNoFollowLinks()

Assert that the tested Path exists, not following symbolic links, by calling Files#exists(Path, LinkOption.NOFOLLOW_LINKS)).

This assertion behaves like exists(), with the difference that it can be used to assert the existence of a symbolic link even if its target is invalid.

Examples:

 // fs is a Unix filesystem
 // Create a regular file, and a symbolic link pointing to it
 final Path existingFile = fs.getPath("somefile");
 Files.createFile(existingFile);
 final Path symlinkToExistingFile = fs.getPath("symlink");
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a symbolic link whose target does not exist
 final Path nonExistentPath = fs.getPath("nonexistent");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // The following assertions succeed
 assertThat(existingFile).existsNoFollowLinks();
 assertThat(symlinkToExistingFile).existsNoFollowLinks();
 assertThat(symlinkToNonExistentPath).existsNoFollowLinks();

 // The following assertion fails
 assertThat(nonExistentPath).existsNoFollowLinks();

Returns:: self
See Also:: Files.exists(Path, LinkOption...)

doesNotExist

public SELF doesNotExist()

Assert that the tested Path does not exist.

IMPORTANT NOTE: this method will NOT follow symbolic links (provided that the underlying FileSystem of this path supports symbolic links at all).

This means that even if the link exists this assertion will fail even if the link's target does not exists - note that this is unlike the default behavior of exists().

If you are a Windows user, the above does not apply to you; if you are a Unix user however, this is important. Consider the following:

 // fs is a FileSystem
 // Create a regular file, and a symbolic link pointing to it
 final Path existingFile = fs.getPath("somefile");
 Files.createFile(existingFile);
 final Path symlinkToExistingFile = fs.getPath("symlink");
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a symbolic link to a nonexistent target file.
 final Path nonExistentPath = fs.getPath("nonExistentPath");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // The following assertion succeeds
 assertThat(nonExistentPath).doesNotExist();

 // The following assertions fail:
 assertThat(existingFile).doesNotExist();
 assertThat(symlinkToExistingFile).doesNotExist();
 // fail because symlinkToNonExistentPath exists even though its target does not.
 assertThat(symlinkToNonExistentPath).doesNotExist();

Returns:: self
See Also:: Files.notExists(Path, LinkOption...), LinkOption.NOFOLLOW_LINKS

isRegularFile

public SELF isRegularFile()

Assert that the tested Path is a regular file.

Note that this method will follow symbolic links. If you are a Unix user and wish to assert that a path is a symbolic link instead, use isSymbolicLink().

This assertion first asserts the existence of the path (using exists()) then checks whether the path is a regular file.

Examples:

 // fs is a Unix filesystem

 // Create a regular file, and a symbolic link to that regular file
 final Path existingFile = fs.getPath("existingFile");
 final Path symlinkToExistingFile = fs.getPath("symlinkToExistingFile");
 Files.createFile(existingFile);
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a directory, and a symbolic link to that directory
 final Path dir = fs.getPath("dir");
 final Path dirSymlink = fs.getPath("dirSymlink");
 Files.createDirectories(dir);
 Files.createSymbolicLink(dirSymlink, dir);

 // Create a nonexistent entry, and a symbolic link to that entry
 final Path nonExistentPath = fs.getPath("nonexistent");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // the following assertions succeed:
 assertThat(existingFile).isRegularFile();
 assertThat(symlinkToExistingFile).isRegularFile();

 // the following assertions fail because paths do not exist:
 assertThat(nonExistentPath).isRegularFile();
 assertThat(symlinkToNonExistentPath).isRegularFile();

 // the following assertions fail because paths exist but are not regular files:
 assertThat(dir).isRegularFile();
 assertThat(dirSymlink).isRegularFile();

Returns:: self

isDirectory

public SELF isDirectory()

Assert that the tested Path is a directory.

Note that this method will follow symbolic links. If you are a Unix user and wish to assert that a path is a symbolic link instead, use isSymbolicLink().

This assertion first asserts the existence of the path (using exists()) then checks whether the path is a directory.

Examples:

 // fs is a Unix filesystem

 // Create a regular file, and a symbolic link to that regular file
 final Path existingFile = fs.getPath("existingFile");
 final Path symlinkToExistingFile = fs.getPath("symlinkToExistingFile");
 Files.createFile(existingFile);
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a directory, and a symbolic link to that directory
 final Path dir = fs.getPath("dir");
 final Path dirSymlink = fs.getPath("dirSymlink");
 Files.createDirectories(dir);
 Files.createSymbolicLink(dirSymlink, dir);

 // Create a nonexistent entry, and a symbolic link to that entry
 final Path nonExistentPath = fs.getPath("nonexistent");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // the following assertions succeed:
 assertThat(dir).isDirectory();
 assertThat(dirSymlink).isDirectory();

 // the following assertions fail because paths do not exist:
 assertThat(nonExistentPath).isDirectory();
 assertThat(symlinkToNonExistentPath).isDirectory();

 // the following assertions fail because paths exist but are not directories:
 assertThat(existingFile).isDirectory();
 assertThat(symlinkToExistingFile).isDirectory();

Returns:: self

isSymbolicLink

public SELF isSymbolicLink()

Assert that the tested Path is a symbolic link.

This assertion first asserts the existence of the path (using existsNoFollowLinks()) then checks whether the path is a symbolic link.

Examples:

 // fs is a Unix filesystem

 // Create a regular file, and a symbolic link to that regular file
 final Path existingFile = fs.getPath("existingFile");
 final Path symlinkToExistingFile = fs.getPath("symlinkToExistingFile");
 Files.createFile(existingFile);
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // Create a directory, and a symbolic link to that directory
 final Path dir = fs.getPath("dir");
 final Path dirSymlink = fs.getPath("dirSymlink");
 Files.createDirectories(dir);
 Files.createSymbolicLink(dirSymlink, dir);

 // Create a nonexistent entry, and a symbolic link to that entry
 final Path nonExistentPath = fs.getPath("nonexistent");
 final Path symlinkToNonExistentPath = fs.getPath("symlinkToNonExistentPath");
 Files.createSymbolicLink(symlinkToNonExistentPath, nonExistentPath);

 // the following assertions succeed:
 assertThat(dirSymlink).isSymbolicLink();
 assertThat(symlinkToExistingFile).isSymbolicLink();
 assertThat(symlinkToNonExistentPath).isSymbolicLink();

 // the following assertion fails because the path does not exist:
 assertThat(nonExistentPath).isSymbolicLink();

 // the following assertions fail because paths exist but are not symbolic links
 assertThat(existingFile).isSymbolicLink();
 assertThat(dir).isSymbolicLink();

Returns:: self

isAbsolute

public SELF isAbsolute()

Assert that the tested Path is absolute (the path does not have to exist).

Note that the fact that a path is absolute does not mean that it is normalized: /foo/.. is absolute, for instance, but it is not normalized.

Examples:

 // unixFs is a Unix FileSystem

 // The following assertion succeeds:
 assertThat(unixFs.getPath("/foo/bar")).isAbsolute();

 // The following assertion fails:
 assertThat(unixFs.getPath("foo/bar")).isAbsolute();

 // windowsFs is a Windows FileSystem

 // The following assertion succeeds:
 assertThat(windowsFs.getPath("c:\\foo")).isAbsolute();

 // The following assertions fail:
 assertThat(windowsFs.getPath("foo\\bar")).isAbsolute();
 assertThat(windowsFs.getPath("c:foo")).isAbsolute();
 assertThat(windowsFs.getPath("\\foo\\bar")).isAbsolute();

Returns:: self
See Also:: Path.isAbsolute()

isRelative

public SELF isRelative()

Assert that the tested Path is relative (opposite to Path.isAbsolute()). Examples:

 // unixFs is a Unix FileSystem

 // The following assertions succeed:
 assertThat(unixFs.getPath("./foo/bar")).isRelative();
 assertThat(unixFs.getPath("foo/bar")).isRelative();

 // The following assertion fails:
 assertThat(unixFs.getPath("/foo/bar")).isRelative();

 // windowsFs is a Windows FileSystem

 // The following assertion succeeds:
 assertThat(windowsFs.getPath("foo\\bar")).isRelative();
 assertThat(windowsFs.getPath("c:foo")).isRelative();
 assertThat(windowsFs.getPath("\\foo\\bar")).isRelative();

 // The following assertions fail:
 assertThat(windowsFs.getPath("c:\\foo")).isRelative();

Returns:: self
See Also:: Path.isAbsolute()

isNormalized

public SELF isNormalized()

Assert that the tested Path is normalized.

A path is normalized if it has no redundant components; typically, on both Unix and Windows, this means that the path has no "self" components (.) and that its only parent components (..), if any, are at the beginning of the path.

Examples:

 // fs is a Unix filesystem

 // the following assertions succeed:
 assertThat(fs.getPath("/usr/lib")).isNormalized();
 assertThat(fs.getPath("a/b/c")).isNormalized();
 assertThat(fs.getPath("../d")).isNormalized();

 // the following assertions fail:
 assertThat(fs.getPath("/a/./b")).isNormalized();
 assertThat(fs.getPath("c/b/..")).isNormalized();
 assertThat(fs.getPath("/../../e")).isNormalized();

Returns:: self

isCanonical

public SELF isCanonical()

Assert that the tested Path is canonical by comparing it to its

real
 path

.

For Windows users, this assertion is no different than isAbsolute() expect that the file must exist. For Unix users, this assertion ensures that the tested path is the actual file system resource, that is, it is not a symbolic link to the actual resource, even if the path is absolute.

Examples:

 // fs is a Unix filesystem
 // Create a directory
 final Path basedir = fs.getPath("/tmp/foo");
 Files.createDirectories(basedir);

 // Create a file in this directory
 final Path existingFile = basedir.resolve("existingFile");
 Files.createFile(existingFile);

 // Create a symbolic link to that file
 final Path symlinkToExistingFile = basedir.resolve("symlinkToExistingFile");
 Files.createSymbolicLink(symlinkToExistingFile, existingFile);

 // The following assertion succeeds:
 assertThat(existingFile).isCanonical();

 // The following assertion fails:
 assertThat(symlinkToExistingFile).isCanonical();

Returns:: self
Throws:: PathsException - an I/O error occurred while evaluating the path
See Also:: Path.toRealPath(LinkOption...), Files.isSameFile(Path, Path)

hasFileName

public SELF hasFileName(String fileName)

Assert that the tested Path last element String representation is equal to the given filename.

Note that the path does not need to exist to check its file name.

Examples:

 // fs is a Unix filesystem
 final Path file = fs.getPath("/foo/foo.txt");
 final Path symlink = fs.getPath("/home/symlink-to-foo");
 Files.createSymbolicLink(symlink, file);

 // the following assertions succeed:
 assertThat(fs.getPath("/dir1/file.txt")).hasFileName("file.txt");
 assertThat(fs.getPath("/dir1/dir2")).hasFileName("dir2");
 // you can check file name on non existent paths
 assertThat(file).hasFileName("foo.txt");
 assertThat(symlink).hasFileName("symlink-to-foo");

 // the following assertions fail:
 assertThat(fs.getPath("/dir1/file.txt").hasFileName("other.txt");
 // fail because, last element is "."
 assertThat(fs.getPath("/dir1/.")).hasFileName("dir1");
 // fail because a link filename is not the same as its target filename
 assertThat(symlink).hasFileName("file.txt");

Parameters:: fileName - the expected filename
Returns:: self
Throws:: NullPointerException - if the given fileName is null.
See Also:: Path.getFileName()

hasParent
```
public SELF hasParent(Path expected)
```
Assert that the tested Path has the expected parent path.
This assertion will perform canonicalization of the tested path and of the given argument before performing the test; see the class description for more details. If this is not what you want, use hasParentRaw(Path) instead.

Checks that the tested path has the given parent. This assertion will fail both if the tested path has no parent, or has a different parent than what is expected.
Examples:
```
 // fs is a Unix filesystem
 final Path actual = fs.getPath("/dir1/dir2/file");

 // the following assertion succeeds:
 assertThat(actual).hasParent(fs.getPath("/dir1/dir2/."));
 // this one too as this path will be normalized to "/dir1/dir2":
 assertThat(actual).hasParent(fs.getPath("/dir1/dir3/../dir2/."));

 // the following assertion fails:
 assertThat(actual).hasParent(fs.getPath("/dir1"));
```
Parameters:

expected - the expected parent path

Returns:

self

Throws:

NullPointerException - if the given parent path is null.

PathsException - failed to canonicalize the tested path or the path given as an argument

See Also:

Path.getParent()

hasParentRaw
```
public SELF hasParentRaw(Path expected)
```
Assert that the tested Path has the expected parent path.
This assertion will not perform any canonicalization of either the tested path or the path given as an argument; see class description for more details. If this is not what you want, use hasParent(Path) instead.

This assertion uses Path.getParent() with no modification, which means the only criterion for this assertion's success is the path's components (its root and its name elements).

This may lead to surprising results if the tested path and the path given as an argument are not normalized. For instance, if the tested path is /home/foo/../bar and the argument is /home, the assertion will fail since the parent of the tested path is not /home but... /home/foo/...

While this may seem counterintuitive, it has to be recalled here that it is not required for a FileSystem to consider that . and .. are name elements for respectively the current directory and the parent directory respectively. In fact, it is not even required that a FileSystem be hierarchical at all.
Examples:
```
 // fs is a Unix filesystem
 final Path actual = fs.getPath("/dir1/dir2/file");

 // the following assertion succeeds:
 assertThat(actual).hasParentRaw(fs.getPath("/dir1/dir2"));

 // the following assertions fails:
 assertThat(actual).hasParent(fs.getPath("/dir1"));
 // ... and this one too as expected path is not canonicalized.
 assertThat(actual).hasParentRaw(fs.getPath("/dir1/dir3/../dir2"));
```
Parameters:

expected - the expected parent path

Returns:

self

Throws:

NullPointerException - if the given parent path is null.

See Also:

Path.getParent()

hasNoParent
```
public SELF hasNoParent()
```
Assert that the tested Path has no parent.
This assertion will first canonicalize the tested path before performing the test; if this is not what you want, use hasNoParentRaw() instead.

Check that the tested path, after canonicalization, has no parent. See the class description for more information about canonicalization.
Examples:
```
 // fs is a Unix filesystem

 // the following assertion succeeds:
 assertThat(fs.getPath("/")).hasNoParent();
 // this one too as path will be normalized to "/"
 assertThat(fs.getPath("/usr/..")).hasNoParent();

 // the following assertions fail:
 assertThat(fs.getPath("/usr/lib")).hasNoParent();
 assertThat(fs.getPath("/usr")).hasNoParent();
```
Returns:

self

Throws:

PathsException - failed to canonicalize the tested path

See Also:

Path.getParent()

hasNoParentRaw
```
public SELF hasNoParentRaw()
```
Assert that the tested Path has no parent.
This assertion will not canonicalize the tested path before performing the test; if this is not what you want, use hasNoParent() instead.

As canonicalization is not performed, this means the only criterion for this assertion's success is the path's components (its root and its name elements).

This may lead to surprising results. For instance, path /usr/.. does have a parent, and this parent is /usr.
Examples:
```
 // fs is a Unix filesystem

 // the following assertions succeed:
 assertThat(fs.getPath("/")).hasNoParentRaw();
 assertThat(fs.getPath("foo")).hasNoParentRaw();

 // the following assertions fail:
 assertThat(fs.getPath("/usr/lib")).hasNoParentRaw();
 assertThat(fs.getPath("/usr")).hasNoParentRaw();
 // this one fails as canonicalization is not performed, leading to parent being /usr
 assertThat(fs.getPath("/usr/..")).hasNoParent();
```
Returns:

self

See Also:

Path.getParent()

startsWith
```
public SELF startsWith(Path other)
```
Assert that the tested Path starts with the given path.
This assertion will perform canonicalization of both the tested path and the path given as an argument; see class description for more details. If this is not what you want, use startsWithRaw(Path) instead.

Checks that the given Path starts with another path. Note that the name components matter, not the string representation; this means that, for example, /home/foobar/baz does not start with /home/foo.
Examples:
```
 // fs is a Unix filesystem
 final Path tested = fs.getPath("/home/joe/myfile");

 // the following assertion succeeds:
 assertThat(tested).startsWith(fs.getPath("/home"));
 assertThat(tested).startsWith(fs.getPath("/home/"));
 assertThat(tested).startsWith(fs.getPath("/home/."));
 // assertion succeeds because this path will be canonicalized to "/home/joe"
 assertThat(tested).startsWith(fs.getPath("/home/jane/../joe/."));

 // the following assertion fails:
 assertThat(tested).startsWith(fs.getPath("/home/harry"));
```
Parameters:

other - the other path

Returns:

self

Throws:

NullPointerException - if the given path is null.

PathsException - failed to canonicalize the tested path or the path given as an argument

See Also:

Path.startsWith(Path), Path.toRealPath(LinkOption...)

startsWithRaw
```
public SELF startsWithRaw(Path other)
```
Assert that the tested Path starts with the given path.
This assertions does not perform canonicalization on either the tested path or the path given as an argument; see class description for more details. If this is not what you want, use startsWith(Path) instead.

Checks that the given Path starts with another path, without performing canonicalization on its arguments. This means that the only criterion to determine whether a path starts with another is the tested path's, and the argument's, name elements.

This may lead to some surprising results: for instance, path /../home/foo does not start with /home since the first name element of the former (..) is different from the first name element of the latter (home).
Examples:
```
 // fs is a Unix filesystem
 final Path tested = fs.getPath("/home/joe/myfile");

 // the following assertion succeeds:
 assertThat(tested).startsWithRaw(fs.getPath("/home/joe"));

 // the following assertion fails:
 assertThat(tested).startsWithRaw(fs.getPath("/home/harry"));
 // .... and this one too as given path is not canonicalized
 assertThat(tested).startsWithRaw(fs.getPath("/home/joe/.."));
```
Parameters:

other - the other path

Returns:

self

Throws:

NullPointerException - if the given path is null.

See Also:

Path.startsWith(Path)

endsWith
```
public SELF endsWith(Path other)
```
Assert that the tested Path ends with the given path.
This assertion will attempt to canonicalize the tested path and normalize the path given as an argument before performing the actual test.

Note that the criterion to determine success is determined by the path's name elements; therefore, /home/foobar/baz does not end with bar/baz.
Examples:
```
 // fs is a Unix filesystem.
 // the current directory is supposed to be /home.
 final Path tested = fs.getPath("/home/joe/myfile");
 // as tested will be canonicalized, it could have been written: /home/jane/../joe/myfile

 // the following assertion succeeds:
 assertThat(tested).endsWith(fs.getPath("joe/myfile"));

 // the following assertions fail:
 assertThat(tested).endsWith(fs.getPath("joe/otherfile"));
 // this path will be normalized to joe/otherfile
 assertThat(tested).endsWith(fs.getPath("joe/myfile/../otherfile"));
```
Parameters:

other - the other path

Returns:

self

Throws:

NullPointerException - if the given path is null.

PathsException - failed to canonicalize the tested path (see class description)

See Also:

Path.endsWith(Path), Path.toRealPath(LinkOption...)

endsWithRaw
```
public SELF endsWithRaw(Path other)
```
Assert that the tested Path ends with the given path.
This assertion will not perform any canonicalization (on the tested path) or normalization (on the path given as an argument); see the class description for more details. If this is not what you want, use endsWith(Path) instead.

This may lead to some surprising results; for instance, path /home/foo does not end with foo/. since the last name element of the former (foo) is different from the last name element of the latter (.).
Examples:
```
 // fs is a Unix filesystem
 // the current directory is supposed to be /home.
 final Path tested = fs.getPath("/home/joe/myfile");

 // The following assertion succeeds:
 assertThat(tested).endsWithRaw(fs.getPath("joe/myfile"));

 // But the following assertion fails:
 assertThat(tested).endsWithRaw(fs.getPath("harry/myfile"));
 // and this one too as the given path is not normalized
 assertThat(tested).endsWithRaw(fs.getPath("harry/../joe/myfile"));
```
Parameters:

other - the other path

Returns:

self

Throws:

NullPointerException - if the given path is null.

See Also:

Path.endsWith(Path)

hasDigest

public SELF hasDigest(MessageDigest digest,
                      byte[] expected)

Verifies that the tested Path digest (calculated with the specified MessageDigest) is equal to the given one.

Note that the Path must be readable.

Examples:

 // fs is a filesystem
 // assume that the current directory contains https://repo1.maven.org/maven2/org/assertj/assertj-core/2.9.0/assertj-core-2.9.0.jar.
 Path tested = Paths.get("assertj-core-2.9.0.jar");

 // The following assertions succeed:
 assertThat(tested).hasDigest(MessageDigest.getInstance("SHA1"), new byte[]{92, 90, -28, 91, 88, -15, 32, 35, -127, 122, -66, 73, 36, 71, -51, -57, -111, 44, 26, 44});
 assertThat(tested).hasDigest(MessageDigest.getInstance("MD5"), new byte[]{-36, -77, 1, 92, -46, -124, 71, 100, 76, -127, 10, -13, 82, -125, 44, 25});

 // The following assertions fail:
 assertThat(tested).hasDigest(MessageDigest.getInstance("SHA1"), "93b9ced2ee5b3f0f4c8e640e77470dab031d4cad".getBytes());
 assertThat(tested).hasDigest(MessageDigest.getInstance("MD5"), "3735dff8e1f9df0492a34ef075205b8f".getBytes());

Parameters:: digest - the MessageDigest used to calculate the digests.; expected - the expected binary content to compare the actual Path's content to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given algorithm is null.; NullPointerException - if the given digest is null.; AssertionError - if the actual Path is null.; AssertionError - if the actual Path does not exist.; AssertionError - if the actual Path is not an file.; AssertionError - if the actual Path is not readable.; UncheckedIOException - if any I/O error occurs.; AssertionError - if the content of the tested Path's digest is not equal to the given one.
Since:: 3.11.0

hasDigest

public SELF hasDigest(MessageDigest digest,
                      String expected)

Verifies that the tested Path digest (calculated with the specified MessageDigest) is equal to the given one.

Note that the Path must be readable.

Examples:

 // fs is a filesystem
 // assume that the current directory contains https://repo1.maven.org/maven2/org/assertj/assertj-core/2.9.0/assertj-core-2.9.0.jar.
 Path tested = Paths.get("assertj-core-2.9.0.jar");

 // The following assertions succeed:
 assertThat(tested).hasDigest(MessageDigest.getInstance("SHA1"), "5c5ae45b58f12023817abe492447cdc7912c1a2c");
 assertThat(tested).hasDigest(MessageDigest.getInstance("MD5"), "dcb3015cd28447644c810af352832c19");

 // The following assertions fail:
 assertThat(tested).hasDigest(MessageDigest.getInstance("SHA1"), "93b9ced2ee5b3f0f4c8e640e77470dab031d4cad");
 assertThat(tested).hasDigest(MessageDigest.getInstance("MD5"), "3735dff8e1f9df0492a34ef075205b8f");

Parameters:: digest - the MessageDigest used to calculate the digests.; expected - the expected binary content to compare the actual Path's content to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given algorithm is null.; NullPointerException - if the given digest is null.; AssertionError - if the actual Path is null.; AssertionError - if the actual Path does not exist.; AssertionError - if the actual Path is not an file.; AssertionError - if the actual Path is not readable.; UncheckedIOException - if any I/O error occurs.; AssertionError - if the content of the tested Path's digest is not equal to the given one.
Since:: 3.11.0

hasDigest

public SELF hasDigest(String algorithm,
                      byte[] expected)

Verifies that the tested Path digest (calculated with the specified algorithm) is equal to the given one.

Note that the Path must be readable.

Examples:

 // fs is a filesystem
 // assume that the current directory contains https://repo1.maven.org/maven2/org/assertj/assertj-core/2.9.0/assertj-core-2.9.0.jar.
 Path tested = Paths.get("assertj-core-2.9.0.jar");

 // The following assertions succeed:
 assertThat(tested).hasDigest("SHA1", new byte[]{92, 90, -28, 91, 88, -15, 32, 35, -127, 122, -66, 73, 36, 71, -51, -57, -111, 44, 26, 44});
 assertThat(tested).hasDigest("MD5", new byte[]{-36, -77, 1, 92, -46, -124, 71, 100, 76, -127, 10, -13, 82, -125, 44, 25});

 // The following assertions fail:
 assertThat(tested).hasDigest("SHA1", "93b9ced2ee5b3f0f4c8e640e77470dab031d4cad".getBytes());
 assertThat(tested).hasDigest("MD5", "3735dff8e1f9df0492a34ef075205b8f".getBytes());

Parameters:: algorithm - the algorithm used to calculate the digests to compare.; expected - the expected binary content to compare the actual Path's content to.
Returns:: this assertion object.
Throws:: NullPointerException - if the given algorithm is null.; NullPointerException - if the given digest is null.; AssertionError - if the actual Path is null.; AssertionError - if the actual Path does not exist.; AssertionError - if the actual Path is not an file.; AssertionError - if the actual Path is not readable.; UncheckedIOException - if any I/O error occurs.; AssertionError - if the content of the tested Path's digest is not equal to the given one.
Since:: 3.11.0

hasDigest
```
public SELF hasDigest(String algorithm,
                      String expected)
```
Verifies that the tested Path digest (calculated with the specified algorithm) is equal to the given one.
Note that the Path must be readable.
Examples:
```
 // assume that assertj-core-2.9.0.jar was downloaded from https://repo1.maven.org/maven2/org/assertj/assertj-core/2.9.0/assertj-core-2.9.0.jar
 Path tested = Paths.get("assertj-core-2.9.0.jar");

 // The following assertions succeed:
 assertThat(tested).hasDigest("SHA1", "5c5ae45b58f12023817abe492447cdc7912c1a2c");
 assertThat(tested).hasDigest("MD5", "dcb3015cd28447644c810af352832c19");

 // The following assertions fail:
 assertThat(tested).hasDigest("SHA1", "93b9ced2ee5b3f0f4c8e640e77470dab031d4cad");
 assertThat(tested).hasDigest("MD5", "3735dff8e1f9df0492a34ef075205b8f"); 
```
Parameters:

algorithm - the algorithm used to calculate the digests.

expected - the expected digest to compare the actual Path's digest to.

Returns:

this assertion object.

Throws:

NullPointerException - if the given algorithm is null.

NullPointerException - if the given digest is null.

AssertionError - if the actual Path is null.

AssertionError - if the actual Path does not exist.

AssertionError - if the actual Path is not an file.

AssertionError - if the actual Path is not readable.

UncheckedIOException - if any I/O error occurs.

AssertionError - if the content of the tested Path's digest is not equal to the given one.

Since:

3.11.0

isDirectoryContaining

public SELF isDirectoryContaining(Predicate<Path> filter)

Verify that the actual Path is a directory containing at least one file matching the given Predicate<Path>.

Note that the actual Path must exist and be a directory.

Given the following directory structure:

 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-file-1.ext
 /root/sub-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryContaining(path -> path.getFileName().toString().startsWith("sub-dir"))
                 .isDirectoryContaining(path -> path.getFileName().toString().startsWith("sub-file"))
                 .isDirectoryContaining(path -> path.getFileName().toString().endsWith(".ext"))
                 .isDirectoryContaining(Files::isDirectory);

 // The following assertions fail:
 assertThat(root).isDirectoryContaining(file -> file.getFileName().toString().startsWith("dir"));
 assertThat(root).isDirectoryContaining(file -> file.getFileName().toString().endsWith(".bin"));

Parameters:: filter - the filter for files located inside actual's directory.
Returns:: this assertion object.
Throws:: NullPointerException - if the given filter is null.; AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual does not contain any files matching the given predicate.
Since:: 3.13.0

isDirectoryContaining
```
public SELF isDirectoryContaining(String syntaxAndPattern)
```
Verify that the actual Path is a directory containing at least one file matching the given String interpreted as a path matcher (as per FileSystem.getPathMatcher(String)).
Note that the actual Path must exist and be a directory.
Given the following directory structure:
```
 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-file-1.ext
 /root/sub-file-2.ext
```
Here are some assertions examples:
```
 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryContaining("glob:**sub-dir*")
                 .isDirectoryContaining("glob:**sub-file*")
                 .isDirectoryContaining("glob:**.ext")
                 .isDirectoryContaining("regex:.*ext")
                 .isDirectoryContaining("glob:**.{ext,bin");

 // The following assertions fail:
 assertThat(root).isDirectoryContaining("glob:**dir");
 assertThat(root).isDirectoryContaining("glob:**.bin");
 assertThat(root).isDirectoryContaining("glob:**.{java,class}"); 
```
Parameters:

syntaxAndPattern - the syntax and pattern for PathMatcher as described in FileSystem.getPathMatcher(String).

Returns:

this assertion object.

Throws:

NullPointerException - if the given syntaxAndPattern is null.

AssertionError - if actual is null.

AssertionError - if actual does not exist.

AssertionError - if actual is not a directory.

AssertionError - if actual does not contain any files matching the given path matcher.

Since:

3.13.0

See Also:

FileSystem.getPathMatcher(String)

isDirectoryRecursivelyContaining
```
public SELF isDirectoryRecursivelyContaining(String syntaxAndPattern)
```
Verify that the actual Path directory or any of its subdirectories (recursively) contains at least one file matching the given String interpreted as a path matcher (as per FileSystem.getPathMatcher(String)).
That methods performs the same assertion as isDirectoryContaining(String syntaxAndPattern) but recursively.
Note that the actual Path must exist and be a directory.
Examples given the following directory structure:
```
 root
 |—— foo
 |    |—— foobar
 |         |—— foo-file-1.ext
 |—— foo-file-2.ext
 
```
```
 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryRecursivelyContaining("glob:**foo")
                 .isDirectoryRecursivelyContaining("glob:**ooba*")
                 .isDirectoryRecursivelyContaining("glob:**file-1.ext")
                 .isDirectoryRecursivelyContaining("regex:.*file-2.*")
                 .isDirectoryRecursivelyContaining("glob:**.{ext,dummy}");

 // The following assertions fail:
 assertThat(root).isDirectoryRecursivelyContaining("glob:**fooba");
 assertThat(root).isDirectoryRecursivelyContaining("glob:**.bin");
 assertThat(root).isDirectoryRecursivelyContaining("glob:**.{java,class}"); 
```
Parameters:

syntaxAndPattern - the syntax and pattern for PathMatcher as described in FileSystem.getPathMatcher(String).

Returns:

this assertion object.

Throws:

NullPointerException - if the given syntaxAndPattern is null.

AssertionError - if actual is null.

AssertionError - if actual does not exist.

AssertionError - if actual is not a directory.

AssertionError - if actual does not contain recursively any files matching the given path matcher.

Since:

3.16.0

See Also:

FileSystem.getPathMatcher(String)

isDirectoryRecursivelyContaining

public SELF isDirectoryRecursivelyContaining(Predicate<Path> filter)

Verify that the actual Path directory or any of its subdirectories (recursively) contains at least one file matching the given Predicate<Path>.

That methods performs the same assertion as isDirectoryContaining(Predicate filter) but recursively.

Note that the actual Path must exist and be a directory.

Examples given the following directory structure:

 root
 |—— foo
 |    |—— foobar
 |         |—— foo-file-1.ext
 |—— foo-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryRecursivelyContaining(file -> file.getName().startsWith("foo-file-1"))
                 .isDirectoryRecursivelyContaining(file -> file.getName().endsWith("file-2.ext"))
                 .isDirectoryRecursivelyContaining(file -> file.getName().equals("foo"))
                 .isDirectoryRecursivelyContaining(file -> file.getParentFile().getName().equals("foo"))

 // The following assertions fail:
 assertThat(root).isDirectoryRecursivelyContaining(file -> file.getName().equals("foo-file-1"))
 assertThat(root).isDirectoryRecursivelyContaining(file -> file.getName().equals("foo/foobar"));

Parameters:: filter - the filter for files located inside actual's directory.
Returns:: this assertion object.
Throws:: NullPointerException - if the given filter is null.; AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual does not contain recursively any files matching the given predicate.
Since:: 3.16.0

isDirectoryNotContaining

public SELF isDirectoryNotContaining(Predicate<Path> filter)

Verify that the actual Path is a directory that does not contain any files matching the given Predicate<Path>.

Note that the actual Path must exist and be a directory.

Given the following directory structure:

 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-file-1.ext
 /root/sub-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryNotContaining(file -> file.getFileName().toString().startsWith("dir"))
                 .isDirectoryNotContaining(file -> file.getFileName().toString().endsWith(".bin"));

 // The following assertions fail:
 assertThat(root).isDirectoryNotContaining(path -> path.getFileName().toString().startsWith("sub-dir"));
 assertThat(root).isDirectoryNotContaining(path -> path.getFileName().toString().startsWith("sub-file"));
 assertThat(root).isDirectoryNotContaining(path -> path.getFileName().toString().endsWith(".ext"));
 assertThat(root).isDirectoryNotContaining(Files::isDirectory);

Parameters:: filter - the filter for files located inside actual's directory.
Returns:: this assertion object.
Throws:: NullPointerException - if the given filter is null.; AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual contains a file matching the given predicate.
Since:: 3.13.0

isDirectoryNotContaining

public SELF isDirectoryNotContaining(String syntaxAndPattern)

Verify that the actual Path is a directory that does not contain any files matching the given String interpreted as a path matcher (as per FileSystem.getPathMatcher(String)).

Note that the actual Path must exist and be a directory.

Given the following directory structure:

 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-file-1.ext
 /root/sub-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isDirectoryNotContaining("glob:**dir")
                 .isDirectoryNotContaining("glob:**.bin")
                 .isDirectoryNotContaining("regex:.*bin")
                 .isDirectoryNotContaining("glob:**.{java,class}");

 // The following assertions fail:
 assertThat(root).isDirectoryNotContaining("glob:**sub-dir*");
 assertThat(root).isDirectoryNotContaining("glob:**sub-file*");
 assertThat(root).isDirectoryNotContaining("glob:**.ext");
 assertThat(root).isDirectoryNotContaining("regex:.*ext");
 assertThat(root).isDirectoryNotContaining("glob:**.{ext,bin");

Parameters:: syntaxAndPattern - the syntax and pattern for PathMatcher as described in FileSystem.getPathMatcher(String).
Returns:: this assertion object.
Throws:: NullPointerException - if the given syntaxAndPattern is null.; AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual contains a file matching the given path matcher.
Since:: 3.13.0
See Also:: FileSystem.getPathMatcher(String)

isEmptyDirectory

public SELF isEmptyDirectory()

Verify that the actual Path is an empty directory.

Note that the actual Path must exist and be a directory.

Given the following directory structure:

 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-dir-2/
 /root/sub-file-1.ext
 /root/sub-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertion succeeds:
 assertThat(root.resolve("sub-dir-2")).isEmptyDirectory();

 // The following assertions fail:
 assertThat(root).isEmptyDirectory();
 assertThat(root.resolve("sub-dir-1")).isEmptyDirectory();

Returns:: this assertion object.
Throws:: AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual is not empty.
Since:: 3.13.0

isNotEmptyDirectory

public SELF isNotEmptyDirectory()

Verify that the actual Path is a non empty directory.

Note that the actual Path must exist and be a directory.

Given the following directory structure:

 /root/
 /root/sub-dir-1/
 /root/sub-dir-1/file-1.ext
 /root/sub-dir-1/file-2.ext
 /root/sub-dir-2/
 /root/sub-file-1.ext
 /root/sub-file-2.ext

Here are some assertions examples:

 Path root = Paths.get("root");

 // The following assertions succeed:
 assertThat(root).isNotEmptyDirectory();
 assertThat(root.resolve("sub-dir-1")).isNotEmptyDirectory();

 // The following assertion fails:
 assertThat(root.resolve("sub-dir-2")).isNotEmptyDirectory();

Returns:: this assertion object.
Throws:: AssertionError - if actual is null.; AssertionError - if actual does not exist.; AssertionError - if actual is not a directory.; AssertionError - if actual is empty.
Since:: 3.13.0

Modifier and Type	Field	Description
`(package private) Charset`	`charset`
`protected Paths`	`paths`

Class AbstractPathAssert<SELF extends AbstractPathAssert<SELF>>

Field Summary

Fields inherited from class org.assertj.core.api.AbstractComparableAssert

Fields inherited from class org.assertj.core.api.AbstractAssert

Constructor Summary

Method Summary

Methods inherited from class org.assertj.core.api.AbstractComparableAssert

Methods inherited from class org.assertj.core.api.AbstractObjectAssert

Methods inherited from class org.assertj.core.api.AbstractAssert

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.core.api.Descriptable

Field Detail

paths

charset

Constructor Detail

AbstractPathAssert

Method Detail

hasSameContentAs

hasSameTextualContentAs

hasSameTextualContentAs

hasSameContentAs

hasBinaryContent

hasSameBinaryContentAs

usingCharset

usingCharset

hasContent

isReadable

isWritable

isExecutable

exists

existsNoFollowLinks

doesNotExist

isRegularFile

isDirectory

isSymbolicLink

isAbsolute

isRelative

isNormalized

isCanonical

hasFileName

hasParent

hasParentRaw

hasNoParent

hasNoParentRaw

startsWith

startsWithRaw

endsWith

endsWithRaw

hasDigest

hasDigest

hasDigest

hasDigest

isDirectoryContaining

isDirectoryContaining

isDirectoryRecursivelyContaining

isDirectoryRecursivelyContaining

isDirectoryNotContaining

isDirectoryNotContaining

isEmptyDirectory

isNotEmptyDirectory