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

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

Source:RecursiveComparisonConfiguration_shouldIgnoreOverriddenEqualsOf_Test.java

...34  }35  @Test36  void should_ignore_all_overridden_equals_for_non_java_types() {37    // GIVEN38    DualValue dualValue = new DualValue(list("foo"), new Person(), new Person());39    recursiveComparisonConfiguration.ignoreAllOverriddenEquals();40    // WHEN41    boolean ignored = recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue);42    // THEN43    assertThat(ignored).as("All overridden equals should be ignored")44                       .isTrue();45  }46  @ParameterizedTest47  @MethodSource("ignoringAllOverriddenEqualsExceptBasicTypes")48  void should_ignore_all_overridden_equals_except_basic_types(Object value) {49    // GIVEN50    DualValue dualValue = new DualValue(list("foo"), value, value);51    recursiveComparisonConfiguration.ignoreAllOverriddenEquals();52    // WHEN53    boolean ignored = recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue);54    // THEN55    assertThat(ignored).as("overridden equals should not be ignored for %s", value.getClass())56                       .isFalse();57  }58  private static Stream<Object> ignoringAllOverriddenEqualsExceptBasicTypes() {59    return Stream.of("foo", 23, 2.0, 123L, true, Byte.MIN_VALUE, new Object(), new Date(), Color.BLUE);60  }61  @ParameterizedTest(name = "{0} overridden equals should be ignored with these regexes {1}")62  @MethodSource("ignoringOverriddenEqualsByRegexesSource")63  void should_ignore_overridden_equals_by_regexes(Class<?> clazz, String[] fieldRegexes) {64    // GIVEN65    recursiveComparisonConfiguration.ignoreOverriddenEqualsForFieldsMatchingRegexes(fieldRegexes);66    // WHEN67    boolean ignored = recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(clazz);68    // THEN69    assertThat(ignored).as("%s overridden equals should be ignored with these regexes %s", clazz, fieldRegexes)70                       .isTrue();71  }72  private static Stream<Arguments> ignoringOverriddenEqualsByRegexesSource() {73    return Stream.of(arguments(Person.class, array("foo", ".*Person")),74                     arguments(Human.class, array("org.assertj.core.internal.*.data\\.Human", "foo")),75                     arguments(Multimap.class, array("com.google.common.collect.*")));76  }77  @ParameterizedTest(name = "{0} overridden equals should be ignored for these types {1}")78  @MethodSource("ignoringOverriddenEqualsForTypesSource")79  void should_ignore_overridden_equals_by_types(Class<?> clazz, List<Class<?>> types) {80    // GIVEN81    recursiveComparisonConfiguration.ignoreOverriddenEqualsForTypes(types.toArray(new Class[0]));82    // WHEN83    boolean ignored = recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(clazz);84    // THEN85    assertThat(ignored).as("%s overridden equals should be ignored for these types %s", clazz, types)86                       .isTrue();87  }88  private static Stream<Arguments> ignoringOverriddenEqualsForTypesSource() {89    return Stream.of(arguments(Person.class, list(Human.class, Person.class, String.class)),90                     arguments(Human.class, list(Human.class)));91  }92  @ParameterizedTest(name = "{0} overridden equals should be ignored for these fields {1}")93  @MethodSource("ignoringOverriddenEqualsForFieldsSource")94  void should_ignore_overridden_equals_by_fields(DualValue dualValue, String[] fields) {95    // GIVEN96    recursiveComparisonConfiguration.ignoreOverriddenEqualsForFields(fields);97    // WHEN98    boolean ignored = recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue);99    // THEN100    assertThat(ignored).as("%s overridden equals should be ignored for these fields %s", dualValue, fields)101                       .isTrue();102  }103  private static Stream<Arguments> ignoringOverriddenEqualsForFieldsSource() {104    return Stream.of(arguments(dualValueWithPath("name"), array("name")),105                     arguments(dualValueWithPath("name"), array("foo", "name", "foo")),106                     arguments(dualValueWithPath("name", "first"), array("name.first")),107                     arguments(dualValueWithPath("father", "name", "first"), array("father", "name.first", "father.name.first")));108  }109  private static DualValue dualValueWithPath(String... pathElements) {110    return new DualValue(list(pathElements), new Person(), new Person());111  }112}...

Source:DualValueDequeTest.java

...11 * Copyright 2012-2020 the original author or authors.12 */13package org.assertj.core.api.recursive.comparison;14import static org.assertj.core.api.BDDAssertions.then;15import static org.assertj.core.api.recursive.comparison.DualValueUtil.randomPath;16import static org.assertj.core.util.Lists.list;17import org.junit.jupiter.api.BeforeEach;18import org.junit.jupiter.api.DisplayName;19import org.junit.jupiter.api.Test;20@DisplayName("DualValueDeque")21class DualValueDequeTest {22  private RecursiveComparisonConfiguration recursiveComparisonConfiguration;23  @BeforeEach24  void beforeEachTest() {25    recursiveComparisonConfiguration = new RecursiveComparisonConfiguration();26  }27  @Test28  void should_ignore_dual_values_with_a_null_first_value() {29    // GIVEN30    recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);31    DualValueDeque dualValueDeque = new DualValueDeque(recursiveComparisonConfiguration);32    DualValue dualValueA = dualValue(null, "A");33    DualValue dualValueB = dualValue("B", "B");34    DualValue dualValueC = dualValue(null, "C");35    DualValue dualValueD = dualValue("D", "D");36    DualValue dualValueE = dualValue("E", "E");37    // WHEN38    dualValueDeque.add(dualValueA);39    dualValueDeque.add(dualValueB);40    dualValueDeque.addFirst(dualValueC);41    dualValueDeque.add(dualValueD);42    dualValueDeque.addLast(dualValueE);43    dualValueDeque.add(1, dualValueA);44    dualValueDeque.addAll(list(dualValueA, dualValueB, dualValueC));45    dualValueDeque.addAll(0, list(dualValueA, dualValueB, dualValueC));46    // THEN47    then(dualValueDeque).containsExactly(dualValueB, dualValueB, dualValueD, dualValueE, dualValueB);48  }49  @Test50  void should_ignore_dual_values_with_a_null_second_value() {51    // GIVEN52    recursiveComparisonConfiguration.setIgnoreAllExpectedNullFields(true);53    DualValueDeque dualValueDeque = new DualValueDeque(recursiveComparisonConfiguration);54    DualValue dualValueA = dualValue("A", null);55    DualValue dualValueB = dualValue("B", "B");56    DualValue dualValueC = dualValue("C", null);57    DualValue dualValueD = dualValue("D", "D");58    DualValue dualValueE = dualValue("E", "E");59    // WHEN60    dualValueDeque.add(dualValueA);61    dualValueDeque.add(dualValueB);62    dualValueDeque.addFirst(dualValueC);63    dualValueDeque.add(dualValueD);64    dualValueDeque.addLast(dualValueE);65    dualValueDeque.add(1, dualValueA);66    dualValueDeque.addAll(list(dualValueA, dualValueB, dualValueC));67    dualValueDeque.addAll(0, list(dualValueA, dualValueB, dualValueC));68    // THEN69    then(dualValueDeque).containsExactly(dualValueB, dualValueB, dualValueD, dualValueE, dualValueB);70  }71  @Test72  void should_not_ignore_any_dual_values() {73    // GIVEN74    DualValueDeque dualValueDeque = new DualValueDeque(recursiveComparisonConfiguration);75    DualValue dualValueA = dualValue(null, "A");76    DualValue dualValueB = dualValue("B", "B");77    DualValue dualValueC = dualValue(null, "C");78    DualValue dualValueD = dualValue("D", "D");79    DualValue dualValueE = dualValue("E", "E");80    // WHEN81    dualValueDeque.add(dualValueA);82    dualValueDeque.add(dualValueB);83    dualValueDeque.addFirst(dualValueC);84    dualValueDeque.add(dualValueD);85    dualValueDeque.addLast(dualValueE);86    dualValueDeque.add(1, dualValueA);87    dualValueDeque.addAll(list(dualValueA, dualValueB, dualValueC));88    dualValueDeque.addAll(0, list(dualValueA, dualValueB, dualValueC));89    // THEN90    then(dualValueDeque).containsExactly(dualValueA, dualValueB, dualValueC, dualValueC, dualValueA, dualValueA, dualValueB,91                                         dualValueD, dualValueE, dualValueA, dualValueB, dualValueC);92  }93  private static DualValue dualValue(String value1, String value2) {94    return new DualValue(randomPath(), value1, value2);95  }96}...

Source:DualDequeTest.java

...19    @Test20    public void should_ignore_dual_keys_with_a_null_first_key() {21        // GIVEN22        recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);23        DualValueDeque dualKayDeque = new DualValueDeque(recursiveComparisonConfiguration);24        DualValue dualKeyA = DualDequeTest.dualKey(null, "A");25        DualValue dualKeyB = DualDequeTest.dualKey("B", "B");26        DualValue dualKeyC = DualDequeTest.dualKey(null, "C");27        DualValue dualKeyD = DualDequeTest.dualKey("D", "D");28        DualValue dualKeyE = DualDequeTest.dualKey("E", "E");29        // WHEN30        dualKayDeque.add(dualKeyA);31        dualKayDeque.add(dualKeyB);32        dualKayDeque.addFirst(dualKeyC);33        dualKayDeque.add(dualKeyD);34        dualKayDeque.addLast(dualKeyE);35        dualKayDeque.add(1, dualKeyA);36        dualKayDeque.addAll(Lists.list(dualKeyA, dualKeyB, dualKeyC));37        dualKayDeque.addAll(0, Lists.list(dualKeyA, dualKeyB, dualKeyC));38        // THEN39        Assertions.assertThat(dualKayDeque).containsExactly(dualKeyB, dualKeyB, dualKeyD, dualKeyE, dualKeyB);40    }41    @Test42    public void should_not_ignore_any_dual_keys() {43        // GIVEN44        DualValueDeque dualKayDeque = new DualValueDeque(recursiveComparisonConfiguration);45        DualValue dualKeyA = DualDequeTest.dualKey(null, "A");46        DualValue dualKeyB = DualDequeTest.dualKey("B", "B");47        DualValue dualKeyC = DualDequeTest.dualKey(null, "C");48        DualValue dualKeyD = DualDequeTest.dualKey("D", "D");49        DualValue dualKeyE = DualDequeTest.dualKey("E", "E");50        // WHEN51        dualKayDeque.add(dualKeyA);52        dualKayDeque.add(dualKeyB);53        dualKayDeque.addFirst(dualKeyC);54        dualKayDeque.add(dualKeyD);55        dualKayDeque.addLast(dualKeyE);56        dualKayDeque.add(1, dualKeyA);57        dualKayDeque.addAll(Lists.list(dualKeyA, dualKeyB, dualKeyC));58        dualKayDeque.addAll(0, Lists.list(dualKeyA, dualKeyB, dualKeyC));59        // THEN60        Assertions.assertThat(dualKayDeque).containsExactly(dualKeyA, dualKeyB, dualKeyC, dualKeyC, dualKeyA, dualKeyA, dualKeyB, dualKeyD, dualKeyE, dualKeyA, dualKeyB, dualKeyC);61    }62}...

DualValue

Using AI Code Generation

1package com.example;2import org.assertj.core.api.recursive.comparison.DualValue;3import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration;4import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifference;5import java.util.List;6public class DualValueExample {7    public static void main(String[] args) {8        RecursiveComparisonConfiguration recursiveComparisonConfiguration = new RecursiveComparisonConfiguration();9        recursiveComparisonConfiguration.setIgnoreCollectionOrder(true);10        recursiveComparisonConfiguration.setIgnoreCollectionOrder(true);11        recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);12        recursiveComparisonConfiguration.setIgnoreAllExpectedNullFields(true);13        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);14        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);15        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);16        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);17        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);18        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);19        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);20        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);21        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);22        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);23        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);24        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);25        recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);26        recursiveComparisonConfiguration.setIgnoreAllExpectedEmptyOptionalFields(true);27        DualValue dualValue = new DualValue("a", "a", recursiveComparisonConfiguration);28        List<RecursiveComparisonDifference> differences = dualValue.getDifferences();29        System.out.println(differences);30    }31}32package com.example;33import org.assertj.core.api.recursive.comparison.DualValue;34import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration;35import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifference;36import java.util.List;37public class DualValueExample {38    public static void main(String[] args) {39        RecursiveComparisonConfiguration recursiveComparisonConfiguration = new RecursiveComparisonConfiguration();40        recursiveComparisonConfiguration.setIgnoreCollectionOrder(true);41        recursiveComparisonConfiguration.setIgnoreCollectionOrder(true);42        recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);

DualValue

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.within;3import java.util.List;4import org.assertj.core.api.recursive.comparison.DualValue;5import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration;6import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifference;7import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifference.DifferenceType;8import org.assertj.core.groups.Tuple;9public class DualValueTest {10    public static void main(String[] args) {11        RecursiveComparisonConfiguration config = new RecursiveComparisonConfiguration();12        List<RecursiveComparisonDifference> differences = DualValue.dualValue("foo", "bar", config).getDifferences();13        assertThat(differences).hasSize(1);14        RecursiveComparisonDifference difference = differences.get(0);15        assertThat(difference.getActual()).isEqualTo("foo");16        assertThat(difference.getExpected()).isEqualTo("bar");17        assertThat(difference.getDifferenceType()).isEqualTo(DifferenceType.VALUE);18        assertThat(difference.getPath()).isEmpty();19        assertThat(difference.getDescription()).isEqualTo("value of type java.lang.String");20        differences = DualValue.dualValue("foo", "foo", config).getDifferences();21        assertThat(differences).isEmpty();22        differences = DualValue.dualValue(1, 2, config).getDifferences();23        assertThat(differences).hasSize(1);24        difference = differences.get(0);25        assertThat(difference.getActual()).isEqualTo(1);26        assertThat(difference.getExpected()).isEqualTo(2);27        assertThat(difference.getDifferenceType()).isEqualTo(DifferenceType.VALUE);28        assertThat(difference.getPath()).isEmpty();29        assertThat(difference.getDescription()).isEqualTo("value of type java.lang.Integer");30        differences = DualValue.dualValue(1, 1, config).getDifferences();31        assertThat(differences).isEmpty();32        differences = DualValue.dualValue(1.0, 2.0, config).getDifferences();33        assertThat(differences).hasSize(1);34        difference = differences.get(0);35        assertThat(difference.getActual()).isEqualTo(1.0);36        assertThat(difference.getExpected()).isEqualTo(2.0);37        assertThat(difference.getDifferenceType()).isEqualTo(DifferenceType.VALUE);38        assertThat(difference.getPath()).isEmpty();39        assertThat(difference.getDescription()).isEqualTo("value of type java.lang.Double");40        differences = DualValue.dualValue(1.0, 1.0, config

DualValue

Using AI Code Generation

1package org.assertj.core.api.recursive.comparison;2import org.assertj.core.api.recursive.comparison.DualValue;3public class DualValueTest {4    public static void main(String[] args) {5        DualValue dualValue = new DualValue(1, 2);6        System.out.println(dualValue);7    }8}9package org.assertj.core.api.recursive.comparison;10import org.assertj.core.api.recursive.comparison.DualValue;11public class DualValueTest {12    public static void main(String[] args) {13        DualValue dualValue = new DualValue(1, 2);14        System.out.println(dualValue.actual);15    }16}17package org.assertj.core.api.recursive.comparison;18import org.assertj.core.api.recursive.comparison.DualValue;19public class DualValueTest {20    public static void main(String[] args) {21        DualValue dualValue = new DualValue(1, 2);22        System.out.println(dualValue.other);23    }24}25package org.assertj.core.api.recursive.comparison;26import org.assertj.core.api.recursive.comparison.DualValue;27public class DualValueTest {28    public static void main(String[] args) {29        DualValue dualValue = new DualValue(1, 2);30        System.out.println(dualValue.isBothNull());31    }32}33package org.assertj.core.api.recursive.comparison;34import org.assertj.core.api.recursive.comparison.DualValue;35public class DualValueTest {36    public static void main(String[] args) {37        DualValue dualValue = new DualValue(1, 2);38        System.out.println(dualValue.isAnyNull());39    }40}

DualValue

Using AI Code Generation

1import org.assertj.core.api.recursive.comparison.DualValue;2public class DualValueTest {3    public static void main(String[] args) {4        DualValue dualValue = new DualValue("A", "B");5        System.out.println(dualValue);6    }7}

DualValue

Using AI Code Generation

1import org.assertj.core.api.recursive.comparison.DualValue;2public class DualValueDemo {3   public static void main(String[] args) {4      DualValue dualValue = new DualValue("1", "2");5      System.out.println(dualValue);6   }7}8import org.assertj.core.api.recursive.comparison.DualValue;9public class DualValueDemo {10   public static void main(String[] args) {11      DualValue dualValue = new DualValue("1", "2");12      System.out.println(dualValue.actual);13      System.out.println(dualValue.expected);14   }15}16import org.assertj.core.api.recursive.comparison.DualValue;17public class DualValueDemo {18   public static void main(String[] args) {19      DualValue dualValue = new DualValue("1", "2");20      System.out.println(dualValue.getActual());21      System.out.println(dualValue.getExpected());22   }23}24import org.assertj.core.api.recursive.comparison.DualValue;25public class DualValueDemo {26   public static void main(String[] args) {27      DualValue dualValue = new DualValue("1", "2");28      System.out.println(dualValue.actual());29      System.out.println(dualValue.expected());30   }31}32import org.assertj.core.api.recursive.comparison.DualValue;33public class DualValueDemo {34   public static void main(String[] args) {35      DualValue dualValue = new DualValue("1", "2");36      System.out.println(dualValue.actual);37      System.out.println(dualValue.expected);38   }39}40import org.assertj.core.api.recursive.comparison

DualValue

Using AI Code Generation

1DualValue dualValue = new DualValue("a", "b");2assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");3assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");4DualValue dualValue = new DualValue("a", "b");5assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");6assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");7DualValue dualValue = new DualValue("a", "b");8assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");9assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");10DualValue dualValue = new DualValue("a", "b");11assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");12assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");13DualValue dualValue = new DualValue("a", "b");14assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");15assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");16DualValue dualValue = new DualValue("a", "b");17assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");18assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");19DualValue dualValue = new DualValue("a", "b");20assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");21assertThat(dualValue).usingRecursiveComparison().isEqualTo("b");22DualValue dualValue = new DualValue("a", "b");23assertThat(dualValue).usingRecursiveComparison().isEqualTo("a");24assertThat(dualValue).usingRecursive

