org.springframework.data.domain.Example.of()

private Flux<Post> testFoundMethod() {
    return this.posts.findAll(Example.of(Post.builder().replacedle("Post one").build()));
}

private boolean modExists(String displayName, short version) {
    ModVersion probe = new ModVersion().setVersion(version).setMod(new Mod().setDisplayName(displayName));
    return modVersionRepository.exists(Example.of(probe, ExampleMatcher.matching()));
}

@Test
public void startingWithByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("Baabba", "", 67));
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(new Customer(null, "bb", 100), ExampleMatcher.matching().withMatcher("surname", match -> match.startsWith()).withIgnoreCase("surname").withIgnoreNullValues());
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void findAllByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check1 = new Customer("B", "X", 0);
    final Customer check2 = new Customer("B", "Y", 0);
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(check1);
    toBeRetrieved.add(check2);
    toBeRetrieved.add(new Customer("C", "V", 0));
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(new Customer("B", null, 0));
    final Iterable<?> retrieved = repository.findAll(example);
    final List<Customer> retrievedList = new LinkedList<>();
    retrieved.forEach(e -> retrievedList.add((Customer) e));
    final List<Customer> checkList = new LinkedList<>();
    checkList.add(check1);
    checkList.add(check2);
    replacedertTrue(equals(checkList, retrievedList, cmp, eq, false));
}

@Test
public void findOneByExampleTest() {
    repository.save(john);
    final Customer customer = repository.findOne(Example.of(john)).get();
    replacedertEquals("customers do not match", john, customer);
}

@Test
public void existsByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer checker = new Customer("I", "Exist", 25, true);
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(new Customer("B", "X", 0));
    toBeRetrieved.add(new Customer("B", "Y", 0));
    toBeRetrieved.add(new Customer("C", "V", 0));
    toBeRetrieved.add(checker);
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(checker);
    final boolean exists = repository.exists(example);
    replacedertTrue(exists);
}

@Test
public void countByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(new Customer("B", "X", 0));
    toBeRetrieved.add(new Customer("B", "Y", 0));
    toBeRetrieved.add(new Customer("C", "V", 0));
    toBeRetrieved.add(new Customer("D", "T", 0));
    toBeRetrieved.add(new Customer("D", "U", 0));
    toBeRetrieved.add(new Customer("E", "S", 0));
    toBeRetrieved.add(new Customer("F", "P", 0));
    toBeRetrieved.add(new Customer("F", "Q", 0));
    toBeRetrieved.add(new Customer("F", "R", 0));
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(new Customer("", "", 0), ExampleMatcher.matchingAny().withIgnoreNullValues().withIgnorePaths(new String[] { "location", "alive" }));
    final long size = repository.count(example);
    replacedertTrue(size == toBeRetrieved.size());
}

@Test
public void findAllByExampleRegexTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check1 = new Customer("B", "X", 0);
    final Customer check2 = new Customer("B", "Y", 0);
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(check1);
    toBeRetrieved.add(check2);
    toBeRetrieved.add(new Customer("C", "V", 0));
    repository.saveAll(toBeRetrieved);
    Customer find = new Customer("([B])", null, 0);
    ExampleMatcher exampleMatcher = ExampleMatcher.matching().withIgnoreNullValues().withMatcher("name", match -> match.regex());
    final Example<Customer> example = Example.of(find, exampleMatcher);
    final Iterable<?> retrieved = repository.findAll(example);
    final List<Customer> retrievedList = new LinkedList<>();
    retrieved.forEach(e -> retrievedList.add((Customer) e));
    final List<Customer> checkList = new LinkedList<>();
    checkList.add(check1);
    checkList.add(check2);
    replacedertTrue(equals(checkList, retrievedList, cmp, eq, false));
}

private <T> Example<T> getExample(final Object source, final Clreplaced<T> clazz) {
    T instance = BeanUtils.instantiateClreplaced(clazz);
    BeanUtils.copyProperties(source, instance);
    return Example.of(instance);
}

