org.assertj.core.api.AbstractListAssert.usingElementComparator()方法的使用及代码示例

x33g5p2x  于2022-01-15 转载在 其他  
字(11.8k)|赞(0)|评价(0)|浏览(74)

本文整理了Java中org.assertj.core.api.AbstractListAssert.usingElementComparator()方法的一些代码示例，展示了AbstractListAssert.usingElementComparator()的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。AbstractListAssert.usingElementComparator()方法的具体详情如下：
包路径：org.assertj.core.api.AbstractListAssert
类名称：AbstractListAssert
方法名：usingElementComparator

AbstractListAssert.usingElementComparator介绍

暂无

代码示例

代码示例来源：origin: Appendium/objectlabkit

public static <T> void compareResults(final Class<T> classType, final List<T> actual, final DataTable expected) {
  final List<String> fieldsToCompare = expected.topCells();
  final T[] expectedEntities = convertDataTableToExpected(classType, expected, fieldsToCompare);
  final List<T> actualEntities = actual.stream().map(sea -> copyFieldValues(fieldsToCompare, sea, classType)).collect(Collectors.toList());
  try {
    assertThat(actualEntities).usingElementComparator(comparator(buildExclusionFields(classType, fieldsToCompare)))
        .containsOnly(expectedEntities);
  } catch (final java.lang.AssertionError e) {
    final String actualDataAsStr = convertToString(actual, fieldsToCompare);
    throw new ComparisonFailure("Table comparison for " + classType.getSimpleName() + " does not match\n", expected.toString(),
        actualDataAsStr);
  }
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void patternComprehension() throws Exception {
  submitAndGet("CREATE (a:Person { name: 'Charlie Sheen' })\n" +
    "CREATE (m1:Movie { name: 'Wall Street', year: 1987 })\n" +
    "CREATE (m2:Movie { name: 'Alpaca Now', year: 1979 })\n" +
    "CREATE (m3:Movie { name: 'Red Down', year: 1984 })\n" +
    "CREATE (m4:Show { name: 'Two and a Half Men', year: 2003 })\n" +
    "CREATE (a)-[:ACTED_IN]->(m1)\n" +
    "CREATE (a)-[:ACTED_IN]->(m2)\n" +
    "CREATE (a)-[:ACTED_IN]->(m3)\n" +
    "CREATE (a)-[:ACTED_IN]->(m4)");
  String cypher = "MATCH (a:Person { name: 'Charlie Sheen' })\n" +
    "RETURN [(a)-->(b) WHERE b:Movie | b.year] AS years";
  List<Map<String, Object>> results = submitAndGet(cypher);
  assertThat(results)
    .hasSize(1)
    .extracting("years")
    .usingElementComparator(ignoreOrderInCollections())
    .containsExactly(asList(1987L, 1979L, 1984L));
}

代码示例来源：origin: v-ladynev/fluent-hibernate

@Test
public void onlyArrayArgument() {
  SimplyPersistent expected = persistents.get(0);
  List<SimplyPersistent> list = getRequest().in("name", new Object[] { expected.getName() })
      .list();
  assertThat(list).isNotNull().hasSize(1).usingElementComparator(COMPARE_BY_PID)
  .containsOnly(expected);
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void aggregationsOnDifferentNodes() throws Exception {
  String[] columnNames = {"n.lastName", "type(r)", "collect(m.name)"};
  String cypher = "MATCH (n:Person)-[r]->(m:Interest) RETURN n.lastName, type(r), collect(m.name)";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .hasSize(2)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", "LIKES", asList("Video", "Video", "Music")),
      tuple("Haugland", "LIKES", asList("Video"))
    );
}

代码示例来源：origin: gentics/mesh

if (field instanceof NodeFieldList) {
  assertThat(((NodeFieldList) field).getItems()).usingElementComparator((a, b) -> {
    return a.getUuid().compareTo(b.getUuid());
  }).containsExactlyElementsOf(expected.getFields().getNodeFieldList(key).getItems());

代码示例来源：origin: v-ladynev/fluent-hibernate

@Test
public void inWithEmptyArray() {
  SimplyPersistent[] expectedResult = twoFirstPersistent();
  Object[] names = getNames(expectedResult).toArray(new Object[0]);
  List<SimplyPersistent> list = getRequest().in("name", names).list();
  assertThat(list).isNotNull().hasSize(2).usingElementComparator(COMPARE_BY_PID)
      .containsOnly(expectedResult);
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
@SuppressWarnings("unchecked")
public void onePivotOneAggregation() throws Exception {
  String[] columnNames = {"n.lastName", "c1"};
  String cypher = "MATCH (n:Person) RETURN\n" +
    "n.lastName," +
    "collect(n.firstName) AS c1;";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .extracting(Map::keySet)
    .allSatisfy(columns -> assertThat(columns).containsExactly(columnNames));
  assertThat(cypherResults)
    .hasSize(4)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", asList("Erik", "Erik", "Erik", "Lars")),
      tuple("Lehtinen", asList("Olavi")),
      tuple("Haugland", asList("Martin")),
      tuple("Pedersen", asList("Erlend"))
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
@SuppressWarnings("unchecked")
public void onePivotThreeAggregations() throws Exception {
  String[] columnNames = {"n.lastName", "c1", "c2", "c3"};
  String cypher = "MATCH (n:Person) RETURN\n" +
    "n.lastName," +
    "count(n) AS c1," +
    "collect(n.born) AS c2," +
    "max(n.born) AS c3;";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .extracting(Map::keySet)
    .allSatisfy(columns -> assertThat(columns).containsExactly(columnNames));
  assertThat(cypherResults)
    .hasSize(4)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", 4L, asList(1995L, 1988L, 1988L, 1986L), 1995L),
      tuple("Lehtinen", 1L, asList(1983L), 1983L),
      tuple("Haugland", 1L, asList(1984L), 1984L),
      tuple("Pedersen", 1L, asList(1996L), 1996L)
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
@SuppressWarnings("unchecked")
public void twoPivotsTwoAggregations() throws Exception {
  String[] columnNames = {"p1", "p2", "c1", "c2"};
  String cypher = "MATCH (n:Person) RETURN\n" +
    "n.lastName as p1," +
    "n.firstName as p2," +
    "count(n) AS c1," +
    "collect(n.email) AS c2;";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .extracting(Map::keySet)
    .allSatisfy(columns -> assertThat(columns).containsExactly(columnNames));
  assertThat(cypherResults)
    .hasSize(5)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", "Erik", 3L, asList("ErikJunior@gmx.com", "TheErik@gmail.com", "ErikTheSecond4@gmail.com")),
      tuple("Andresen", "Lars", 1L, asList("Lars.Nielsen.6711515243877401003@yahoo.com")),
      tuple("Lehtinen", "Olavi", 1L, asList("Olavi4398046541996@gmx.com")),
      tuple("Haugland", "Martin", 1L, asList("Martin4398046518130@hotmail.com")),
      tuple("Pedersen", "Erlend", 1L, asList("Erlend2199023287971@gmail.com"))
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void aggregationsOnly() throws Exception {
  String[] columnNames = {"count(n1)", "count(n2)"};
  String cypher = "MATCH (n1)-[r]->(n2) RETURN count(n1), count(n2)";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .hasSize(1)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple(22L, 22L)
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
@SuppressWarnings("unchecked")
public void threePivotsThreeAggregations() throws Exception {
  String[] columnNames = {"p1", "p2", "p3", "c1", "c2", "c3"};
  String cypher = "MATCH (n:Person) RETURN\n" +
    "n.lastName as p1," +
    "n.firstName as p2," +
    "n.born as p3," +
    "count(n) AS c1," +
    "collect(n.email) AS c2," +
    "max(n.born) AS c3;";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .extracting(Map::keySet)
    .allSatisfy(columns -> assertThat(columns).containsExactly(columnNames));
  assertThat(cypherResults)
    .hasSize(6)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", "Erik", 1988L, 2L, asList("TheErik@gmail.com", "ErikTheSecond4@gmail.com"), 1988L),
      tuple("Andresen", "Erik", 1995L, 1L, asList("ErikJunior@gmx.com"), 1995L),
      tuple("Andresen", "Lars", 1986L, 1L, asList("Lars.Nielsen.6711515243877401003@yahoo.com"), 1986L),
      tuple("Lehtinen", "Olavi", 1983L, 1L, asList("Olavi4398046541996@gmx.com"), 1983L),
      tuple("Haugland", "Martin", 1984L, 1L, asList("Martin4398046518130@hotmail.com"), 1984L),
      tuple("Pedersen", "Erlend", 1996L, 1L, asList("Erlend2199023287971@gmail.com"), 1996L)
    );
}

代码示例来源：origin: v-ladynev/fluent-hibernate

@Test
public void inWithCollection() {
  SimplyPersistent[] expectedResult = twoFirstPersistent();
  List<SimplyPersistent> list = getRequest().in("name", getNames(expectedResult)).list();
  assertThat(list).isNotNull().hasSize(2).usingElementComparator(COMPARE_BY_PID)
      .containsOnly(expectedResult);
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void labelPredicate() throws Exception {
  String[] columnNames = {"isPerson", "count"};
  String cypher = "MATCH (n)\n" +
    "RETURN (n:Person) AS isPerson, count(*) AS count";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .hasSize(2)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple(true, 7L),
      tuple(false, 11L)
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void distinct() throws Exception {
  String[] columnNames = {"n.lastName", "type(r)"};
  String cypher = "MATCH ()-[r]->(n:Person) RETURN DISTINCT n.lastName, type(r)";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .hasSize(3)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("Andresen", "KNOWS"),
      tuple("Pedersen", "KNOWS"),
      tuple("Lehtinen", "KNOWS")
    );
}

代码示例来源：origin: opencypher/cypher-for-gremlin

@Test
public void multiple() throws Exception {
  String[] columnNames = {"type(r)", "count"};
  String cypher = "MATCH ()-[r]->() RETURN count(r) AS count, type(r)";
  List<Map<String, Object>> cypherResults = submitAndGet(cypher);
  assertThat(cypherResults)
    .hasSize(4)
    .extracting(columnNames)
    .usingElementComparator(ignoreOrderInCollections())
    .containsAll(extract(cypherResults, byName(columnNames)))
    .containsExactlyInAnyOrder(
      tuple("IS_LOCATED_IN", 6L),
      tuple("LIKES", 4L),
      tuple("KNOWS", 6L),
      tuple("IS_PART_OF", 6L)
    );
}

代码示例来源：origin: v-ladynev/fluent-hibernate

@Test
public void nothingForEmptyCollectionNotEmpty() {
  SimplyPersistent[] expectedResult = twoFirstPersistent();
  List<SimplyPersistent> list = getRequest().add(
      in("name", getNames(expectedResult)).nothingForEmptyCollection()).list();
  assertThat(list).isNotNull().hasSize(2).usingElementComparator(COMPARE_BY_PID)
      .containsOnly(expectedResult);
}

内容来源于网络，如有侵权，请联系作者删除！

AbstractListAssert

相关文章

    查看更多
    微信公众号

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    AbstractListAssert类方法

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com