SELF - self typepublic abstract class AbstractPathAssert<SELF extends AbstractPathAssert<SELF>> extends AbstractComparableAssert<SELF,Path>
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:
null arguments; if a null
argument is passed, these assertions will throw a NullPointerException.closed. If a filesystems is closed, assertions will throw a
ClosedFileSystemException.Path as an argument. If this path is not issued from the same
provider as the tested path, assertions will throw a ProviderMismatchException.PathsException.| Modifier and Type | Field and Description |
|---|---|
protected Paths |
paths |
actual, info, myself, throwUnsupportedExceptionOnEquals| Constructor and Description |
|---|
AbstractPathAssert(Path actual,
Class<?> selfType) |
| Modifier and Type | Method and 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(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 |
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 |
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 |
hasSameContentAs(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 |
hasSameContentAs(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()
|
SELF |
isDirectory()
Assert that the tested
Path is a 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 |
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(Charset charset)
Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file).
|
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).
|
inBinary, inHexadecimal, isBetween, isEqualByComparingTo, isGreaterThan, isGreaterThanOrEqualTo, isLessThan, isLessThanOrEqualTo, isNotEqualByComparingTo, isStrictlyBetween, usingComparator, usingComparator, usingDefaultComparatoras, as, extracting, extracting, extracting, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparisonasList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, 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, setCustomRepresentation, throwAssertionError, withFailMessage, withRepresentation, withThreadDumpOnErrorprotected Paths paths
public SELF hasSameContentAs(Path expected)
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);expected - the given Path to compare the actual Path to.this assertion object.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.public SELF hasSameContentAs(Path expected, Charset expectedCharset)
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);expected - the given Path to compare the actual Path to.expectedCharset - the Charset used to read the content of the expected Path.this assertion object.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.public SELF hasBinaryContent(byte[] expected)
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());expected - the expected binary content to compare the actual File's content to.this assertion object.NullPointerException - if the given content is null.AssertionError - if the actual File is null.AssertionError - if the actual File is not an existing file.UncheckedIOException - if an I/O error occurs.AssertionError - if the content of the actual File is not equal to the given binary content.public SELF usingCharset(String charsetName)
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");charsetName - the name of the charset to use.this assertion object.IllegalArgumentException - if the given encoding is not supported on this platform.public SELF usingCharset(Charset 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");charset - the charset to use.this assertion object.NullPointerException - if the given charset is null.public SELF hasContent(String expected)
Path (which must be a readable file) is exactly equal
to the given one.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");expected - the expected text content to compare the actual File's content to.this assertion object.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 File is not equal to the given content.public SELF isReadable()
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();Files.isReadable(Path)public SELF isWritable()
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();Files.isWritable(Path)public SELF isExecutable()
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();Files.isExecutable(Path)public SELF exists()
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.
// 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();Files.exists(Path, LinkOption...)public SELF existsNoFollowLinks()
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.
// 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();Files.exists(Path, LinkOption...)public SELF doesNotExist()
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();Files.notExists(Path, LinkOption...),
LinkOption.NOFOLLOW_LINKSpublic SELF isRegularFile()
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.
// 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();public SELF isDirectory()
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.
// 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();public SELF isSymbolicLink()
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.
// 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();public SELF isAbsolute()
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.
// 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();Path.isAbsolute()public SELF isRelative()
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();Path.isAbsolute()public SELF isNormalized()
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.
// 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();public SELF isCanonical()
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.
// 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();PathsException - an I/O error occurred while evaluating the pathPath.toRealPath(LinkOption...),
Files.isSameFile(Path, Path)public SELF hasFileName(String fileName)
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");fileName - the expected filenameNullPointerException - if the given fileName is null.Path.getFileName()public SELF hasParent(Path expected)
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"));expected - the expected parent pathNullPointerException - if the given parent path is null.PathsException - failed to canonicalize the tested path or the path given as an argumentPath.getParent()public SELF hasParentRaw(Path expected)
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.
// 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"));expected - the expected parent pathNullPointerException - if the given parent path is null.Path.getParent()public SELF hasNoParent()
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();PathsException - failed to canonicalize the tested pathPath.getParent()public SELF hasNoParentRaw()
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.
// 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();Path.getParent()public SELF startsWith(Path other)
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.
// 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"));other - the other pathNullPointerException - if the given path is null.PathsException - failed to canonicalize the tested path or the path given as an argumentPath.startsWith(Path),
Path.toRealPath(LinkOption...)public SELF startsWithRaw(Path other)
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).
// 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/.."));other - the other pathNullPointerException - if the given path is null.Path.startsWith(Path)public SELF endsWith(Path other)
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.
// 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"));other - the other pathNullPointerException - if the given path is null.PathsException - failed to canonicalize the tested path (see class
description)Path.endsWith(Path),
Path.toRealPath(LinkOption...)public SELF endsWithRaw(Path other)
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 (.).
// 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"));other - the other pathNullPointerException - if the given path is null.Path.endsWith(Path)public SELF hasDigest(MessageDigest digest, byte[] expected)
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()); digest - the MessageDigest used to calculate the digests.expected - the expected binary content to compare the actual Path's content to.this assertion object.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.public SELF hasDigest(MessageDigest digest, String expected)
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"); digest - the MessageDigest used to calculate the digests.expected - the expected binary content to compare the actual Path's content to.this assertion object.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.public SELF hasDigest(String algorithm, byte[] expected)
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()); algorithm - the algorithm used to calulate the digests to compare.expected - the expected binary content to compare the actual Path's content to.this assertion object.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.public SELF hasDigest(String algorithm, String expected)
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"); algorithm - the algorithm used to calculate the digests.expected - the expected digest to compare the actual Path's digest to.this assertion object.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.Copyright © 2014–2019 AssertJ. All rights reserved.