@Override
public boolean existAccount(String account) throws Exception {
    account = replacedertNotBlank("账号不能为空", account);
    UserEnreplacedy exp = new UserEnreplacedy();
    exp.setAccount(account);
    return udao.exists(Example.of(exp));
}

public List<AccountEnreplacedy> accountEnreplacedyList(HttpServletRequest request, AccountEnreplacedy accountEnreplacedy, String accountId) {
    // execute select
    Example<AccountEnreplacedy> enreplacedyExample = Example.of(accountEnreplacedy);
    List<AccountEnreplacedy> list = accountRepository.findAll(enreplacedyExample);
    // filter current user
    list = list.stream().filter(it -> !it.getId().toString().equals(accountId)).collect(Collectors.toList());
    list.forEach(it -> it.setPreplacedword(null));
    return list;
}

/**
 * Returns a "paged" collection of resources matching the input query params using default
 * matching rules for strings of "contains and ignores case".
 * <p>
 * TODO I'm not exactly happy with the resource name "queryByExample".  Need to research more what
 * other APIs look like for this kind of functionality
 *
 * @param paramMap a Map of fields to use to search with
 * @param pageable a Pageable to restrict results
 * @return A paged result of matching Patients
 */
@GetMapping("/search/by-example")
public Page<Patient> getPatientsByExample(@RequestParam Map<String, Object> paramMap, Pageable pageable) {
    // naively copies map entries to matching properties in the Patient POJO
    Patient examplePatient = this.jacksonObjectMapper.convertValue(paramMap, Patient.clreplaced);
    Page<Patient> pagedResults = this.patientRepository.findAll(Example.of(examplePatient, DEFAULT_MATCHER), pageable);
    if (!pagedResults.hasContent()) {
        throw new NotFoundException(Patient.RESOURCE_PATH, "No Patients found matching example query " + examplePatient);
    }
    return pagedResults;
}

@Test
public void findAllByExamplePageNull() {
    this.expectedEx.expect(IllegalArgumentException.clreplaced);
    this.expectedEx.expectMessage("A non-null pageable is required.");
    this.simpleDatastoreRepository.findAll(Example.of(new Object()), (Pageable) null);
}

public long countProjectAccess(String projectId) {
    replacedertion.isValidProjectId(projectId);
    ScheduleAccess probe = new ScheduleAccess();
    probe.key = new ProjectAccessCompositeKey(null, projectId);
    Example<ScheduleAccess> example = Example.of(probe);
    return repository.count(example);
}

public long countProjectProductResults(String projectId) {
    replacedertion.isValidProjectId(projectId);
    ScanReport probe = new ScanReport();
    probe.projectId = projectId;
    Example<ScanReport> example = Example.of(probe);
    return repository.count(example);
}

@RolesAllowed(RoleConstants.ROLE_SUPERADMIN)
public List<ProductResult> fetchAllResultsInProject(String projectiD) {
    ProductResult probe = new ProductResult();
    probe.projectId = projectiD;
    return repository.findAll(Example.of(probe));
}

public long countProjectScanResults(String projectId) {
    replacedertion.isValidProjectId(projectId);
    ProductResult probe = new ProductResult();
    probe.projectId = projectId;
    Example<ProductResult> example = Example.of(probe);
    return repository.count(example);
}

public long countProjectAccess(String projectId) {
    replacedertion.isValidProjectId(projectId);
    ScanAccess probe = new ScanAccess();
    probe.key = new ProjectAccessCompositeKey(null, projectId);
    Example<ScanAccess> example = Example.of(probe);
    return repository.count(example);
}

@Test
public void when_not_last_admin_user_rights_can_be_revoked() {
    /* prepare */
    User capture = new User();
    capture.superAdmin = true;
    // query counts super admins now with 2, so can revoke
    when(userRepository.count(eq(Example.of(capture)))).thenReturn(2L);
    /* execute */
    serviceToTest.revokeSuperAdminRightsFrom(ADMIN_USER);
/* test */
// just no exception
}

