doc / ch.tutteli.atrium.api.infix.en_GB / toBe

toBe

infix fun <T> Expect<T>.toBe(expected: T): Expect<T> (source)
Deprecated: Use toEqual; will be removed with 1.0.0 at the latest

Expects that the subject of this expectation is (equal to) expected.

expect(12) toEqual 12 // holds

fails {
    expect(12) toEqual 11
}

// holds, toBe is based on equality, use isSameAs for identity
expect(listOf(1)) toEqual listOf(1)

fails { // because array has not implemented equals, so is equivalent to isSameAs
    expect(arrayOf(1)) toEqual arrayOf(1)
}

Return
an Expect for the subject of this expectation.

infix fun <T : CharSequence> Expect<T>.toBe(empty: empty): Expect<T> (source)

Expects that the subject of this expectation (a CharSequence) CharSequence.kotlin.text.isEmpty.

//Unresolved: ch.tutteli.atrium.api.infix.en_GB.samples.CharSequenceExpectationSamples.toBeEmpty

Parameters

empty - Use the pseudo-keyword empty.

Return
an Expect for the subject of this expectation.

@JvmName("toBeNull") infix fun <T : BigDecimal> Expect<T?>.toBe(expected: Nothing?): Expect<T?> (source)
Deprecated: Use toEqual; will be removed with 1.0.0 at the latest

Expects that the subject of this expectation (a BigDecimal) is null.

// only use toBe to check against null, otherwise use isNumericallyEqualTo or isEqualIncludingScale
expect(null as BigDecimal?).toBe(null)

Return
an Expect for the subject of this expectation.

infix fun <E, T : Optional<E>> Expect<T>.toBe(present: present): FeatureExpect<T, E> (source)

Expects that the subject of this expectation (an Optional) is present and returns an Expect for the inner type E.

Shortcut for more or less something like feature(Optional<T>::get) but with error handling; yet it depends on the underlying implementation though.

Return
The newly created Expect for the inner type E.

Since
0.12.0

infix fun <E, T : Optional<E>> Expect<T>.toBe(present: PresentWithCreator<E>): Expect<T> (source)

Expects that the subject of this expectation (an Optional) is present and that it holds all assertions the given PresentWithCreator.assertionCreator creates.

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(existing: existing): Expect<T> (source)

Expects that the subject of this expectation (a Path) exists; meaning that there is a file system entry at the location the Path points to.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, then the search will continue at that location.

val dir = tempDir.newDirectory("test_dir")

expect(dir) toBe existing

fails {
    expect(Paths.get("non_existing_dir")) toBe existing
}

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(readable: readable): Expect<T> (source)

Expects that the subject of this expectation (a Path) is readable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to read from it.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, search will continue at the location the link points at.

This assertion is not atomic with respect to concurrent file system operations on the paths the assertion works on. Its result, in particular its extended explanations, may be wrong if such concurrent file system operations take place.

val dir = tempDir.newDirectory("test_dir")

expect(dir) toBe readable

fails {
    expect(Paths.get("non_existing_dir")) toBe readable
}

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(writable: writable): Expect<T> (source)

Expects that the subject of this expectation (a Path) is writable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to write to it.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, search will continue at the location the link points at.

val dir = tempDir.newDirectory("test_dir")

expect(dir) toBe writable

fails {
    expect(Paths.get("non_existing_dir")) toBe writable
}

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(executable: executable): Expect<T> (source)

Expects that the subject of this expectation (a Path) is executable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to execute it.

The semantics of “permission to execute it” may differ when checking access to a directory. For example, on UNIX systems, it means that the Java virtual machine has permission to search the directory in order to access file or subdirectories.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, search will continue at the location the link points at.

val dir = tempDir.newDirectory("test_dir")

expect(dir) toBe executable

fails {
    expect(Paths.get("non_existing_dir")) toBe executable
}

Return
an Expect for the subject of this expectation.

