How to use compareAtomicInteger method of org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator class

Best Assertj code snippet using org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator.compareAtomicInteger

Source:RecursiveComparisonDifferenceCalculator.java Github

copy

Full Screen

...249 compareAtomicBoolean(dualValue, comparisonState);250 continue;251 }252 if (dualValue.isExpectedFieldAnAtomicInteger()) {253 compareAtomicInteger(dualValue, comparisonState);254 continue;255 }256 if (dualValue.isExpectedFieldAnAtomicIntegerArray()) {257 compareAtomicIntegerArray(dualValue, comparisonState);258 continue;259 }260 if (dualValue.isExpectedFieldAnAtomicLong()) {261 compareAtomicLong(dualValue, comparisonState);262 continue;263 }264 if (dualValue.isExpectedFieldAnAtomicLongArray()) {265 compareAtomicLongArray(dualValue, comparisonState);266 continue;267 }268 if (dualValue.isExpectedFieldAnAtomicReference()) {269 compareAtomicReference(dualValue, comparisonState);270 continue;271 }272 if (dualValue.isExpectedFieldAnAtomicReferenceArray()) {273 compareAtomicReferenceArray(dualValue, comparisonState);274 continue;275 }276 if (shouldHonorEquals(dualValue, recursiveComparisonConfiguration)) {277 if (!actualFieldValue.equals(expectedFieldValue)) comparisonState.addDifference(dualValue);278 continue;279 }280 Class<?> actualFieldValueClass = actualFieldValue.getClass();281 Class<?> expectedFieldClass = expectedFieldValue.getClass();282 if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode() && expectedTypeIsNotSubtypeOfActualType(dualValue)) {283 comparisonState.addDifference(dualValue,284 format(STRICT_TYPE_ERROR, expectedFieldClass.getName(), actualFieldValueClass.getName()));285 continue;286 }287 Set<String> actualNonIgnoredFieldsNames = recursiveComparisonConfiguration.getActualFieldNamesToCompare(dualValue);288 Set<String> expectedFieldsNames = getFieldsNames(expectedFieldClass);289 // Check if expected has more fields than actual, in that case the additional fields are reported as difference290 if (!expectedFieldsNames.containsAll(actualNonIgnoredFieldsNames)) {291 // report missing fields in actual292 Set<String> actualFieldsNamesNotInExpected = newHashSet(actualNonIgnoredFieldsNames);293 actualFieldsNamesNotInExpected.removeAll(expectedFieldsNames);294 String missingFields = actualFieldsNamesNotInExpected.toString();295 String expectedClassName = expectedFieldClass.getName();296 String actualClassName = actualFieldValueClass.getName();297 String missingFieldsDescription = format(MISSING_FIELDS, actualClassName, expectedClassName,298 expectedFieldClass.getSimpleName(), actualFieldValueClass.getSimpleName(),299 missingFields);300 comparisonState.addDifference(dualValue, missingFieldsDescription);301 } else { // TODO remove else to report more diff302 // compare actual's fields against expected :303 // - if actual has more fields than expected, the additional fields are ignored as expected is the reference304 for (String actualFieldName : actualNonIgnoredFieldsNames) {305 if (expectedFieldsNames.contains(actualFieldName)) {306 DualValue newDualValue = new DualValue(dualValue.fieldLocation.field(actualFieldName),307 COMPARISON.getSimpleValue(actualFieldName, actualFieldValue),308 COMPARISON.getSimpleValue(actualFieldName, expectedFieldValue));309 comparisonState.registerForComparison(newDualValue);310 }311 }312 }313 }314 return comparisonState.getDifferences();315 }316 // avoid comparing enum recursively since they contain static fields which are ignored in recursive comparison317 // this would make different field enum value to be considered the same!318 private static void compareAsEnums(final DualValue dualValue,319 ComparisonState comparisonState,320 RecursiveComparisonConfiguration recursiveComparisonConfiguration) {321 if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode()) {322 // we can use == for comparison which checks both actual and expected values and types are the same323 if (dualValue.actual != dualValue.expected) comparisonState.addDifference(dualValue);324 return;325 }326 if (!dualValue.isActualAnEnum()) {327 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an enum"));328 return;329 }330 // both actual and expected are enums331 Enum<?> actualEnum = (Enum<?>) dualValue.actual;332 Enum<?> expectedEnum = (Enum<?>) dualValue.expected;333 // we must only compare actual and expected enum by value but not by type334 if (!actualEnum.name().equals(expectedEnum.name())) comparisonState.addDifference(dualValue);335 }336 private static boolean shouldHonorEquals(DualValue dualValue,337 RecursiveComparisonConfiguration recursiveComparisonConfiguration) {338 // since java 17 we can't introspect java types and get their fields so by default we compare them with equals339 // unless for some container like java types: iterables, array, optional, atomic values where we take the contained values340 // through accessors and register them in the recursive comparison.341 boolean shouldHonorJavaTypeEquals = dualValue.hasSomeJavaTypeValue() && !dualValue.isExpectedAContainer();342 return shouldHonorJavaTypeEquals || shouldHonorOverriddenEquals(dualValue, recursiveComparisonConfiguration);343 }344 private static boolean shouldHonorOverriddenEquals(DualValue dualValue,345 RecursiveComparisonConfiguration recursiveComparisonConfiguration) {346 boolean shouldNotIgnoreOverriddenEqualsIfAny = !recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue);347 return shouldNotIgnoreOverriddenEqualsIfAny && dualValue.actual != null && hasOverriddenEquals(dualValue.actual.getClass());348 }349 private static void compareArrays(DualValue dualValue, ComparisonState comparisonState) {350 if (!dualValue.isActualFieldAnArray()) {351 // at the moment we only allow comparing arrays with arrays but we might allow comparing to collections later on352 // but only if we are not in strict type mode.353 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an array"));354 return;355 }356 // both values in dualValue are arrays357 int actualArrayLength = Array.getLength(dualValue.actual);358 int expectedArrayLength = Array.getLength(dualValue.expected);359 if (actualArrayLength != expectedArrayLength) {360 comparisonState.addDifference(dualValue, format(DIFFERENT_SIZE_ERROR, "arrays", actualArrayLength, expectedArrayLength));361 // no need to inspect elements, arrays are not equal as they don't have the same size362 return;363 }364 // register each pair of actual/expected elements for recursive comparison365 FieldLocation arrayFieldLocation = dualValue.fieldLocation;366 for (int i = 0; i < actualArrayLength; i++) {367 Object actualElement = Array.get(dualValue.actual, i);368 Object expectedElement = Array.get(dualValue.expected, i);369 FieldLocation elementFieldLocation = arrayFieldLocation.field(format("[%d]", i));370 comparisonState.registerForComparison(new DualValue(elementFieldLocation, actualElement, expectedElement));371 }372 }373 /*374 * Deeply compare two Collections that must be same length and in same order.375 */376 private static void compareOrderedCollections(DualValue dualValue, ComparisonState comparisonState) {377 if (!dualValue.isActualFieldAnOrderedCollection()) {378 // at the moment if expected is an ordered collection then actual should also be one379 comparisonState.addDifference(dualValue,380 format(ACTUAL_NOT_ORDERED_COLLECTION, dualValue.actual.getClass().getCanonicalName()));381 return;382 }383 Collection<?> actualCollection = (Collection<?>) dualValue.actual;384 Collection<?> expectedCollection = (Collection<?>) dualValue.expected;385 if (actualCollection.size() != expectedCollection.size()) {386 comparisonState.addDifference(dualValue, format(DIFFERENT_SIZE_ERROR, "collections", actualCollection.size(),387 expectedCollection.size()));388 // no need to inspect elements, arrays are not equal as they don't have the same size389 return;390 }391 // register pair of elements with same index for later comparison as we compare elements in order392 Iterator<?> expectedIterator = expectedCollection.iterator();393 int i = 0;394 for (Object element : actualCollection) {395 FieldLocation elementFielLocation = dualValue.fieldLocation.field(format("[%d]", i));396 DualValue elementDualValue = new DualValue(elementFielLocation, element, expectedIterator.next());397 comparisonState.registerForComparison(elementDualValue);398 i++;399 }400 }401 private static String differentTypeErrorMessage(DualValue dualValue, String actualTypeDescription) {402 return format(DIFFERENT_ACTUAL_AND_EXPECTED_FIELD_TYPES,403 actualTypeDescription, dualValue.actual.getClass().getCanonicalName());404 }405 private static void compareUnorderedIterables(DualValue dualValue, ComparisonState comparisonState) {406 if (!dualValue.isActualFieldAnIterable()) {407 // at the moment we only compare iterable with iterables (but we might allow arrays too)408 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an iterable"));409 return;410 }411 Iterable<?> actual = (Iterable<?>) dualValue.actual;412 Iterable<?> expected = (Iterable<?>) dualValue.expected;413 int actualSize = sizeOf(actual);414 int expectedSize = sizeOf(expected);415 if (actualSize != expectedSize) {416 comparisonState.addDifference(dualValue, format(DIFFERENT_SIZE_ERROR, "collections", actualSize, expectedSize));417 // no need to inspect elements, iterables are not equal as they don't have the same size418 return;419 }420 // copy actual as we will remove elements found in expected421 Collection<?> actualCopy = new LinkedList<>(toCollection(actual));422 List<Object> expectedElementsNotFound = list();423 for (Object expectedElement : expected) {424 boolean expectedElementMatched = false;425 // compare recursively expectedElement to all remaining actual elements426 Iterator<?> actualIterator = actualCopy.iterator();427 while (actualIterator.hasNext()) {428 Object actualElement = actualIterator.next();429 // we need to get the currently visited dual values otherwise a cycle would cause an infinite recursion.430 List<ComparisonDifference> differences = determineDifferences(actualElement, expectedElement, dualValue.fieldLocation,431 comparisonState.visitedDualValues,432 comparisonState.recursiveComparisonConfiguration);433 if (differences.isEmpty()) {434 // found an element in actual matching expectedElement, remove it as it can't be used to match other expected elements435 actualIterator.remove();436 expectedElementMatched = true;437 // jump to next actual element check438 break;439 }440 }441 if (!expectedElementMatched) {442 expectedElementsNotFound.add(expectedElement);443 }444 }445 if (!expectedElementsNotFound.isEmpty()) {446 String unmatched = format("The following expected elements were not matched in the actual %s:%n %s",447 actual.getClass().getSimpleName(), expectedElementsNotFound);448 comparisonState.addDifference(dualValue, unmatched);449 // TODO could improve the error by listing the actual elements not in expected but that would need450 // another double loop inverting actual and expected to find the actual elements not matched in expected451 }452 }453 // TODO replace by ordered map454 private static <K, V> void compareSortedMap(DualValue dualValue, ComparisonState comparisonState) {455 if (!dualValue.isActualFieldASortedMap()) {456 // at the moment we only compare iterable with iterables (but we might allow arrays too)457 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "a sorted map"));458 return;459 }460 Map<?, ?> actualMap = (Map<?, ?>) dualValue.actual;461 @SuppressWarnings("unchecked")462 Map<K, V> expectedMap = (Map<K, V>) dualValue.expected;463 if (actualMap.size() != expectedMap.size()) {464 comparisonState.addDifference(dualValue, format(DIFFERENT_SIZE_ERROR, "sorted maps", actualMap.size(), expectedMap.size()));465 // no need to inspect entries, maps are not equal as they don't have the same size466 return;467 }468 Iterator<Map.Entry<K, V>> expectedMapEntries = expectedMap.entrySet().iterator();469 for (Map.Entry<?, ?> actualEntry : actualMap.entrySet()) {470 Map.Entry<?, ?> expectedEntry = expectedMapEntries.next();471 // check keys are matched before comparing values as keys represents a field472 if (!java.util.Objects.equals(actualEntry.getKey(), expectedEntry.getKey())) {473 // report a missing key/field.474 comparisonState.addKeyDifference(dualValue, actualEntry.getKey(), expectedEntry.getKey());475 } else {476 // as the key/field match we can simply compare field/key values477 FieldLocation keyFieldLocation = keyFieldLocation(dualValue.fieldLocation, actualEntry.getKey());478 comparisonState.registerForComparison(new DualValue(keyFieldLocation, actualEntry.getValue(), expectedEntry.getValue()));479 }480 }481 }482 private static void compareUnorderedMap(DualValue dualValue, ComparisonState comparisonState) {483 if (!dualValue.isActualFieldAMap()) {484 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "a map"));485 return;486 }487 Map<?, ?> actualMap = (Map<?, ?>) dualValue.actual;488 Map<?, ?> expectedMap = (Map<?, ?>) dualValue.expected;489 if (actualMap.size() != expectedMap.size()) {490 comparisonState.addDifference(dualValue, format(DIFFERENT_SIZE_ERROR, "maps", actualMap.size(), expectedMap.size()));491 // no need to inspect entries, maps are not equal as they don't have the same size492 return;493 }494 // actual and expected maps same size but do they have the same keys?495 Set<?> expectedKeysNotFound = new LinkedHashSet<>(expectedMap.keySet());496 expectedKeysNotFound.removeAll(actualMap.keySet());497 if (!expectedKeysNotFound.isEmpty()) {498 comparisonState.addDifference(dualValue, format("The following keys were not found in the actual map value:%n %s",499 expectedKeysNotFound));500 return;501 }502 // actual and expected maps have the same keys, we need now to compare their values503 for (Object key : expectedMap.keySet()) {504 FieldLocation keyFieldLocation = keyFieldLocation(dualValue.fieldLocation, key);505 comparisonState.registerForComparison(new DualValue(keyFieldLocation, actualMap.get(key), expectedMap.get(key)));506 }507 }508 private static FieldLocation keyFieldLocation(FieldLocation parentFieldLocation, Object key) {509 return key == null ? parentFieldLocation : parentFieldLocation.field(key.toString());510 }511 private static void compareOptional(DualValue dualValue, ComparisonState comparisonState) {512 if (!dualValue.isActualFieldAnOptional()) {513 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an Optional"));514 return;515 }516 Optional<?> actual = (Optional<?>) dualValue.actual;517 Optional<?> expected = (Optional<?>) dualValue.expected;518 if (actual.isPresent() != expected.isPresent()) {519 comparisonState.addDifference(dualValue);520 return;521 }522 // either both are empty or present523 if (!actual.isPresent()) return; // both optional are empty => end of the comparison524 // both are present, we have to compare their values recursively525 Object value1 = actual.get();526 Object value2 = expected.get();527 // we add VALUE_FIELD_NAME to the path since we register Optional.value fields.528 comparisonState.registerForComparison(new DualValue(dualValue.fieldLocation.field(VALUE_FIELD_NAME), value1, value2));529 }530 private static void compareAtomicBoolean(DualValue dualValue, ComparisonState comparisonState) {531 if (!dualValue.isActualFieldAnAtomicBoolean()) {532 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an AtomicBoolean"));533 return;534 }535 AtomicBoolean actual = (AtomicBoolean) dualValue.actual;536 AtomicBoolean expected = (AtomicBoolean) dualValue.expected;537 Object value1 = actual.get();538 Object value2 = expected.get();539 // we add VALUE_FIELD_NAME to the path since we register AtomicBoolean.value fields.540 comparisonState.registerForComparison(new DualValue(dualValue.fieldLocation.field(VALUE_FIELD_NAME), value1, value2));541 }542 private static void compareAtomicInteger(DualValue dualValue, ComparisonState comparisonState) {543 if (!dualValue.isActualFieldAnAtomicInteger()) {544 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an AtomicInteger"));545 return;546 }547 AtomicInteger actual = (AtomicInteger) dualValue.actual;548 AtomicInteger expected = (AtomicInteger) dualValue.expected;549 Object value1 = actual.get();550 Object value2 = expected.get();551 // we add VALUE_FIELD_NAME to the path since we register AtomicInteger.value fields.552 comparisonState.registerForComparison(new DualValue(dualValue.fieldLocation.field(VALUE_FIELD_NAME), value1, value2));553 }554 private static void compareAtomicIntegerArray(DualValue dualValue, ComparisonState comparisonState) {555 if (!dualValue.isActualFieldAnAtomicIntegerArray()) {556 comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an AtomicIntegerArray"));557 return;558 }559 AtomicIntegerArray actual = (AtomicIntegerArray) dualValue.actual;560 AtomicIntegerArray expected = (AtomicIntegerArray) dualValue.expected;561 // both values in dualValue are arrays562 int actualArrayLength = actual.length();563 int expectedArrayLength = expected.length();564 if (actualArrayLength != expectedArrayLength) {565 comparisonState.addDifference(dualValue,566 format(DIFFERENT_SIZE_ERROR, "AtomicIntegerArrays", actualArrayLength, expectedArrayLength));567 // no need to inspect elements, arrays are not equal as they don't have the same size568 return;...