DualValue

Using AI Code Generation

1public class DualValueTest {2    public static void main(String[] args) {3        DualValue dualValue = DualValue.dualValue("value1", "value2");4        System.out.println(dualValue);5    }6}7DualValue{actual=value1, other=value2}8public class DualValueTest {9    public static void main(String[] args) {10        DualValue dualValue = DualValue.dualValue("value1", "value2");11        System.out.println(dualValue);12    }13}14DualValue{actual=value1, other=value2}15public class DualValueTest {16    public static void main(String[] args) {17        DualValue dualValue = DualValue.dualValue("value1", "value2");18        System.out.println(dualValue);19    }20}21DualValue{actual=value1, other=value2}22public class DualValueTest {23    public static void main(String[] args) {24        DualValue dualValue = DualValue.dualValue("value1", "value2");25        System.out.println(dualValue);26    }27}28DualValue{actual=value1, other=value2}29public class DualValueTest {30    public static void main(String[] args) {31        DualValue dualValue = DualValue.dualValue("value1", "value2");32        System.out.println(dualValue);33    }34}35DualValue{actual=value1, other=value2}36public class DualValueTest {37    public static void main(String[] args) {38        DualValue dualValue = DualValue.dualValue("value1", "value2");39        System.out.println(dualValue);40    }41}42DualValue{actual=value1, other=value2}