Since
0.14.0

infix fun <T : Path> Expect<T>.toBe(aRegularFile: aRegularFile): Expect<T> (source)

Expects that the subject of this expectation (a Path) is a file; meaning that there is a file system entry at the location the Path points to and that is a regular file.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, search will continue at the location the link points at.

This assertion is not atomic with respect to concurrent file system operations on the paths the assertion works on. Its result, in particular its extended explanations, may be wrong if such concurrent file system operations take place.

val file = tempDir.newFile("test_file")
val dir = tempDir.newDirectory("test_dir")

expect(file) toBe aRegularFile

fails {
    expect(dir) toBe aRegularFile
}

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(aDirectory: aDirectory): Expect<T> (source)

Expects that the subject of this expectation (a Path) is a directory; meaning that there is a file system entry at the location the Path points to and that is a directory.

This assertion resolves symbolic links. Therefore, if a symbolic link exists at the location the subject points to, search will continue at the location the link points at.

This assertion is not atomic with respect to concurrent file system operations on the paths the assertion9 works on. Its result, in particular its extended explanations, may be wrong if such concurrent file system operations take place.

val file = tempDir.newFile("test_file")
val dir = tempDir.newDirectory("test_dir")

expect(dir) toBe aDirectory

fails {
    expect(file) toBe aDirectory
}

Return
an Expect for the subject of this expectation.

Since
0.12.0

infix fun <T : Path> Expect<T>.toBe(aSymbolicLink: aSymbolicLink): Expect<T> (source)

Expects that the subject of this expectation (a Path) is a symbolic link; meaning that there is a file system entry at the location the Path points to and that is a symbolic link.

This assertion is not atomic with respect to concurrent file system operations on the paths the assertion works on. Its result, in particular its extended explanations, may be wrong if such concurrent file system operations take place.

val target = tempDir.newFile("target")
val link = Files.createSymbolicLink(tempDir.resolve("link"), target)

// Passes, because subject `link` is a symbolic link
expect(link) toBe aSymbolicLink

val file = tempDir.newFile("somePath")

fails { // because subject `path` is a not a symbolic link
    expect(file) toBe aSymbolicLink
}

Return
an Expect for the subject of this expectation.

Since
0.16.0

infix fun <T : Path> Expect<T>.toBe(absolute: absolute): Expect<T> (source)

Expects that the subject of this expectation (a Path) is an absolute path; meaning that the Path specified in this instance starts at the file system root.

val s = FileSystems.getDefault().separator
val prefix = if (s == "\\") "C:" else "" // if (s == "\\") => true current os is windows
expect(Paths.get("$prefix${s}absolute${s}path")) toBe absolute

fails {
    expect(Paths.get("relative/path")) toBe absolute
}

Return
an Expect for the subject of this expectation.

Since
0.14.0

infix fun <T : Path> Expect<T>.toBe(relative: relative): Expect<T> (source)

Expects that the subject of this expectation (a Path) is a relative path; meaning that the Path specified in this instance does not start at the file system root.

expect(Paths.get("relative/path")) toBe relative

fails {
    val s = FileSystems.getDefault().separator
    val prefix = if (s == "\\") "C:" else "" // if (s == "\\") => true current os is windows
    expect(Paths.get("$prefix${s}absolute${s}path")) toBe relative
}

Return
an Expect for the subject of this expectation.

Since
0.14.0

infix fun <T : Path> Expect<T>.toBe(anEmptyDirectory: anEmptyDirectory): Expect<T> (source)

Expects that the subject of this expectation (a Path) is an empty directory; meaning that there is a file system entry at the location the Path points to and that is an empty directory.

val dir = tempDir.newDirectory("test_dir")
expect(dir) toBe anEmptyDirectory

dir.newFile("test_file.txt")
fails {
    expect(dir) toBe anEmptyDirectory
}

Return
an Expect for the subject of this expectation.

Since
0.16.0