Full Screen

Full Screen

compareAtomicInteger

Using AI Code Generation

copy

Full Screen

1public class RecursiveComparisonDifferenceCalculator_compareAtomicInteger_Test {2 public void should_compare_atomic_integer() {3 AtomicInteger actual = new AtomicInteger(1);4 AtomicInteger other = new AtomicInteger(2);5 RecursiveComparisonDifference differences = compareAtomicInteger(actual, other);6 assertThat(differences).hasSize(1);7 RecursiveComparisonDifference difference = differences.iterator().next();8 assertThat(difference).hasDescription("AtomicInteger[<no field>] differ: actual value was:<1> but expected value was:<2>");9 }10}

Full Screen

Full Screen

compareAtomicInteger

Using AI Code Generation

copy

Full Screen

1public class CompareAtomicInteger {2 public static void main(String[] args) {3 AtomicInteger atomicInteger1 = new AtomicInteger(1);4 AtomicInteger atomicInteger2 = new AtomicInteger(1);5 RecursiveComparisonDifferenceCalculator calculator = new RecursiveComparisonDifferenceCalculator();6 List<RecursiveComparisonDifference> differences = calculator.compareAtomicInteger(atomicInteger1, atomicInteger2);7 differences.forEach(difference -> System.out.println(difference.toString()));8 }9}10public class CompareAtomicInteger {11 public static void main(String[] args) {12 AtomicInteger atomicInteger1 = new AtomicInteger(1);13 AtomicInteger atomicInteger2 = new AtomicInteger(1);14 RecursiveComparisonDifferenceCalculator calculator = new RecursiveComparisonDifferenceCalculator();15 List<RecursiveComparisonDifference> differences = calculator.compareAtomicInteger(atomicInteger1, atomicInteger2);16 differences.forEach(difference -> System.out.println(difference.toString()));17 }18}19public class CompareAtomicInteger {20 public static void main(String[] args) {21 AtomicInteger atomicInteger1 = new AtomicInteger(1);22 AtomicInteger atomicInteger2 = new AtomicInteger(1);23 RecursiveComparisonDifferenceCalculator calculator = new RecursiveComparisonDifferenceCalculator();24 List<RecursiveComparisonDifference> differences = calculator.compareAtomicInteger(atomicInteger1, atomicInteger2);25 differences.forEach(difference -> System.out.println(difference.toString()));26 }27}28public class CompareAtomicInteger {29 public static void main(String[] args) {30 AtomicInteger atomicInteger1 = new AtomicInteger(1);31 AtomicInteger atomicInteger2 = new AtomicInteger(1);32 RecursiveComparisonDifferenceCalculator calculator = new RecursiveComparisonDifferenceCalculator();33 List<RecursiveComparisonDifference> differences = calculator.compareAtomicInteger(atomicInteger1, atomicInteger2);34 differences.forEach(difference -> System.out.println(difference.toString()));35 }36}

Full Screen

Full Screen

compareAtomicInteger

Using AI Code Generation

copy

Full Screen

1public void printList(List<List<String>> list) {2 for (List<String> innerList : list) {3 for (String item : innerList) {4 System.out.println(item);5 }6 }7}8public void testPrintList() {9 List<List<String>> list = new ArrayList<>();10 List<String> innerList = new ArrayList<>();11 innerList.add("a");12 innerList.add("b");13 list.add(innerList);14 printList(list);15}16I tried using assertThat(list).containsExactly(innerList); but that fails with the same error. I also tried assertThat(list).containsExactly(innerList, new ArrayList<>()); but that fails with the following error:17to contain exactly (and in same order):18I have also tried assertThat(list).containsExactlyElementsOf(innerList); but that fails with the following error:19to contain exactly (and in same order):20public class MyComparator implements Comparator<String> {21 public int compare(String s1, String s2) {22 return s1.compareTo(s2);23 }24}25public class MyComparatorTest {

Full Screen

Full Screen

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:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful