KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta 
How to use DeepDifference class of org.assertj.core.internal package
Best Assertj code snippet using org.assertj.core.internal.DeepDifference
Source:DeepDifference_Test.java 
...52 * @author John DeRegnaucourt53 * @author sapradhan854 * @author Pascal Schumacher55 */56public class DeepDifference_Test {57 @Test58 public void testSameObject() {59 Date date1 = new Date();60 Date date2 = date1;61 assertHaveNoDifferences(date1, date2);62 }63 @Test64 public void testEqualsWithNull() {65 Date date1 = new Date();66 assertHaveDifferences(null, date1);67 assertHaveDifferences(date1, null);68 }69 @Test70 public void testBigDecimals() {71 BigDecimal bigDecimal1 = new BigDecimal("42.5");72 BigDecimal bigDecimal2 = new BigDecimal("42.5");73 assertHaveNoDifferences(bigDecimal1, bigDecimal2);74 }75 @Test76 public void testWithDifferentFields() {77 assertHaveDifferences("one", 1);78 assertHaveDifferences(new Wrapper(new Wrapper("one")), new Wrapper("one"));79 }80 @Test81 public void testPOJOequals() {82 Class1 x = new Class1(true, tan(PI / 4), 1);83 Class1 y = new Class1(true, 1.0, 1);84 assertHaveNoDifferences(x, y);85 assertHaveDifferences(x, new Class1());86 Class2 a = new Class2((float) atan(1.0), "hello", (short) 2, new Class1(false, sin(0.75), 5));87 Class2 b = new Class2((float) PI / 4, "hello", (short) 2, new Class1(false, 2 * cos(0.75 / 2) * sin(0.75 / 2), 5));88 assertHaveNoDifferences(a, b);89 assertHaveDifferences(a, new Class2((float) atan(2.0), "hello", (short) 2, new Class1(false, sin(0.75), 5)));90 }91 @Test92 public void testPrimitiveArrays() {93 int array1[] = { 2, 4, 5, 6, 3, 1, 3, 3, 5, 22 };94 int array2[] = { 2, 4, 5, 6, 3, 1, 3, 3, 5, 22 };95 assertHaveNoDifferences(array1, array2);96 int array3[] = { 3, 4, 7 };97 assertHaveDifferences(array1, array3);98 float array4[] = { 3.4f, 5.5f };99 assertHaveDifferences(array1, array4);100 }101 @Test102 public void testOrderedCollection() {103 List<String> a = newArrayList("one", "two", "three", "four", "five");104 List<String> b = new LinkedList<>();105 b.addAll(a);106 assertHaveNoDifferences(a, b);107 List<Integer> c = newArrayList(1, 2, 3, 4, 5);108 assertHaveDifferences(a, c);109 List<Integer> d = newArrayList(4, 6);110 assertHaveDifferences(c, d);111 List<Class1> x1 = newArrayList(new Class1(true, log(pow(E, 2)), 6), new Class1(true, tan(PI / 4), 1));112 List<Class1> x2 = newArrayList(new Class1(true, 2, 6), new Class1(true, 1, 1));113 assertHaveNoDifferences(x1, x2);114 }115 @Test116 public void testUnorderedCollection() {117 Set<String> a = newLinkedHashSet("one", "two", "three", "four", "five");118 Set<String> b = newLinkedHashSet("three", "five", "one", "four", "two");119 assertHaveNoDifferences(a, b);120 assertHaveNoDifferences(a, b, noFieldComparators(), new TypeComparators());121 Set<Integer> c = newLinkedHashSet(1, 2, 3, 4, 5);122 assertHaveDifferences(a, c);123 assertHaveDifferences(a, c, noFieldComparators(), null);124 Set<Integer> d = newLinkedHashSet(4, 2, 6);125 assertHaveDifferences(c, d);126 assertHaveDifferences(c, d, noFieldComparators(), null);127 Set<Class1> x1 = newLinkedHashSet(new Class1(true, log(pow(E, 2)), 6), new Class1(true, tan(PI / 4), 1));128 Set<Class1> x2 = newLinkedHashSet(new Class1(true, 1, 1), new Class1(true, 2, 6));129 assertHaveNoDifferences(x1, x2);130 }131 @Test132 public void testUnorderedCollectionWithCustomComparatorsByType() {133 TypeComparators comparatorsWithBigDecimalComparator = new TypeComparators();134 comparatorsWithBigDecimalComparator.put(BigDecimal.class, BIG_DECIMAL_COMPARATOR);135 Set<BigDecimal> a = newLinkedHashSet(new BigDecimal("1.0"), new BigDecimal("3"), new BigDecimal("2"), new BigDecimal("4"));136 Set<BigDecimal> b = newLinkedHashSet(new BigDecimal("4"), new BigDecimal("1"), new BigDecimal("2.0"), new BigDecimal("3"));137 assertHaveNoDifferences(a, b, noFieldComparators(), comparatorsWithBigDecimalComparator);138 Set<BigDecimal> c = newLinkedHashSet(new BigDecimal("4"), new BigDecimal("1"), new BigDecimal("2.2"), new BigDecimal("3"));139 assertHaveDifferences(a, c, noFieldComparators(), comparatorsWithBigDecimalComparator);140 }141 @Test142 public void testUnorderedCollectionWithCustomComparatorsByFieldName() {143 SetWrapper a = new SetWrapper(newLinkedHashSet(new Wrapper("one"), new Wrapper("two")));144 SetWrapper b = new SetWrapper(newLinkedHashSet(new Wrapper("1"), new Wrapper("2")));145 Map<String, Comparator<?>> fieldComparators = new HashMap<>();146 fieldComparators.put("set.o", ALWAY_EQUALS_STRING);147 assertHaveNoDifferences(a, b, fieldComparators, defaultTypeComparators());148 }149 @Test150 public void testEquivalentMaps() {151 Map<String, Integer> map1 = new LinkedHashMap<>();152 fillMap(map1);153 Map<String, Integer> map2 = new HashMap<>();154 fillMap(map2);155 assertHaveNoDifferences(map1, map2);156 assertThat(DeepDifference.deepHashCode(map1)).isEqualTo(DeepDifference.deepHashCode(map2));157 map1 = new TreeMap<>();158 fillMap(map1);159 map2 = new TreeMap<>();160 map2 = Collections.synchronizedSortedMap((SortedMap<String, Integer>) map2);161 fillMap(map2);162 assertHaveNoDifferences(map1, map2);163 assertThat(DeepDifference.deepHashCode(map1)).isEqualTo(DeepDifference.deepHashCode(map2));164 }165 @Test166 public void testInequivalentMaps() {167 Map<String, Integer> map1 = new TreeMap<>();168 fillMap(map1);169 Map<String, Integer> map2 = new HashMap<>();170 fillMap(map2);171 // Sorted versus non-sorted Map172 assertHaveDifferences(map1, map2);173 // Hashcodes are equals because the Maps have same elements174 assertThat(DeepDifference.deepHashCode(map1)).isEqualTo(DeepDifference.deepHashCode(map2));175 map2 = new TreeMap<>();176 fillMap(map2);177 map2.remove("kilo");178 assertHaveDifferences(map1, map2);179 // Hashcodes are different because contents of maps are different180 assertThat(DeepDifference.deepHashCode(map1)).isNotEqualTo(DeepDifference.deepHashCode(map2));181 // Inequality because ConcurrentSkipListMap is a SortedMap182 map1 = new HashMap<>();183 fillMap(map1);184 map2 = new ConcurrentSkipListMap<>();185 fillMap(map2);186 assertHaveDifferences(map1, map2);187 map1 = new TreeMap<>();188 fillMap(map1);189 map2 = new ConcurrentSkipListMap<>();190 fillMap(map2);191 assertHaveNoDifferences(map1, map2);192 map2.remove("papa");193 assertHaveDifferences(map1, map2);194 }195 @Test196 public void testEquivalentCollections() {197 // ordered Collection198 Collection<String> col1 = new ArrayList<>();199 fillCollection(col1);200 Collection<String> col2 = new LinkedList<>();201 fillCollection(col2);202 assertHaveNoDifferences(col1, col2);203 assertThat(DeepDifference.deepHashCode(col1)).isEqualTo(DeepDifference.deepHashCode(col2));204 // unordered Collections (Set)205 col1 = new LinkedHashSet<>();206 fillCollection(col1);207 col2 = new HashSet<>();208 fillCollection(col2);209 assertHaveNoDifferences(col1, col2);210 assertThat(DeepDifference.deepHashCode(col1)).isEqualTo(DeepDifference.deepHashCode(col2));211 col1 = new TreeSet<>();212 fillCollection(col1);213 col2 = new TreeSet<>();214 Collections.synchronizedSortedSet((SortedSet<String>) col2);215 fillCollection(col2);216 assertHaveNoDifferences(col1, col2);217 assertThat(DeepDifference.deepHashCode(col1)).isEqualTo(DeepDifference.deepHashCode(col2));218 }219 @Test220 public void testInequivalentCollections() {221 Collection<String> col1 = new TreeSet<>();222 fillCollection(col1);223 Collection<String> col2 = new HashSet<>();224 fillCollection(col2);225 assertHaveDifferences(col1, col2);226 assertThat(DeepDifference.deepHashCode(col1)).isEqualTo(DeepDifference.deepHashCode(col2));227 col2 = new TreeSet<>();228 fillCollection(col2);229 col2.remove("lima");230 assertHaveDifferences(col1, col2);231 assertThat(DeepDifference.deepHashCode(col1)).isNotEqualTo(DeepDifference.deepHashCode(col2));232 assertHaveDifferences(new HashMap<>(), new ArrayList<>());233 assertHaveDifferences(new ArrayList<>(), new HashMap<>());234 }235 @Test236 public void testArray() {237 Object[] a1 = new Object[] { "alpha", "bravo", "charlie", "delta" };238 Object[] a2 = new Object[] { "alpha", "bravo", "charlie", "delta" };239 assertHaveNoDifferences(a1, a2);240 assertThat(DeepDifference.deepHashCode(a1)).isEqualTo(DeepDifference.deepHashCode(a2));241 a2[3] = "echo";242 assertHaveDifferences(a1, a2);243 assertThat(DeepDifference.deepHashCode(a1)).isNotEqualTo(DeepDifference.deepHashCode(a2));244 }245 @Test246 public void testHasCustomMethod() {247 assertThat(DeepDifference.hasCustomEquals(EmptyClass.class)).isFalse();248 assertThat(DeepDifference.hasCustomHashCode(Class1.class)).isFalse();249 assertThat(DeepDifference.hasCustomEquals(EmptyClassWithEquals.class)).isTrue();250 assertThat(DeepDifference.hasCustomHashCode(EmptyClassWithEquals.class)).isTrue();251 }252 @Test253 public void shouldBeAbleToUseCustomComparatorForHashMap() {254 class ObjectWithMapField {255 Map<Integer, Boolean> map;256 }257 ObjectWithMapField a = new ObjectWithMapField(), b = new ObjectWithMapField();258 a.map = new HashMap<>();259 a.map.put(1, true);260 b.map = new HashMap<>();261 b.map.put(2, true);262 @SuppressWarnings("rawtypes")263 class AlwaysEqualMapComparator implements Comparator<Map> {264 @Override265 public int compare(Map o1, Map o2) {266 return 0;267 }268 }269 TypeComparators typeComparators = new TypeComparators();270 typeComparators.put(Map.class, new AlwaysEqualMapComparator());271 assertThat(DeepDifference.determineDifferences(a, b, noFieldComparators(), typeComparators)).isEmpty();272 }273 private void assertHaveNoDifferences(Object x, Object y) {274 assertHaveNoDifferences(x, y, noFieldComparators(), defaultTypeComparators());275 }276 private void assertHaveNoDifferences(Object x, Object y, Map<String, Comparator<?>> fieldComparators, TypeComparators typeComparators) {277 assertThat(DeepDifference.determineDifferences(x, y, fieldComparators, typeComparators)).isEmpty();278 }279 private void assertHaveDifferences(Object x, Object y) {280 assertHaveDifferences(x, y, noFieldComparators(), defaultTypeComparators());281 }282 private void assertHaveDifferences(Object x, Object y, Map<String, Comparator<?>> fieldComparators, TypeComparators typeComparators) {283 assertThat(DeepDifference.determineDifferences(x, y, fieldComparators, typeComparators)).isNotEmpty();284 }285 private static class EmptyClass {286 }287 private static class EmptyClassWithEquals {288 @Override289 public boolean equals(Object obj) {290 return obj instanceof EmptyClassWithEquals;291 }292 @Override293 public int hashCode() {294 return 0;295 }296 }297 private static class Class1 {...
Source:ShouldBeEqualByComparingFieldByFieldRecursively_create_Test.java
...22import java.util.List;23import java.util.TreeMap;24import java.util.TreeSet;25import org.assertj.core.description.TextDescription;26import org.assertj.core.internal.DeepDifference;27import org.assertj.core.internal.DeepDifference.Difference;28import org.assertj.core.internal.objects.Objects_assertIsEqualToComparingFieldByFieldRecursive_Test.WithCollection;29import org.assertj.core.internal.objects.Objects_assertIsEqualToComparingFieldByFieldRecursive_Test.WithMap;30import org.assertj.core.test.Jedi;31import org.junit.Test;32public class ShouldBeEqualByComparingFieldByFieldRecursively_create_Test {33 @Test34 public void should_throw_assertion_error_rather_than_null_pointer_when_one_nested_member_is_null() {35 // GIVEN36 Jedi yoda = new Jedi("Yoda", "Green");37 Jedi noname = new Jedi(null, "Green");38 // WHEN39 Throwable throwable1 = catchThrowable(() -> assertThat(yoda).isEqualToComparingFieldByFieldRecursively(noname));40 Throwable throwable2 = catchThrowable(() -> assertThat(noname).isEqualToComparingFieldByFieldRecursively(yoda));41 // THEN42 assertThat(throwable1).isInstanceOf(AssertionError.class)43 .isNotInstanceOf(NullPointerException.class);44 assertThat(throwable2).isInstanceOf(AssertionError.class)45 .isNotInstanceOf(NullPointerException.class);46 }47 @Test48 public void should_use_unambiguous_fields_description_when_standard_description_of_actual_and_expected_collection_fields_values_are_identical() {49 // GIVEN50 WithCollection<String> withHashSet = new WithCollection<>(new LinkedHashSet<String>());51 WithCollection<String> withSortedSet = new WithCollection<>(new TreeSet<String>());52 withHashSet.collection.add("bar");53 withHashSet.collection.add("foo");54 withSortedSet.collection.addAll(withHashSet.collection);55 List<Difference> differences = DeepDifference.determineDifferences(withHashSet, withSortedSet, null, null);56 // WHEN57 // @format:off58 String message = shouldBeEqualByComparingFieldByFieldRecursive(withSortedSet,59 withHashSet,60 differences,61 CONFIGURATION_PROVIDER.representation())62 .create(new TextDescription("Test"), CONFIGURATION_PROVIDER.representation());63 // @format:on64 // THEN65 assertThat(message).isEqualTo(format("[Test] %n" +66 "Expecting:%n" +67 " <WithCollection [collection=[bar, foo]]>%n" +68 "to be equal to:%n" +69 " <WithCollection [collection=[bar, foo]]>%n" +70 "when recursively comparing field by field, but found the following difference(s):%n"71 + "%n" +72 "Path to difference: <collection>%n" +73 "- expected: <[\"bar\", \"foo\"] (TreeSet@%s)>%n" +74 "- actual : <[\"bar\", \"foo\"] (LinkedHashSet@%s)>",75 toHexString(withSortedSet.collection.hashCode()),76 toHexString(withHashSet.collection.hashCode())));77 }78 @Test79 public void should_use_unambiguous_fields_description_when_standard_description_of_actual_and_expected_map_fields_values_are_identical() {80 // GIVEN81 WithMap<Long, Boolean> withLinkedHashMap = new WithMap<>(new LinkedHashMap<Long, Boolean>());82 WithMap<Long, Boolean> withTreeMap = new WithMap<>(new TreeMap<Long, Boolean>());83 withLinkedHashMap.map.put(1L, true);84 withLinkedHashMap.map.put(2L, false);85 withTreeMap.map.putAll(withLinkedHashMap.map);86 List<Difference> differences = DeepDifference.determineDifferences(withLinkedHashMap, withTreeMap, null, null);87 // WHEN88 // @format:off89 String message = shouldBeEqualByComparingFieldByFieldRecursive(withTreeMap,90 withLinkedHashMap,91 differences,92 CONFIGURATION_PROVIDER.representation())93 .create(new TextDescription("Test"), CONFIGURATION_PROVIDER.representation());94 // @format:on95 // THEN96 assertThat(message).isEqualTo(format("[Test] %n" +97 "Expecting:%n" +98 " <WithMap [map={1=true, 2=false}]>%n" +99 "to be equal to:%n" +100 " <WithMap [map={1=true, 2=false}]>%n" +...
DeepDifference
Using AI Code Generation
1import static org.assertj.core.api.Assertions.assertThat;2import java.util.Arrays;3import java.util.List;4import org.assertj.core.internal.DeepDifference;5import org.junit.Test;6public class DeepDifferenceTest {7 public void testDeepDifference() {8 List<String> list1 = Arrays.asList("a", "b", "c");9 List<String> list2 = Arrays.asList("a", "b", "d");10 DeepDifference deepDifference = new DeepDifference(list1, list2);11 assertThat(deepDifference.differencesFound()).isTrue();12 System.out.println(deepDifference.toString());13 }14}15at org.junit.Assert.assertEquals(Assert.java:115)16at org.junit.Assert.assertEquals(Assert.java:144)
DeepDifference
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.internal.DeepDifference;3import org.junit.Test;4public class TestDeepDifference {5 public void testDeepDifference() {6 String[] actual = { "a", "b", "c" };7 String[] expected = { "a", "b", "d" };8 DeepDifference deepDifference = new DeepDifference(actual, expected);9 Assertions.assertThat(deepDifference.differences()).isEqualTo("array lengths differ at path \"\", expected: 3 but was: 3 [a, b, c]!=[a, b, d]");10 }11}12 Assertions.assertThat(deepDifference.differences()).isEqualTo("array lengths differ at path "", expected: 3 but was: 3 [a, b, c]!=[a, b, d]");13OpenJDK Runtime Environment 18.9 (build 11.0.2+9)14OpenJDK 64-Bit Server VM 18.9 (build 11.0.2+9, mixed mode)
DeepDifference
Using AI Code Generation
1import org.assertj.core.internal.DeepDifference;2import org.assertj.core.internal.Difference;3import org.assertj.core.internal.Differences;4import java.util.List;5public class DeepDiff {6 public static void main(String[] args) {7 DeepDifference diff = new DeepDifference();8 Differences differences = diff.differencesOf("a", "b");9 List<Difference> diffs = differences.getDifferences();10 for (Difference d : diffs) {11 System.out.println(d);12 }13 }14}
DeepDifference
Using AI Code Generation
1package com.automationintesting;2import org.assertj.core.api.*;3import org.assertj.core.internal.DeepDifference;4import org.junit.Test;5import static org.assertj.core.api.Assertions.*;6import java.util.*;7import java.util.stream.Collectors;8public class DeepDifferenceTest {9 public void testDeepDifference() {10 List<DeepObject> objects = new ArrayList<>();11 objects.add(new DeepObject("id", "name", "description"));12 objects.add(new DeepObject("id2", "name2", "description2"));13 List<DeepObject> objects2 = new ArrayList<>();14 objects2.add(new DeepObject("id", "name", "description"));15 objects2.add(new DeepObject("id2", "name2", "description2"));16 DeepDifference deepDifference = new DeepDifference();17 List<DeepDifference.Difference> differences = deepDifference.differencesBetween(objects, objects2);18 assertThat(differences).isEmpty();19 }20}21package com.automationintesting;22import java.util.Objects;23public class DeepObject {24 private String id;25 private String name;26 private String description;27 public DeepObject(String id, String name, String description) {28 this.id = id;29 this.name = name;30 this.description = description;31 }32 public String getId() {33 return id;34 }35 public void setId(String id) {36 this.id = id;37 }38 public String getName() {39 return name;40 }41 public void setName(String name) {42 this.name = name;43 }44 public String getDescription() {45 return description;46 }47 public void setDescription(String description) {48 this.description = description;49 }50 public boolean equals(Object o) {51 if (this == o) return true;52 if (!(o instanceof DeepObject)) return false;53 DeepObject that = (DeepObject) o;54 return Objects.equals(id, that.id) &&55 Objects.equals(name, that.name) &&56 Objects.equals(description, that.description);57 }58 public int hashCode() {59 return Objects.hash(id, name,
DeepDifference
Using AI Code Generation
1package com.mycompany.app;2import org.assertj.core.internal.DeepDifference;3import java.util.*;4class DeepDifferenceTest{5 public static void main(String args[]){6 DeepDifference deepDiff = new DeepDifference();7 List<String> list1 = new ArrayList<String>();8 List<String> list2 = new ArrayList<String>();9 list1.add("A");10 list1.add("B");11 list1.add("C");12 list2.add("A");13 list2.add("B");14 list2.add("C");15 System.out.println(deepDiff.differences(list1,list2));16 }17}18package com.mycompany.app;19import org.assertj.core.internal.DeepDifference;20import java.util.*;21class DeepDifferenceTest{22 public static void main(String args[]){23 DeepDifference deepDiff = new DeepDifference();24 List<String> list1 = new ArrayList<String>();25 List<String> list2 = new ArrayList<String>();26 list1.add("A");27 list1.add("B");28 list1.add("C");29 list2.add("A");30 list2.add("B");31 list2.add("C");32 System.out.println(deepDiff.differences(list1,list2).isEmpty());33 }34}35package com.mycompany.app;36import org.assertj.core.internal.DeepDifference;37import java.util.*;38class DeepDifferenceTest{39 public static void main(String args[]){40 DeepDifference deepDiff = new DeepDifference();41 List<String> list1 = new ArrayList<String>();42 List<String> list2 = new ArrayList<String>();43 list1.add("A");44 list1.add("B");45 list1.add("C");46 list2.add("A");47 list2.add("B");48 list2.add("C");49 System.out.println(deepDiff.differences(list1,list2).size());50 }51}52package com.mycompany.app;53import org.assertj.core.internal.DeepDifference;54import java.util.*;55class DeepDifferenceTest{56 public static void main(String args[]){57 DeepDifference deepDiff = new DeepDifference();58 List<String> list1 = new ArrayList<String>();
DeepDifference
Using AI Code Generation
1package com.javatpoint;2import org.assertj.core.api.*;3import org.assertj.core.internal.DeepDifference;4import org.junit.Test;5public class AssertJTest {6 public void test(){7 String str1 = "Hello";8 String str2 = "Hello";9 DeepDifference diff = new DeepDifference(str1, str2);10 System.out.println(diff);11 }12}
DeepDifference
Using AI Code Generation
1import org.assertj.core.internal.DeepDifference;2import java.util.List;3public class DeepDifferenceTest {4 public static void main(String[] args) {5 String[] array1 = {"a", "b", "c"};6 String[] array2 = {"a", "b", "c"};7 DeepDifference deepDifference = new DeepDifference();8 List<String> diff = deepDifference.deepDiff(array1, array2);9 System.out.println("The difference between two arrays is: "+diff);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.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Assertj automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used methods in DeepDifference
- DualKey
- equals
- hashCode
- toString
- getPath
- getConcatenatedPath
- Difference
- getActual
- getOther
- getDescription
- determineDifferences
- hasCustomComparator
- initStack
- getFieldsNames
- isContainerType
- compareArrays
- compareOrderedCollection
- compareUnorderedCollectionByHashCodes
- compareUnorderedCollection
- compareSortedMap
- compareUnorderedMap
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