@Test
public void when_last_admin_user_rights_cannot_be_revoked() {
    /* prepare */
    User exampleUser = new User();
    exampleUser.superAdmin = true;
    // query counts super admins now with 1
    when(userRepository.count(eq(Example.of(exampleUser)))).thenReturn(1L);
    /* test */
    expected.expect(NotAcceptableException.clreplaced);
    /* execute */
    serviceToTest.revokeSuperAdminRightsFrom(ADMIN_USER);
}

/**
 * 根据菜单对象的Example判断是否存在
 * @param menu 菜单对象
 */
@Override
public Menu getByMenuToExample(Menu menu) {
    return menuRepository.findOne(Example.of(menu)).orElse(null);
}

@Test
public void findAllByExampleWhitArrayStringTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("AbbaXP", "BbaaaaXZ", 1001);
    final Customer customer2 = new Customer("Bwa?[a.b]baAaGH", "", 67);
    customer1.setStringList(Arrays.asList("testA", "testB", "testC"));
    customer2.setStringList(Arrays.asList("test1", "test2", "test3"));
    toBeRetrieved.add(customer1);
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer("AbbaXP", "BbaaaaXZ", 1001);
    exampleCustomer.setStringList(Arrays.asList("testB"));
    final Example<Customer> example = Example.of(exampleCustomer);
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(customer1, retrieved);
}

@Test
public void plusSignExampleTest() {
    String NAME = "Abc+Def";
    final Customer enreplacedy = new Customer(NAME, "surname", 10);
    repository.save(enreplacedy);
    final Customer probe = new Customer();
    probe.setName(NAME);
    probe.setAge(10);
    final Example<Customer> example = Example.of(probe);
    final Optional<Customer> retrieved = repository.findOne(example);
    replacedertThat(retrieved.isPresent(), is(true));
    replacedertThat(retrieved.get().getName(), is(NAME));
}

@Test
public void exampleWithLikeAndEscapingTest() {
    String NAME = "Abc+Def";
    final Customer enreplacedy = new Customer(NAME, "surname", 10);
    repository.save(enreplacedy);
    final Customer probe = new Customer();
    probe.setName("Abc+De%");
    probe.setAge(10);
    final Example<Customer> example = Example.of(probe);
    final Optional<Customer> retrieved = repository.findOne(example);
    replacedertThat(retrieved.isPresent(), is(false));
}

@Test
public void endingWithByExampleNestedIncludeNullTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested = new Customer("$B*\\wa?[a.b]baaa", "", 67);
    final Customer nested2 = new Customer("qwerty", "", 10);
    nested2.setAddress(new Address("123456"));
    nested.setNestedCustomer(nested2);
    check.setNestedCustomer(nested);
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested3 = new Customer("B*\\wa?[a.b]baAa", "", 66);
    nested3.setNestedCustomer(nested2);
    exampleCustomer.setNestedCustomer(nested3);
    final Example<Customer> example = Example.of(exampleCustomer, ExampleMatcher.matching().withMatcher("nestedCustomer.name", match -> match.endsWith()).withIgnorePaths(new String[] { "arangoId", "id", "key", "rev" }).withIgnoreCase("nestedCustomer.name").withIncludeNullValues().withTransformer("nestedCustomer.age", o -> Optional.of(Integer.valueOf(o.get().toString()) + 1)));
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void findAllSortByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(new Customer("B", "C", 0));
    toBeRetrieved.add(new Customer("B", "D", 0));
    repository.saveAll(toBeRetrieved);
    repository.save(new Customer("A", "A", 1));
    final Example<Customer> example = Example.of(new Customer("", "", 0), ExampleMatcher.matchingAny().withIgnoreNullValues().withIgnorePaths(new String[] { "location", "alive" }));
    final List<Sort.Order> orders = new LinkedList<>();
    orders.add(new Sort.Order(Sort.Direction.ASC, "name"));
    orders.add(new Sort.Order(Sort.Direction.ASC, "surname"));
    final Sort sort = Sort.by(orders);
    final Iterable<Customer> retrieved = repository.findAll(example, sort);
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, true));
}

