KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use internalExtracting method of org.assertj.core.api.AbstractIterableAssert class

Best Assertj code snippet using org.assertj.core.api.AbstractIterableAssert.internalExtracting

Source:AbstractIterableAssert.java

...1298   * @return a new assertion object whose object under test is the list of values extracted1299   */1300  @CheckReturnValue1301  public <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> extracting(Function<? super ELEMENT, V> extractor) {1302    return internalExtracting(extractor);1303  }1304  private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> internalExtracting(Function<? super ELEMENT, V> extractor) {1305    if (actual == null) throwAssertionError(shouldNotBeNull());1306    List<V> values = FieldsOrPropertiesExtractor.extract(actual, extractor);1307    return newListAssertInstanceForMethodsChangingElementType(values);1308  }1309  /**1310   * Maps the Iterable's elements under test by applying a mapping function, the resulting list becomes the instance under test.1311   * <p>1312   * This allows to test values from the elements more safely than by using {@link #extracting(String)}.1313   * <p>1314   * Let's have a look at an example:1315   * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)1316   * List&lt;TolkienCharacter&gt; fellowshipOfTheRing = new ArrayList&lt;TolkienCharacter&gt;();1317   *1318   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Frodo&quot;, 33, HOBBIT));1319   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Sam&quot;, 38, HOBBIT));1320   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gandalf&quot;, 2020, MAIA));1321   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Legolas&quot;, 1000, ELF));1322   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Pippin&quot;, 28, HOBBIT));1323   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gimli&quot;, 139, DWARF));1324   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Aragorn&quot;, 87, MAN);1325   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Boromir&quot;, 37, MAN));1326   *1327   * // fellowship has hobbitses, right, my precioussss?1328   * assertThat(fellowshipOfTheRing).map(TolkienCharacter::getRace)1329   *                                .contains(HOBBIT);</code></pre>1330   *1331   * Note that the order of mapped values is consistent with the order of the Iterable under test, for example if1332   * it's a {@link HashSet}, you won't be able to make any assumptions on the extracted values order.1333   *1334   * @param <V> the type of elements resulting of the map operation.1335   * @param mapper the {@link Function} transforming input object to desired one1336   * @return a new assertion object whose object under test is the list of values extracted1337   * @since 3.19.01338   */1339  public <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> map(Function<? super ELEMENT, V> mapper) {1340    return internalExtracting(mapper);1341  }1342  /**1343   * Extract the values from Iterable's elements under test by applying an extracting function (which might throw an1344   * exception) on them. The returned iterable becomes the instance under test.1345   * <p>1346   * Any checked exception raised in the extractor is rethrown wrapped in a {@link RuntimeException}.1347   * <p>1348   * It allows to test values from the elements more safely than by using {@link #extracting(String)}, as it1349   * doesn't utilize introspection.1350   * <p>1351   * Let's have a look at an example:1352   * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)1353   * // they can be public field or properties, both can be extracted.1354   * List&lt;TolkienCharacter&gt; fellowshipOfTheRing = new ArrayList&lt;TolkienCharacter&gt;();1355   *1356   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Frodo&quot;, 33, HOBBIT));1357   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Sam&quot;, 38, HOBBIT));1358   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gandalf&quot;, 2020, MAIA));1359   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Legolas&quot;, 1000, ELF));1360   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Pippin&quot;, 28, HOBBIT));1361   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gimli&quot;, 139, DWARF));1362   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Aragorn&quot;, 87, MAN);1363   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Boromir&quot;, 37, MAN));1364   *1365   * assertThat(fellowshipOfTheRing).extracting(input -&gt; {1366   *   if (input.getAge() &lt; 20) {1367   *     throw new Exception("age &lt; 20");1368   *   }1369   *   return input.getName();1370   * }).contains("Frodo");</code></pre>1371   *1372   * Note that the order of extracted property/field values is consistent with the iteration order of the Iterable under1373   * test, for example if it's a {@link HashSet}, you won't be able to make any assumptions on the extracted values1374   * order.1375   *1376   * @param <EXCEPTION> the exception type of {@link ThrowingExtractor}1377   * @param <V> the type of elements extracted.1378   * @param extractor the object transforming input object to desired one1379   * @return a new assertion object whose object under test is the list of values extracted1380   * @since 3.7.01381   */1382  @CheckReturnValue1383  public <V, EXCEPTION extends Exception> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> extracting(ThrowingExtractor<? super ELEMENT, V, EXCEPTION> extractor) {1384    return internalExtracting(extractor);1385  }1386  /**1387   * Maps the Iterable's elements by applying the given mapping function (which might throw an exception), the returned list1388   * becomes the instance under test.1389   * <p>1390   * Any checked exception raised in the function is rethrown wrapped in a {@link RuntimeException}.1391   * <p>1392   * This allows to test values from the elements more safely than by using {@link #extracting(String)}.1393   * <p>1394   * Let's have a look at an example:1395   * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)1396   * List&lt;TolkienCharacter&gt; fellowshipOfTheRing = new ArrayList&lt;TolkienCharacter&gt;();1397   *1398   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Frodo&quot;, 33, HOBBIT));1399   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Sam&quot;, 38, HOBBIT));1400   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gandalf&quot;, 2020, MAIA));1401   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Legolas&quot;, 1000, ELF));1402   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Pippin&quot;, 28, HOBBIT));1403   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Gimli&quot;, 139, DWARF));1404   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Aragorn&quot;, 87, MAN);1405   * fellowshipOfTheRing.add(new TolkienCharacter(&quot;Boromir&quot;, 37, MAN));1406   *1407   * assertThat(fellowshipOfTheRing).map(input -&gt; {1408   *   if (input.getAge() &lt; 20) {1409   *     throw new Exception("age &lt; 20");1410   *   }1411   *   return input.getName();1412   * }).contains("Frodo");</code></pre>1413   *1414   * Note that the order of mapped values is consistent with the order of the Iterable under test, for example if it's a1415   * {@link HashSet}, you won't be able to make any assumptions on the extracted values order.1416   *1417   * @param <EXCEPTION> the exception type of {@link ThrowingExtractor}1418   * @param <V> the type of elements extracted.1419   * @param mapper the function transforming input object to desired one1420   * @return a new assertion object whose object under test is the list of values extracted1421   * @since 3.19.01422   */1423  @CheckReturnValue1424  public <V, EXCEPTION extends Exception> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> map(ThrowingExtractor<? super ELEMENT, V, EXCEPTION> mapper) {1425    return internalExtracting(mapper);1426  }1427  /*1428   * Should be used after any methods changing the elements type like {@link #extracting(Function)} as it will propagate the1429   * correct assertions state, that is everything but the element comparator (since the element type has changed).1430   */1431  private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> newListAssertInstanceForMethodsChangingElementType(List<V> values) {1432    if (actual instanceof SortedSet) {1433      // Reset the natural element comparator set when building an iterable assert instance for a SortedSet as it is likely not1434      // compatible with extracted values type, example with a SortedSet<Person> using a comparator on the Person's age, after1435      // extracting names we get a List<String> which is mot suitable for the age comparator1436      usingDefaultElementComparator();1437    }1438    return newListAssertInstance(values).withAssertionState(myself);1439  }...

internalExtracting

Using AI Code Generation

1    public static <ELEMENT, ITERABLE extends Iterable<? extends ELEMENT>> AbstractIterableAssert<?, ITERABLE, ELEMENT, ObjectAssert<ELEMENT>> internalExtracting(2            AbstractIterableAssert<?, ITERABLE, ELEMENT, ObjectAssert<ELEMENT>> self, Function<? super ELEMENT, ?> extractor) {3        return self.extracting(extractor);4    }5    public void test() {6        List<Person> persons = new ArrayList<>();7        Person person = new Person();8        person.setName("John");9        person.setAge(20);10        persons.add(person);11        person = new Person();12        person.setName("Mary");13        person.setAge(30);14        persons.add(person);15        person = new Person();16        person.setName("Tom");17        person.setAge(40);18        persons.add(person);19        assertThat(persons).extracting("name").contains("John");20        assertThat(persons).extracting("age").contains(40);21        assertThat(persons).extracting("name", "age").contains(tuple("John", 20));22        assertThat(persons).extracting("name", "age").contains(tuple("Mary", 30));23        assertThat(persons).extracting("name", "age").contains(tuple("Tom", 40));24    }25    public class Person {26        private String name;27        private int age;28        public String getName() {29            return name;30        }31        public void setName(String name) {32            this.name = name;33        }34        public int getAge() {35            return age;36        }37        public void setAge(int age) {38            this.age = age;39        }40    }41}

internalExtracting

Using AI Code Generation

1assertThat(Arrays.asList("1", "2", "3"))2    .extracting(new AbstractCharSequenceAssert.StringExtractor<Integer>() {3        public Integer apply(String input) {4            return Integer.parseInt(input);5        }6    })7    .containsExactly(1, 2, 3);8assertThat(Arrays.asList("1", "2", "3"))9    .extracting(new AbstractCharSequenceAssert.StringExtractor<Integer>() {10        public Integer apply(String input) {11            return Integer.parseInt(input);12        }13    })14    .containsExactly(1, 2, 3);15assertThat(Arrays.asList("1", "2", "3"))16    .extracting(new AbstractCharSequenceAssert.StringExtractor<Integer>() {17        public Integer apply(String input) {18            return Integer.parseInt(input);19        }20    })21    .containsExactly(1, 2, 3);22assertThat(Arrays.asList("1", "2", "3"))23    .extracting(new AbstractCharSequenceAssert.StringExtractor<Integer>() {24        public Integer apply(String input) {25            return Integer.parseInt(input);26        }27    })28    .containsExactly(1, 2, 3);29assertThat(Arrays.asList("1", "2", "3"))30    .extracting(new AbstractCharSequenceAssert.StringExtractor<Integer>() {31        public Integer apply(String input) {32            return Integer.parseInt(input);33        }34    })35    .containsExactly(1, 2, 3);36assertThat(Arrays.asList("1", "2", "3"))37    .extracting(new AbstractChar

internalExtracting

Using AI Code Generation

1assertThat(employees).extracting(Employee::getName).contains("John", "Jane", "Joe");2assertThat(employees).extracting(Employee::getName, e -> e.getDepartment().getName())3                     .contains(tuple("John", "IT"), tuple("Jane", "HR"), tuple("Joe", "IT"));4assertThat(employees).extracting("name", "department.name")5                     .contains(tuple("John", "IT"), tuple("Jane", "HR"), tuple("Joe", "IT"));6assertThat(employees).extracting("name", "department.name")7                     .contains(tuple("John", "IT"), tuple("Jane", "HR"), tuple("Joe", "IT"));8assertThat(employees).extracting("name", "department.name")9                     .contains(tuple("John", "IT"), tuple("Jane", "HR"), tuple("Joe", "IT"));10assertThat(employees).extracting("name", "department.name")11                     .contains(tuple("John", "IT"), tuple("Jane", "HR"), tuple("Joe", "IT"));

internalExtracting

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.api.AbstractIterableAssert;3import java.util.Arrays;4import java.util.List;5class AssertionsExample {6    public static void main(String[] args) {7        List<List<Object>> list = Arrays.asList(8                Arrays.asList("a", "b", "c"),9                Arrays.asList(1, 2, 3)10        );11        AbstractIterableAssert<?, Iterable<Object>, Object, Object> iterableAssert = Assertions.assertThat(list)12                .flatExtracting(Iterable::iterator);13        iterableAssert.containsExactly("a", "b", "c", 1, 2, 3);14    }15}16at org.junit.Assert.assertEquals(Assert.java:115)17at org.junit.Assert.assertEquals(Assert.java:144)18at org.assertj.core.api.AbstractIterableAssert.isEqualTo(AbstractIterableAssert.java:116)19at org.assertj.core.api.AbstractIterableAssert.isEqualTo(AbstractIterableAssert.java:25)20at org.assertj.core.api.AssertionsExample.main(AssertionsExample.java:21)

internalExtracting

Using AI Code Generation

1extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));2extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));3assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));4assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));5assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));6assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));7assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));8assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));9assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));10assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));11assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));12assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));13assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"), list("Alex", "Jack", "Charlie"));14assertThat(employees).extracting("children.age").containsOnly(list(4, 6), list(2, 8, 10));15assertThat(employees).extracting("children.name").containsOnly(list("Sara", "Zoe"),

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.