Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use toPathNames method of org.assertj.core.error.ShouldNotContain class

Best Assertj code snippet using org.assertj.core.error.ShouldNotContain.toPathNames

Source:Paths_assertIsDirectoryNotContaining_Predicate_Test.java

...16import static org.assertj.core.api.Assertions.catchThrowable;17import static org.assertj.core.error.ShouldBeDirectory.shouldBeDirectory;18import static org.assertj.core.error.ShouldExist.shouldExist;19import static org.assertj.core.error.ShouldNotContain.directoryShouldNotContain;20import static org.assertj.core.internal.Paths.toPathNames;21import static org.assertj.core.util.AssertionsUtil.expectAssertionError;22import static org.assertj.core.util.FailureMessages.actualIsNull;23import static org.assertj.core.util.Lists.emptyList;24import static org.assertj.core.util.Lists.list;25import static org.mockito.ArgumentMatchers.any;26import static org.mockito.ArgumentMatchers.eq;27import static org.mockito.BDDMockito.given;28import static org.mockito.Mockito.verify;29import java.io.IOException;30import java.io.UncheckedIOException;31import java.nio.file.Path;32import java.util.List;33import java.util.Optional;34import java.util.function.Predicate;35import org.assertj.core.api.AssertionInfo;36import org.assertj.core.internal.Paths;37import org.junit.jupiter.api.Test;38/**39 * Tests for <code>{@link Paths#assertIsDirectoryNotContaining(AssertionInfo, Path, Predicate)}</code>40 *41 * @author Valeriy Vyrva42 */43class Paths_assertIsDirectoryNotContaining_Predicate_Test extends MockPathsBaseTest {44  /**45   * We will check count call to {@link Path#getFileName()}46   */47  private static final Predicate<Path> JAVA_SOURCE = path -> Optional.ofNullable(path.getFileName())48                                                                     .map(Path::toString)49                                                                     .filter(fileName -> fileName.endsWith(".java"))50                                                                     .isPresent();51  @Test52  void should_pass_if_actual_does_not_contain_files_matching_the_given_filter() {53    // GIVEN54    Path file = mockRegularFile("root", "Test.class");55    List<Path> items = list(file);56    Path actual = mockDirectory("root", items);57    // THEN58    paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE);59  }60  @Test61  void should_pass_if_actual_is_empty() {62    // GIVEN63    List<Path> items = emptyList();64    Path actual = mockDirectory("root", items);65    // THEN66    paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE);67  }68  @Test69  void should_throw_error_if_filter_is_null() {70    // GIVEN71    Predicate<Path> filter = null;72    // THEN73    assertThatNullPointerException().isThrownBy(() -> paths.assertIsDirectoryNotContaining(INFO, null, filter))74                                    .withMessage("The paths filter should not be null");75  }76  @Test77  void should_fail_if_actual_is_null() {78    // GIVEN79    Path actual = null;80    // WHEN81    AssertionError error = expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));82    // THEN83    assertThat(error).hasMessage(actualIsNull());84  }85  @Test86  void should_fail_if_actual_does_not_exist() {87    // GIVEN88    given(nioFilesWrapper.exists(actual)).willReturn(false);89    // WHEN90    expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));91    // THEN92    verify(failures).failure(INFO, shouldExist(actual));93  }94  @Test95  void should_fail_if_actual_exists_but_is_not_directory() {96    // GIVEN97    given(nioFilesWrapper.exists(actual)).willReturn(true);98    given(nioFilesWrapper.isDirectory(actual)).willReturn(false);99    // WHEN100    expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));101    // THEN102    verify(failures).failure(INFO, shouldBeDirectory(actual));103  }104  @Test105  void should_throw_runtime_error_wrapping_caught_IOException() throws IOException {106    // GIVEN107    IOException cause = new IOException();108    given(nioFilesWrapper.exists(actual)).willReturn(true);109    given(nioFilesWrapper.isDirectory(actual)).willReturn(true);110    given(nioFilesWrapper.newDirectoryStream(eq(actual), any())).willThrow(cause);111    // WHEN112    Throwable error = catchThrowable(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));113    // THEN114    assertThat(error).isInstanceOf(UncheckedIOException.class)115                     .hasCause(cause);116  }117  @Test118  void should_fail_if_one_actual_file_matches_the_filter() {119    // GIVEN120    Path file = mockRegularFile("Test.java");121    List<Path> items = list(file);122    Path actual = mockDirectory("root", items);123    // WHEN124    expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));125    // THEN126    verify(failures).failure(INFO, directoryShouldNotContain(actual, toPathNames(items), "the given filter"));127  }128  @Test129  void should_fail_if_all_actual_files_match_the_filter() {130    // GIVEN131    Path file1 = mockRegularFile("Test.java");132    Path file2 = mockRegularFile("Utils.java");133    List<Path> items = list(file1, file2);134    Path actual = mockDirectory("root", items);135    // WHEN136    expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));137    // THEN138    verify(failures).failure(INFO, directoryShouldNotContain(actual, toPathNames(items), "the given filter"));139  }140  @Test141  void should_fail_if_some_actual_files_match_the_filter() {142    // GIVEN143    Path file1 = mockRegularFile("Test.class");144    Path file2 = mockRegularFile("Test.java");145    Path file3 = mockRegularFile("Utils.class");146    Path file4 = mockRegularFile("Utils.java");147    Path file5 = mockRegularFile("application.yml");148    List<Path> items = list(file1, file2, file3, file4, file5);149    Path actual = mockDirectory("root", items);150    // WHEN151    expectAssertionError(() -> paths.assertIsDirectoryNotContaining(INFO, actual, JAVA_SOURCE));152    // THEN153    verify(failures).failure(INFO, directoryShouldNotContain(actual, toPathNames(list(file2, file4)), "the given filter"));154  }155}...

Source:ShouldNotContain.java

...58                .map(File::getName)59                .collect(toList());60  }61  public static ErrorMessageFactory directoryShouldNotContain(Path actual, List<Path> matchingContent, String filterDescription) {62    return new ShouldNotContain(actual, toPathNames(matchingContent), filterDescription);63  }64  private static List<String> toPathNames(List<Path> files) {65    return files.stream()66                .map(Path::toString)67                .collect(toList());68  }69  private ShouldNotContain(Object actual, List<String> matchingContent, String filterDescription) {70    // not passing matchingContent and filterDescription as parameter to avoid AssertJ default String formatting71    super("%nExpecting directory:%n" +72          "  %s%n" +73          "not to contain any files matching " + filterDescription + " but found some:%n" +74          "  " + matchingContent,75          actual);76  }77}...

toPathNames

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.error.ShouldNotContain.shouldNotContain;3import org.assertj.core.error.ErrorMessageFactory;4import org.assertj.core.internal.TestDescription;5import org.assertj.core.presentation.StandardRepresentation;6public class ShouldNotContainTest {7    public static void main(String[] args) {8        ErrorMessageFactory errorMessageFactory = shouldNotContain("test", "test", new TestDescription("Test"), new StandardRepresentation());9        System.out.println(errorMessageFactory.create(new TestDescription("Test"), new StandardRepresentation()));10    }11}12import static org.assertj.core.api.Assertions.assertThat;13import static org.assertj.core.error.ShouldNotContain.shouldNotContain;14import org.assertj.core.error.ErrorMessageFactory;15import org.assertj.core.internal.TestDescription;16import org.assertj.core.presentation.StandardRepresentation;17public class ShouldNotContainTest {18    public static void main(String[] args) {19        ErrorMessageFactory errorMessageFactory = shouldNotContain("test", "test", new TestDescription("Test"), new StandardRepresentation());20        System.out.println(errorMessageFactory.create(new TestDescription("Test"), new StandardRepresentation()).toString());21    }22}23import static org.assertj.core.api.Assertions.assertThat;24import static org.assertj.core.error.ShouldNotContain.shouldNotContain;25import org.assertj.core.error.ErrorMessageFactory;26import org.assertj.core.internal.TestDescription;27import org.assertj.core.presentation.StandardRepresentation;28public class ShouldNotContainTest {29    public static void main(String[] args) {30        ErrorMessageFactory errorMessageFactory = shouldNotContain("test", "test", new TestDescription("Test"), new StandardRepresentation());31        System.out.println(errorMessageFactory.create(new TestDescription("Test"), new StandardRepresentation()).toString());32    }33}

toPathNames

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.catchThrowable;3import org.assertj.core.error.ShouldNotContain;4import org.assertj.core.internal.TestDescription;5import org.junit.Test;6public class ShouldNotContainTest {7    public void testToPathNames() {8        Throwable error = catchThrowable(() -> assertThat(new String[] { "foo", "bar" }).contains("foo"));9        String message = ShouldNotContain.shouldNotContain("foo", new String[] { "foo", "bar" }, null).create(new TestDescription("TEST"), null);10        assertThat(message).isEqualTo(String.format("[TEST] %n" +11                " <[\"foo\"]>"));12    }13}14at org.junit.Assert.assertEquals(Assert.java:115)15at org.junit.Assert.assertEquals(Assert.java:144)16at org.assertj.core.error.ShouldNotContainTest.testToPathNames(ShouldNotContainTest.java:22)

toPathNames

Using AI Code Generation

1package org.assertj.core.error;2import static org.assertj.core.util.Arrays.array;3import java.nio.file.Path;4import org.assertj.core.description.Description;5import org.assertj.core.presentation.StandardRepresentation;6import org.assertj.core.util.VisibleForTesting;7public class ShouldNotContain extends BasicErrorMessageFactory {8  public static final String SHOULD_NOT_CONTAIN = "%nExpecting:%n <%s>%nnot to contain:%n <%s> %s";9  public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence) {10    return new ShouldNotContain(actual, sequence, array());11  }12  public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence, Throwable cause) {13    return new ShouldNotContain(actual, sequence, array(cause));14  }15  public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence, Path path) {16    return new ShouldNotContain(actual, sequence, array(path));17  }18  public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence, Path path, Throwable cause) {19    return new ShouldNotContain(actual, sequence, array(path, cause));20  }21  private ShouldNotContain(CharSequence actual, CharSequence sequence, Object[] arguments) {22    super(SHOULD_NOT_CONTAIN, actual, sequence, arguments);23  }24  public String create(Description description, Representation representation) {25    Object[] args = arguments;26    if (args.length > 0 && args[args.length - 1] instanceof Throwable) {27      args = array(args).withLength(args.length - 1);28    }29    return String.format(description == null ? message : description.value() + message, args);30  }31  public String toString() {32    return String.format(message, arguments);33  }34  public static class ShouldNotContainCharSequence extends BasicErrorMessageFactory {35    public static final String SHOULD_NOT_CONTAIN = "%nExpecting:%n <%s>%nnot to contain:%n <%s> %s";36    public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence) {37      return new ShouldNotContainCharSequence(actual, sequence, array());38    }39    public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence, Throwable cause) {40      return new ShouldNotContainCharSequence(actual, sequence, array(cause));41    }42    private ShouldNotContainCharSequence(CharSequence actual, CharSequence sequence, Object[] arguments) {43      super(SHO

toPathNames

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import java.util.Arrays;3import java.util.List;4import org.assertj.core.error.ShouldNotContain;5import org.assertj.core.presentation.StandardRepresentation;6public class ShouldNotContainTest {7  public static void main(String[] args) {8    List<String> actual = Arrays.asList("Luke", "Yoda", "Leia");9    List<String> values = Arrays.asList("Leia", "Yoda");10    String message = ShouldNotContain.shouldNotContain(actual, values, new StandardRepresentation()).create();11    System.out.println(message);12  }13}14import static org.assertj.core.api.Assertions.assertThat;15import java.util.Arrays;16import java.util.List;17import org.assertj.core.error.ShouldContain;18import org.assertj.core.presentation.StandardRepresentation;19public class ShouldContainTest {20  public static void main(String[] args) {21    List<String> actual = Arrays.asList("Luke", "Yoda", "Leia");22    List<String> values = Arrays.asList("Leia", "Yoda");23    String message = ShouldContain.shouldContain(actual, values, new StandardRepresentation()).create();24    System.out.println(message);25  }26}27import static org.assertj.core.api.Assertions.assertThat;28import java.util.Arrays;29import java.util.List;30import org.assertj.core.error.ShouldBeSorted;31import org.assertj.core.presentation.StandardRepresentation;32public class ShouldBeSortedTest {33  public static void main(String[] args) {34    List<Integer> actual = Arrays.asList(4, 1, 3);35    String message = ShouldBeSorted.shouldBeSorted(1, actual, new StandardRepresentation()).create();36    System.out.println(message);37  }38}

toPathNames

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.error.ShouldNotContain;3import org.assertj.core.internal.TestDescription;4import org.assertj.core.presentation.StandardRepresentation;5public class Path {6    public static void main(String[] args) {7        final StandardRepresentation representation = new StandardRepresentation();8        ShouldNotContain shouldNotContain = new ShouldNotContain("foo", "bar", representation);9        String[] paths = shouldNotContain.toPathNames("foo", "bar");10        for (String path : paths) {11            System.out.println(path);12        }13    }14}15import org.assertj.core.api.Assertions;16import org.assertj.core.error.ShouldNotContain;17import org.assertj.core.internal.TestDescription;18import org.assertj.core.presentation.StandardRepresentation;19public class Path {20    public static void main(String[] args) {21        final StandardRepresentation representation = new StandardRepresentation();22        ShouldNotContain shouldNotContain = new ShouldNotContain("foo", "bar", representation);23        String[] paths = shouldNotContain.toPathNames("foo", "bar");24        Assertions.assertThat(paths).containsExactly("foo", "foo.bar");25    }26}27to contain exactly (and in same order):28import org.assertj.core.api.Assertions;29import org.assertj.core.internal.Objects;30import org.assertj.core.internal.TestDescription;31import org.assertj.core.presentation.StandardRepresentation;32public class Path {33    public static void main(String[] args) {34        Objects objects = new Objects(new TestDescription("Test"));35        objects.assertHasNoNullFieldsOrProperties(new Test(), "test");36    }37}

toPathNames

Using AI Code Generation

1package org.assertj.core.error;2import static java.lang.String.format;3import static org.assertj.core.util.Strings.join;4import java.nio.file.Path;5import java.util.List;6public class ShouldNotContain extends BasicErrorMessageFactory {7  private static final String SHOULD_NOT_CONTAIN = "%nExpecting:%n <%s>%nnot to contain:%n <%s>%n";8  public static ErrorMessageFactory shouldNotContain(Path actual, Path other) {9    return new ShouldNotContain(actual, other);10  }11  public static ErrorMessageFactory shouldNotContain(Path actual, List<Path> other) {12    return new ShouldNotContain(actual, other);13  }14  private ShouldNotContain(Path actual, Path other) {15    super(SHOULD_NOT_CONTAIN, actual, other);16  }17  private ShouldNotContain(Path actual, List<Path> other) {18    super(SHOULD_NOT_CONTAIN, actual, join(other));19  }20}21package org.assertj.core.error;22import static java.lang.String.format;23import static org.assertj.core.util.Strings.join;24import java.nio.file.Path;25import java.util.List;26public class ShouldContain extends BasicErrorMessageFactory {27  private static final String SHOULD_CONTAIN = "%nExpecting:%n <%s>%nto contain:%n <%s>%n";28  public static ErrorMessageFactory shouldContain(Path actual, Path other) {29    return new ShouldContain(actual, other);30  }31  public static ErrorMessageFactory shouldContain(Path actual, List<Path> other) {32    return new ShouldContain(actual, other);33  }34  private ShouldContain(Path actual, Path other) {35    super(SHOULD_CONTAIN, actual, other);36  }37  private ShouldContain(Path actual, List<Path> other) {38    super(SHOULD_CONTAIN, actual, join(other));39  }40}41package org.assertj.core.api;42import java.nio.file.Path;43import java.util.List;44public class PathAssert extends AbstractAssert<PathAssert, Path> {45  public PathAssert(Path actual) {46    super(actual, PathAssert.class);47  }48  public PathAssert contains(Path other) {49    isNotNull();50    assertPathParameterIsNotNull(other);

toPathNames

Using AI Code Generation

1Path[] paths = new Path[2];2paths[0] = Paths.get("C:\\Users\\user\\Desktop\\1.txt");3paths[1] = Paths.get("C:\\Users\\user\\Desktop\\2.txt");4ShouldNotContain shouldNotContain = new ShouldNotContain((Object) paths, paths, new StandardRepresentation());5String pathNames = shouldNotContain.toPathNames(paths);6System.out.println(pathNames);7Path[] paths = new Path[2];8paths[0] = Paths.get("C:\\Users\\user\\Desktop\\1.txt");9paths[1] = Paths.get("C:\\Users\\user\\Desktop\\2.txt");10ShouldNotContain shouldNotContain = new ShouldNotContain((Object) paths, paths, new StandardRepresentation());11String pathNames = shouldNotContain.toPathNames(paths);12System.out.println(pathNames);13Path[] paths = new Path[2];14paths[0] = Paths.get("C:\\Users\\user\\Desktop\\1.txt");15paths[1] = Paths.get("C:\\Users\\user\\Desktop\\2.txt");16ShouldNotContain shouldNotContain = new ShouldNotContain((Object) paths, paths, new StandardRepresentation());17String pathNames = shouldNotContain.toPathNames(paths);18System.out.println(pathNames);19Path[] paths = new Path[2];20paths[0] = Paths.get("C:\\Users\\user\\Desktop\\1.txt");21paths[1] = Paths.get("C:\\Users\\user\\Desktop\\2.txt");22ShouldNotContain shouldNotContain = new ShouldNotContain((Object) paths, paths, new StandardRepresentation());

toPathNames

Using AI Code Generation

1import org.assertj.core.error.ShouldNotContain;2import org.assertj.core.util.Paths;3import java.nio.file.Path;4public class 1 {5    public static void main(String[] args) {6        Path actual = Paths.newPath("C:\\Users\\User\\Desktop\\1.txt");7        Path expected = Paths.newPath("C:\\Users\\User\\Desktop\\2.txt");8        ShouldNotContain shouldNotContain = new ShouldNotContain(actual, expected, null);9        System.out.println(shouldNotContain.toPathNames());10    }11}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.