@Test
public void endingWithByExampleNestedTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested = new Customer("$B*\\wa?[a.b]baaa", "", 67);
    final Customer nested2 = new Customer("qwerty", "", 10);
    nested2.setAddress(new Address("123456"));
    nested.setNestedCustomer(nested2);
    check.setNestedCustomer(nested);
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested3 = new Customer("B*\\wa?[a.b]baAa", null, 66);
    nested3.setNestedCustomer(nested2);
    exampleCustomer.setNestedCustomer(nested3);
    final Example<Customer> example = Example.of(exampleCustomer, ExampleMatcher.matching().withMatcher("nestedCustomer.name", match -> match.endsWith()).withIgnoreCase("nestedCustomer.name").withIgnoreNullValues().withTransformer("nestedCustomer.age", o -> Optional.of(Integer.valueOf(o.get().toString()) + 1)));
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void exampleWithRefPropertyTest() {
    ShoppingCart shoppingCart = new ShoppingCart();
    shoppingCartRepository.save(shoppingCart);
    Customer customer = new Customer("Dhiren", "Upadhyay", 28);
    customer.setShoppingCart(shoppingCart);
    repository.save(customer);
    Customer customer1 = new Customer();
    customer1.setShoppingCart(shoppingCart);
    ExampleMatcher exampleMatcher = ExampleMatcher.matching().withIgnorePaths("age", "location", "alive");
    Example<Customer> example = Example.of(customer1, exampleMatcher);
    final Customer retrieved = repository.findOne(example).orElse(null);
    replacedertEquals(customer, retrieved);
}

public boolean existsBook1(Book book) {
    Example<Book> bookExample = Example.of(book);
    return bookRepository.exists(bookExample);
}

public List<RuleDatabaseEnreplacedy> getRuleDataBaseList(HttpServletRequest request, RuleDatabaseEnreplacedy ruleDatabaseEnreplacedy) throws GovernanceException {
    try {
        ruleDatabaseEnreplacedy.setSystemTag(false);
        Example<RuleDatabaseEnreplacedy> enreplacedyExample = Example.of(ruleDatabaseEnreplacedy);
        List<RuleDatabaseEnreplacedy> ruleDatabaseEnreplacedyList = ruleDatabaseRepository.findAll(enreplacedyExample);
        ruleDatabaseEnreplacedyList.forEach(ruleDataBase -> {
            String dataBaseUrl = ruleDataBase.getDatabaseUrl();
            if (StringUtil.isBlank(ruleDataBase.getOptionalParameter())) {
                ruleDataBase.setDatabaseUrl(dataBaseUrl);
            } else {
                ruleDataBase.setDatabaseUrl(dataBaseUrl + "?" + ruleDataBase.getOptionalParameter());
            }
        });
        return ruleDatabaseEnreplacedyList;
    } catch (Exception e) {
        log.error("get ruleDatabaseList fail", e);
        throw new GovernanceException("get ruleDatabaseList fail", e);
    }
}

@Test
public void findOneByExample() {
    Example<Object> example = Example.of(new Object());
    doAnswer((invocationOnMock) -> new DatastoreResultsIterable(Arrays.asList(1), null)).when(this.datastoreTemplate).queryByExample(same(example), eq(new DatastoreQueryOptions.Builder().setLimit(1).build()));
    replacedertThat(this.simpleDatastoreRepository.findOne(example).get()).isEqualTo(1);
    verify(this.datastoreTemplate, times(1)).queryByExample(same(example), eq(new DatastoreQueryOptions.Builder().setLimit(1).build()));
}