DualValue

Using AI Code Generation

1package org.assertj.core.api.recursive.comparison;2import java.util.ArrayList;3import java.util.List;4import java.util.Objects;5import java.util.stream.Collectors;6import java.util.stream.Stream;7public class DualValueTest {8    public static void main(String[] args) {9        List<DualValue> dualValues = new ArrayList<>();10        DualValue dualValue = new DualValue("A", "B");11        dualValues.add(dualValue);12        DualValue dualValue1 = DualValue.of("A", "B");13        dualValues.add(dualValue1);14        DualValue dualValue2 = DualValue.of("A", null);15        dualValues.add(dualValue2);16        DualValue dualValue3 = DualValue.of(null, "B");17        dualValues.add(dualValue3);18        DualValue dualValue4 = DualValue.of(null, null);19        dualValues.add(dualValue4);20        DualValue dualValue5 = DualValue.of(null, null);21        dualValues.add(dualValue5);22        DualValue dualValue6 = DualValue.of("A", "B");23        dualValues.add(dualValue6);24        DualValue dualValue7 = DualValue.of(null, null);25        dualValues.add(dualValue7);26        DualValue dualValue8 = DualValue.of(null, null);27        dualValues.add(dualValue8);28        DualValue dualValue9 = DualValue.of(null, null);29        dualValues.add(dualValue9);30        DualValue dualValue10 = DualValue.of(null, null);31        dualValues.add(dualValue10);32        DualValue dualValue11 = DualValue.of(null, null);33        dualValues.add(dualValue11);

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.