@Test
public void findAllByExample() {
    Example<Object> example = Example.of(new Object());
    this.simpleDatastoreRepository.findAll(example);
    verify(this.datastoreTemplate, times(1)).queryByExample(same(example), isNull());
}

@Test
public void countByExampleZero() {
    Example<Object> example1 = Example.of(new Object());
    doAnswer((invocationOnMock) -> new ArrayList<>()).when(this.datastoreTemplate).keyQueryByExample(same(example1), isNull());
    replacedertThat(this.simpleDatastoreRepository.count(example1)).isEqualTo(0);
    verify(this.datastoreTemplate, times(1)).keyQueryByExample(same(example1), isNull());
}

private List<DbEncryptedSecret> findAllSecretsForDevice(String deviceIdentification) {
    final DbEncryptedSecret searchByIdExample = new DbEncryptedSecret();
    searchByIdExample.setDeviceIdentification(deviceIdentification);
    return this.encryptedSecretRepository.findAll(Example.of(searchByIdExample));
}

@Override
public List<Waveform> getByExampleAllDistinctMatching(Waveform waveform) {
    return Optional.ofNullable(waveformRepository.findAll(Example.of(waveform, ignoreStandardFieldsMatcher))).orElseGet(ArrayList::new).stream().distinct().collect(Collectors.toList());
}

private List<Music> fingAllByNameAndSinger(String name, String singer) {
    Music music = new Music();
    music.setName(name);
    music.setSinger(singer);
    ExampleMatcher matcher = ExampleMatcher.matching().withIgnorePaths("type", "id");
    Example<Music> example = Example.of(music, matcher);
    return musicRepository.findAll(example);
}

@Override
public boolean existByName(String name) {
    replacedert.hasText(name, "Link name must not be blank");
    Link link = new Link();
    link.setName(name);
    return linkRepository.exists(Example.of(link));
}

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    Example<SysUser> example = Example.of(new SysUser().setUsername(username));
    SysUser sysUser = sysUserRepository.findOne(example).get();
    // List<GrantedAuthority> authorityList = new ArrayList<>();
    // authorityList.add(new SimpleGrantedAuthority(sysUser.getRole()));
    // return new User(sysUser.getUsername(), sysUser.getPreplacedword(),authorityList);
    return sysUser;
}

@Test
public void countByExampleZero() {
    Example<Object> example1 = Example.of(new Object());
    doAnswer(invocationOnMock -> new ArrayList<>()).when(this.datastoreTemplate).keyQueryByExample(same(example1), isNull());
    replacedertThat(this.simpleDatastoreRepository.count(example1)).isZero();
    verify(this.datastoreTemplate).keyQueryByExample(same(example1), isNull());
}

@Test
public void findAllByExample() {
    Example<Object> example = Example.of(new Object());
    this.simpleDatastoreRepository.findAll(example);
    verify(this.datastoreTemplate).queryByExample(same(example), isNull());
}

@Test
public void findOneByExample() {
    Example<Object> example = Example.of(new Object());
    doAnswer(invocationOnMock -> new DatastoreResultsIterable(Arrays.asList(1), null)).when(this.datastoreTemplate).queryByExample(same(example), eq(new DatastoreQueryOptions.Builder().setLimit(1).build()));
    replacedertThat(this.simpleDatastoreRepository.findOne(example)).contains(1);
    verify(this.datastoreTemplate).queryByExample(same(example), eq(new DatastoreQueryOptions.Builder().setLimit(1).build()));
}

@GetMapping
public ResponseEnreplacedy<List<T>> list(T enreplacedy) {
    Example<T> example = Example.of(enreplacedy, ExampleMatcher.matching());
    return new ResponseEnreplacedy<>(this.getService().find(example), HttpStatus.OK);
}

@Override
public Collection<VehiclePosition> getHistoryFor(String vehicleName) throws VehicleNotFoundException {
    VehiclePosition position = new VehicleBuilder().withName(vehicleName).build();
    Example<VehiclePosition> example = Example.of(position);
    // just a hack to sort correctly
    return new TreeSet<VehiclePosition>(mongoDb.findAll(example));
}

@RolesAllowed(RoleConstants.ROLE_SUPERADMIN)
public List<ProductResult> fetchAllResultsForJob(UUID sechubJobUUID) {
    ProductResult probe = new ProductResult();
    probe.secHubJobUUID = sechubJobUUID;
    return repository.findAll(Example.of(probe));
}

/* FIXME Albert Tregnaghi, 2020-04-23: we must fix the security-context problem, see https://github.com/Daimler/sechub/issues/216 */
// @RolesAllowed(RoleConstants.ROLE_SUPERADMIN)
public void deleteAllResultsForJob(UUID sechubJobUUID) {
    ProductResult probe = new ProductResult();
    probe.secHubJobUUID = sechubJobUUID;
    List<ProductResult> existingResults = repository.findAll(Example.of(probe));
    boolean purged = false;
    for (ProductResult result : existingResults) {
        repository.delete(result);
        purged = true;
    }
    if (purged) {
        /* we only send purged event - when something existed before and was really removed */
        sendJobResultsPurged(sechubJobUUID);
    }
}

@RolesAllowed(RoleConstants.ROLE_SUPERADMIN)
public List<ProjectScanLog> fetchLogsForJob(UUID sechubJobUUID) {
    ProjectScanLog log = new ProjectScanLog();
    log.sechubJobUUID = sechubJobUUID;
    return repository.findAll(Example.of(log));
}

/* @formatter:off */
@UseCaseAdministratorListsAllAdmins(@Step(number = 2, name = "Service call", description = "All userids of sechub administrators are returned as json"))
public List<String> listAdministrators() {
    /* @formatter:on */
    User userExample = new User();
    userExample.superAdmin = true;
    return userRepository.findAll(Example.of(userExample)).stream().map(User::getName).collect(Collectors.toList());
}

@Test
public void findAllByExampleWithArrayORTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested = new Customer("Bwa?[a.b]baAa", "", 67);
    final Customer nested2 = new Customer("qwertyASD", "", 10);
    check.setNestedCustomers(Arrays.asList(nested, nested2));
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("Baabba", "", 67));
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer();
    final Customer exampleNested = new Customer("qwertyASD", "", 10);
    final Customer exampleOr = new Customer("qwertyOr", "", 10);
    exampleCustomer.setNestedCustomers(Arrays.asList(exampleNested, exampleOr));
    final Example<Customer> example = Example.of(exampleCustomer, ExampleMatcher.matching().withIgnoreNullValues().withIgnorePaths(new String[] { "location", "alive", "age" }));
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void findAllByExampleWithArrayTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested = new Customer("Bwa?[a.b]baAa", "", 67);
    final Customer nested2 = new Customer("qwerty", "", 10);
    check.setNestedCustomers(Arrays.asList(nested, nested2));
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("Baabba", "", 67));
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer("Abba", "Bbaaaa", 100);
    final Customer exampleNested = new Customer("Bwa?[a.b]baAa", "", 67);
    exampleCustomer.setNestedCustomers(Arrays.asList(exampleNested));
    final Example<Customer> example = Example.of(exampleCustomer);
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void findAllByExampleWithArray2Test() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    final Customer nested = new Customer("Bwa?[a.b]baAa", "", 67);
    final Customer nested2 = new Customer("qwertyASD", "", 10);
    check.setNestedCustomers(Arrays.asList(nested, nested2));
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("Baabba", "", 67));
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer();
    final Customer exampleNested = new Customer("qwertyASD", "", 10);
    exampleCustomer.setNestedCustomers(Arrays.asList(exampleNested));
    final Example<Customer> example = Example.of(exampleCustomer, ExampleMatcher.matching().withIgnoreNullValues().withIgnorePaths(new String[] { "location", "alive", "age" }));
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

See More Examples