{@link org.assertj.core.api.CharArrayAssert#containsExactly(char...)}.
- *
* @author Jean-Christophe Gay
*/
class CharArrayAssert_containsExactly_Test extends CharArrayAssertBaseTest {
@@ -41,7 +39,7 @@ protected void verify_internal_effects() {
@Test
void should_honor_the_given_element_comparator() {
char[] actual = arrayOf('a', 'b');
- assertThat(actual).usingElementComparator(CaseInsensitiveCharacterComparator.instance)
+ assertThat(actual).usingElementComparator(CaseInsensitiveCharacterComparator.INSTANCE)
.containsExactly('a', 'B');
}
}
diff --git a/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingCustomComparator_Test.java b/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingCustomComparator_Test.java
index b4340c45d9..ff0844031a 100644
--- a/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingCustomComparator_Test.java
+++ b/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingCustomComparator_Test.java
@@ -18,7 +18,7 @@
import org.assertj.core.api.CharSequenceAssert;
import org.assertj.core.api.CharSequenceAssertBaseTest;
-import org.assertj.core.util.CaseInsensitiveCharSequenceComparator;
+import org.assertj.core.test.CaseInsensitiveCharSequenceComparator;
/**
* Tests for {@link CharSequenceAssert#usingComparator(Comparator)}.
@@ -30,12 +30,12 @@ class CharSequenceAssert_usingCustomComparator_Test extends CharSequenceAssertBa
@Override
protected CharSequenceAssert invoke_api_method() {
- return assertions.usingComparator(CaseInsensitiveCharSequenceComparator.instance);
+ return assertions.usingComparator(CaseInsensitiveCharSequenceComparator.INSTANCE);
}
@Override
protected void verify_internal_effects() {
- assertThat(CaseInsensitiveCharSequenceComparator.instance).isSameAs(getObjects(assertions).getComparator());
- assertThat(CaseInsensitiveCharSequenceComparator.instance).isSameAs(getStrings(assertions).getComparator());
+ assertThat(CaseInsensitiveCharSequenceComparator.INSTANCE).isSameAs(getObjects(assertions).getComparator());
+ assertThat(CaseInsensitiveCharSequenceComparator.INSTANCE).isSameAs(getStrings(assertions).getComparator());
}
}
diff --git a/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingDefaultComparator_Test.java b/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingDefaultComparator_Test.java
index fe60e7761b..ffddd8aea7 100644
--- a/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingDefaultComparator_Test.java
+++ b/src/test/java/org/assertj/core/api/charsequence/CharSequenceAssert_usingDefaultComparator_Test.java
@@ -18,7 +18,7 @@
import org.assertj.core.api.CharSequenceAssertBaseTest;
import org.assertj.core.internal.Objects;
import org.assertj.core.internal.Strings;
-import org.assertj.core.util.CaseInsensitiveCharSequenceComparator;
+import org.assertj.core.test.CaseInsensitiveCharSequenceComparator;
/**
* Tests for {@link CharSequenceAssert#usingDefaultComparator()}.
@@ -29,7 +29,7 @@ class CharSequenceAssert_usingDefaultComparator_Test extends CharSequenceAssertB
@Override
protected CharSequenceAssert invoke_api_method() {
- return assertions.usingComparator(CaseInsensitiveCharSequenceComparator.instance)
+ return assertions.usingComparator(CaseInsensitiveCharSequenceComparator.INSTANCE)
.usingDefaultComparator();
}
diff --git a/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_Test.java b/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_Test.java
index 18ca9bc2b3..3e66081d82 100644
--- a/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_Test.java
+++ b/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_Test.java
@@ -104,7 +104,7 @@ void extractingResultOf_should_keep_assertion_state() {
"foo")
.usingComparatorForElementFieldsWithType(ALWAYS_EQUALS_TIMESTAMP,
Timestamp.class)
- .usingComparatorForType(CaseInsensitiveStringComparator.instance,
+ .usingComparatorForType(CaseInsensitiveStringComparator.INSTANCE,
String.class)
.extractingResultOf("toString")
.containsOnly("YODA", "darth vader");
@@ -112,7 +112,7 @@ void extractingResultOf_should_keep_assertion_state() {
assertThat(assertion.descriptionText()).isEqualTo("test description");
assertThat(assertion.info.representation()).isEqualTo(UNICODE_REPRESENTATION);
assertThat(assertion.info.overridingErrorMessage()).isEqualTo("error message");
- assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.instance);
+ assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.INSTANCE);
assertThat(comparatorForElementFieldsWithTypeOf(assertion).getComparatorForType(Timestamp.class)).isSameAs(ALWAYS_EQUALS_TIMESTAMP);
assertThat(comparatorForElementFieldsWithNamesOf(assertion).get("foo")).isSameAs(ALWAYS_EQUALS_STRING);
}
@@ -128,7 +128,7 @@ void strongly_typed_extractingResultOf_should_keep_assertion_state() {
"foo")
.usingComparatorForElementFieldsWithType(ALWAYS_EQUALS_TIMESTAMP,
Timestamp.class)
- .usingComparatorForType(CaseInsensitiveStringComparator.instance,
+ .usingComparatorForType(CaseInsensitiveStringComparator.INSTANCE,
String.class)
.extractingResultOf("toString", String.class)
.containsOnly("YODA", "darth vader");
@@ -136,7 +136,7 @@ void strongly_typed_extractingResultOf_should_keep_assertion_state() {
assertThat(assertion.descriptionText()).isEqualTo("test description");
assertThat(assertion.info.representation()).isEqualTo(UNICODE_REPRESENTATION);
assertThat(assertion.info.overridingErrorMessage()).isEqualTo("error message");
- assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.instance);
+ assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.INSTANCE);
assertThat(comparatorForElementFieldsWithTypeOf(assertion).getComparatorForType(Timestamp.class)).isSameAs(ALWAYS_EQUALS_TIMESTAMP);
assertThat(comparatorForElementFieldsWithNamesOf(assertion).get("foo")).isSameAs(ALWAYS_EQUALS_STRING);
}
diff --git a/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_with_SortedSet_Test.java b/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_with_SortedSet_Test.java
index ccd5ecf38d..45b360fd41 100644
--- a/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_with_SortedSet_Test.java
+++ b/src/test/java/org/assertj/core/api/iterable/IterableAssert_extractingResultOf_with_SortedSet_Test.java
@@ -107,14 +107,14 @@ void extractingResultOf_should_keep_assertion_state() {
.usingComparatorForElementFieldsWithType(ALWAYS_EQUALS_TIMESTAMP,
Timestamp.class)
.extractingResultOf("toString")
- .usingComparatorForType(CaseInsensitiveStringComparator.instance,
+ .usingComparatorForType(CaseInsensitiveStringComparator.INSTANCE,
String.class)
.containsOnly("YODA", "darth vader");
// THEN
assertThat(assertion.descriptionText()).isEqualTo("test description");
assertThat(assertion.info.representation()).isEqualTo(UNICODE_REPRESENTATION);
assertThat(assertion.info.overridingErrorMessage()).isEqualTo("error message");
- assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.instance);
+ assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.INSTANCE);
assertThat(comparatorForElementFieldsWithTypeOf(assertion).getComparatorForType(Timestamp.class)).isSameAs(ALWAYS_EQUALS_TIMESTAMP);
assertThat(comparatorForElementFieldsWithNamesOf(assertion).get("foo")).isSameAs(ALWAYS_EQUALS_STRING);
}
@@ -131,14 +131,14 @@ void strongly_typed_extractingResultOf_should_keep_assertion_state() {
.usingComparatorForElementFieldsWithType(ALWAYS_EQUALS_TIMESTAMP,
Timestamp.class)
.extractingResultOf("toString", String.class)
- .usingComparatorForType(CaseInsensitiveStringComparator.instance,
+ .usingComparatorForType(CaseInsensitiveStringComparator.INSTANCE,
String.class)
.containsOnly("YODA", "darth vader");
// THEN
assertThat(assertion.descriptionText()).isEqualTo("test description");
assertThat(assertion.info.representation()).isEqualTo(UNICODE_REPRESENTATION);
assertThat(assertion.info.overridingErrorMessage()).isEqualTo("error message");
- assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.instance);
+ assertThat(comparatorsByTypeOf(assertion).getComparatorForType(String.class)).isSameAs(CaseInsensitiveStringComparator.INSTANCE);
assertThat(comparatorForElementFieldsWithTypeOf(assertion).getComparatorForType(Timestamp.class)).isSameAs(ALWAYS_EQUALS_TIMESTAMP);
assertThat(comparatorForElementFieldsWithNamesOf(assertion).get("foo")).isSameAs(ALWAYS_EQUALS_STRING);
}
diff --git a/src/test/java/org/assertj/core/api/iterable/IterableAssert_filteredOnAssertions_ThrowingConsumer_Test.java b/src/test/java/org/assertj/core/api/iterable/IterableAssert_filteredOnAssertions_ThrowingConsumer_Test.java
index 8fcd4bc8b2..1c7d5c8ae0 100644
--- a/src/test/java/org/assertj/core/api/iterable/IterableAssert_filteredOnAssertions_ThrowingConsumer_Test.java
+++ b/src/test/java/org/assertj/core/api/iterable/IterableAssert_filteredOnAssertions_ThrowingConsumer_Test.java
@@ -125,7 +125,7 @@ void should_keep_assertion_state() {
IterableAssert{@link Strings#assertContainsIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- *
* @author Alex Ruiz
* @author Joel Costigliola
*/
@@ -35,59 +32,88 @@ class Strings_assertContainsIgnoringCase_Test extends StringsBaseTest {
@Test
void should_fail_if_actual_does_not_contain_sequence() {
- assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsIgnoringCase(someInfo(), "Yoda", "Luke"))
- .withMessage(shouldContainIgnoringCase("Yoda", "Luke").create());
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertContainsIgnoringCase(someInfo(), "Yoda", "Luke"));
+ // THEN
+ then(assertionError).hasMessage(shouldContainIgnoringCase("Yoda", "Luke").create());
}
@Test
void should_throw_error_if_sequence_is_null() {
- assertThatNullPointerException().isThrownBy(() -> strings.assertContainsIgnoringCase(someInfo(), "Yoda", null))
- .withMessage(charSequenceToLookForIsNull());
+ // WHEN
+ NullPointerException exception = catchNullPointerException(() -> strings.assertContainsIgnoringCase(someInfo(), "Yoda",
+ null));
+ // THEN
+ then(exception).hasMessage(charSequenceToLookForIsNull());
}
@Test
void should_fail_if_actual_is_null() {
- assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsIgnoringCase(someInfo(), null, "Yoda"))
- .withMessage(actualIsNull());
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertContainsIgnoringCase(someInfo(), null, "Yoda"));
+ // THEN
+ then(assertionError).hasMessage(actualIsNull());
}
@Test
void should_pass_if_actual_contains_sequence() {
+ // WHEN/THEN
strings.assertContainsIgnoringCase(someInfo(), "Yoda", "Yo");
}
@Test
void should_pass_if_actual_contains_sequence_in_different_case() {
+ // WHEN/THEN
strings.assertContainsIgnoringCase(someInfo(), "Yoda", "yo");
}
@Test
void should_fail_if_actual_does_not_contain_sequence_whatever_custom_comparison_strategy_is() {
- assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(), "Yoda", "Luke"))
- .withMessage(shouldContainIgnoringCase("Yoda", "Luke").create());
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(),
+ "Yoda",
+ "Luke"));
+ // THEN
+ then(assertionError).hasMessage(shouldContainIgnoringCase("Yoda", "Luke").create());
}
@Test
void should_throw_error_if_sequence_is_null_whatever_custom_comparison_strategy_is() {
- assertThatNullPointerException().isThrownBy(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(),
- "Yoda",
- null))
- .withMessage(charSequenceToLookForIsNull());
+ // WHEN
+ NullPointerException exception = catchNullPointerException(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(),
+ "Yoda",
+ null));
+ // THEN
+ then(exception).hasMessage(charSequenceToLookForIsNull());
}
@Test
void should_fail_if_actual_is_null_whatever_custom_comparison_strategy_is() {
- assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(), null, "Yoda"))
- .withMessage(actualIsNull());
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(),
+ null,
+ "Yoda"));
+ // THEN
+ then(assertionError).hasMessage(actualIsNull());
}
@Test
void should_pass_if_actual_contains_sequence_whatever_custom_comparison_strategy_is() {
+ // WHEN/THEN
stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(), "Yoda", "Yo");
}
@Test
void should_pass_if_actual_contains_sequence_in_different_case_whatever_custom_comparison_strategy_is() {
+ // WHEN/THEN
stringsWithCaseInsensitiveComparisonStrategy.assertContainsIgnoringCase(someInfo(), "Yoda", "yo");
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_pass_with_Turkish_default_locale() {
+ // WHEN/THEN
+ strings.assertContainsIgnoringCase(someInfo(), "Leia", "IA");
+ }
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotContainIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotContainIgnoringCase_Test.java
index 37793f0c66..f1361ca2fd 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotContainIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotContainIgnoringCase_Test.java
@@ -12,39 +12,37 @@
*/
package org.assertj.core.internal.strings;
-import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.assertj.core.api.Assertions.catchNullPointerException;
import static org.assertj.core.api.BDDAssertions.then;
import static org.assertj.core.api.BDDAssertions.thenIllegalArgumentException;
import static org.assertj.core.error.ShouldNotContainCharSequence.shouldNotContainIgnoringCase;
import static org.assertj.core.internal.ErrorMessages.arrayOfValuesToLookForIsEmpty;
import static org.assertj.core.internal.ErrorMessages.valuesToLookForIsNull;
import static org.assertj.core.test.TestData.someInfo;
+import static org.assertj.core.util.Arrays.array;
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.assertj.core.util.FailureMessages.actualIsNull;
-import static org.mockito.internal.util.collections.Sets.newSet;
+import static org.assertj.core.util.Sets.set;
-import org.assertj.core.api.AssertionInfo;
-import org.assertj.core.internal.Strings;
import org.assertj.core.internal.StringsBaseTest;
-import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
/**
- * Tests for {@link Strings#assertDoesNotContainIgnoringCase(AssertionInfo, CharSequence, CharSequence...)}.
- *
* @author Brummolix
*/
-@DisplayName("Strings assertDoesNotContainIgnoringCase")
class Strings_assertDoesNotContainIgnoringCase_Test extends StringsBaseTest {
@Test
void should_pass_if_actual_does_not_contain_value_ignoring_case() {
- assertDoesNotContainIgnoringCase("Yoda", "no");
+ // WHEN/THEN
+ strings.assertDoesNotContainIgnoringCase(someInfo(), "Yoda", "no");
}
@Test
void should_pass_if_actual_does_not_contain_values_ignoring_case() {
- assertDoesNotContainIgnoringCase("Yoda", "no", "also no");
+ // WHEN/THEN
+ strings.assertDoesNotContainIgnoringCase(someInfo(), "Yoda", "no", "also no");
}
@Test
@@ -52,7 +50,8 @@ void should_fail_if_actual_contains_value() {
// GIVEN
String actual = "Yoda";
// WHEN
- AssertionError assertionError = expectAssertionError(() -> assertDoesNotContainIgnoringCase(actual, "od"));
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), actual,
+ "od"));
// THEN
then(assertionError).hasMessage(shouldNotContainIgnoringCase(actual, "od").create());
}
@@ -62,7 +61,8 @@ void should_fail_if_actual_contains_value_with_different_case() {
// GIVEN
String actual = "Yoda";
// WHEN
- AssertionError assertionError = expectAssertionError(() -> assertDoesNotContainIgnoringCase(actual, "OD"));
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), actual,
+ "OD"));
// THEN
then(assertionError).hasMessage(shouldNotContainIgnoringCase(actual, "OD").create());
}
@@ -72,10 +72,10 @@ void should_fail_if_actual_contains_one_of_several_values() {
// GIVEN
String actual = "Yoda";
// WHEN
- AssertionError assertionError = expectAssertionError(() -> assertDoesNotContainIgnoringCase(actual, "od", "Yo", "Luke"));
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), actual, "od",
+ "Yo", "Luke"));
// THEN
- String message = shouldNotContainIgnoringCase(actual, new CharSequence[] { "od", "Yo", "Luke" }, newSet("od", "Yo")).create();
- then(assertionError).hasMessage(message);
+ then(assertionError).hasMessage(shouldNotContainIgnoringCase(actual, array("od", "Yo", "Luke"), set("od", "Yo")).create());
}
@Test
@@ -83,10 +83,10 @@ void should_fail_if_actual_contains_one_of_several_values_with_different_case()
// GIVEN
String actual = "Yoda";
// WHEN
- AssertionError assertionError = expectAssertionError(() -> assertDoesNotContainIgnoringCase(actual, "OD", "yo", "Luke"));
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), actual, "OD",
+ "yo", "Luke"));
// THEN
- String message = shouldNotContainIgnoringCase(actual, new CharSequence[] { "OD", "yo", "Luke" }, newSet("OD", "yo")).create();
- then(assertionError).hasMessage(message);
+ then(assertionError).hasMessage(shouldNotContainIgnoringCase(actual, array("OD", "yo", "Luke"), set("OD", "yo")).create());
}
@Test
@@ -94,10 +94,10 @@ void should_fail_if_values_are_null() {
// GIVEN
CharSequence[] values = null;
// WHEN
- Throwable npe = catchThrowable(() -> assertDoesNotContainIgnoringCase("Yoda", values));
+ NullPointerException exception = catchNullPointerException(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), "Yoda",
+ values));
// THEN
- then(npe).isInstanceOf(NullPointerException.class)
- .hasMessage(valuesToLookForIsNull());
+ then(exception).hasMessage(valuesToLookForIsNull());
}
@Test
@@ -105,14 +105,15 @@ void should_fail_if_actual_is_null() {
// GIVEN
String actual = null;
// WHEN
- AssertionError assertionError = expectAssertionError(() -> assertDoesNotContainIgnoringCase(actual, "Yoda"));
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), actual,
+ "Yoda"));
// THEN
then(assertionError).hasMessage(actualIsNull());
}
@Test
void should_throw_error_if_values_are_empty() {
- thenIllegalArgumentException().isThrownBy(() -> assertDoesNotContainIgnoringCase("Yoda"))
+ thenIllegalArgumentException().isThrownBy(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), "Yoda"))
.withMessage(arrayOfValuesToLookForIsEmpty());
}
@@ -121,13 +122,19 @@ void should_throw_error_if_values_contains_null() {
// GIVEN
CharSequence[] values = new CharSequence[] { "1", null };
// WHEN
- Throwable npe = catchThrowable(() -> assertDoesNotContainIgnoringCase("Yoda", values));
+ NullPointerException exception = catchNullPointerException(() -> strings.assertDoesNotContainIgnoringCase(someInfo(), "Yoda",
+ values));
// THEN
- then(npe).isInstanceOf(NullPointerException.class)
- .hasMessage("Expecting CharSequence elements not to be null but found one at index 1");
+ then(exception).hasMessage("Expecting CharSequence elements not to be null but found one at index 1");
}
- private void assertDoesNotContainIgnoringCase(CharSequence actual, CharSequence... values) {
- strings.assertDoesNotContainIgnoringCase(someInfo(), actual, values);
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_fail_with_Turkish_default_locale() {
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotContainIgnoringCase(INFO, "Leia", "EI"));
+ // THEN
+ then(assertionError).hasMessage(shouldNotContainIgnoringCase("Leia", "EI").create());
}
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotEndWithIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotEndWithIgnoringCase_Test.java
index 6c5961e7dd..216742b7ab 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotEndWithIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotEndWithIgnoringCase_Test.java
@@ -18,7 +18,6 @@
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.assertj.core.util.FailureMessages.actualIsNull;
-import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.ComparatorBasedComparisonStrategy;
import org.assertj.core.internal.ComparisonStrategy;
import org.assertj.core.internal.StandardComparisonStrategy;
@@ -26,11 +25,9 @@
import org.assertj.core.internal.StringsBaseTest;
import org.assertj.core.util.StringHashCodeTestComparator;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
-/**
- * Tests for {@link Strings#assertDoesNotEndWithIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- */
-class Strings_assertDoesNotEndWithIgnoringCaseIgnoringCase_Test extends StringsBaseTest {
+class Strings_assertDoesNotEndWithIgnoringCase_Test extends StringsBaseTest {
@Test
void should_pass_if_actual_does_not_end_with_suffix() {
@@ -78,4 +75,14 @@ void should_fail_if_actual_ends_with_suffix_according_to_custom_comparison_strat
// THEN
then(assertionError).hasMessage(shouldNotEndWithIgnoringCase("Yoda", "A", hashCodeComparisonStrategy).create());
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_fail_with_Turkish_default_locale() {
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotEndWithIgnoringCase(INFO, "Leia", "IA"));
+ // THEN
+ then(assertionError).hasMessage(shouldNotEndWithIgnoringCase("Leia", "IA", StandardComparisonStrategy.instance()).create());
+ }
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotStartWithIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotStartWithIgnoringCase_Test.java
index 70d6ac2b72..a18bc90bd6 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotStartWithIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertDoesNotStartWithIgnoringCase_Test.java
@@ -18,7 +18,6 @@
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.assertj.core.util.FailureMessages.actualIsNull;
-import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.ComparatorBasedComparisonStrategy;
import org.assertj.core.internal.ComparisonStrategy;
import org.assertj.core.internal.StandardComparisonStrategy;
@@ -26,10 +25,8 @@
import org.assertj.core.internal.StringsBaseTest;
import org.assertj.core.util.StringHashCodeTestComparator;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
-/**
- * Tests for {@link Strings#assertDoesNotStartWithIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- */
class Strings_assertDoesNotStartWithIgnoringCase_Test extends StringsBaseTest {
@Test
@@ -42,7 +39,7 @@ void should_pass_if_actual_does_not_start_with_prefix() {
void should_fail_if_actual_starts_with_prefix() {
// WHEN
AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotStartWithIgnoringCase(INFO, "Yoda", "yo"));
- //THEN
+ // THEN
then(assertionError).hasMessage(shouldNotStartWithIgnoringCase("Yoda", "yo", StandardComparisonStrategy.instance()).create());
}
@@ -76,6 +73,17 @@ void should_fail_if_actual_starts_with_prefix_according_to_custom_comparison_str
// WHEN
AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotStartWithIgnoringCase(INFO, "Yoda", "yODA"));
// THEN
- then(assertionError).hasMessageContainingAll(shouldNotStartWithIgnoringCase("Yoda", "yODA", hashCodeComparisonStrategy).create());
+ then(assertionError).hasMessageContainingAll(shouldNotStartWithIgnoringCase("Yoda", "yODA",
+ hashCodeComparisonStrategy).create());
+ }
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_fail_with_Turkish_default_locale() {
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertDoesNotStartWithIgnoringCase(INFO, "Leia", "LEI"));
+ // THEN
+ then(assertionError).hasMessage(shouldNotStartWithIgnoringCase("Leia", "LEI", StandardComparisonStrategy.instance()).create());
}
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertEndsWithIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertEndsWithIgnoringCase_Test.java
index 169cb990bb..58a1b920d9 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertEndsWithIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertEndsWithIgnoringCase_Test.java
@@ -15,10 +15,10 @@
import static org.assertj.core.api.Assertions.assertThatNullPointerException;
import static org.assertj.core.api.BDDAssertions.then;
import static org.assertj.core.error.ShouldEndWithIgnoringCase.shouldEndWithIgnoringCase;
+import static org.assertj.core.test.TestData.someInfo;
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.assertj.core.util.FailureMessages.actualIsNull;
-import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.ComparatorBasedComparisonStrategy;
import org.assertj.core.internal.ComparisonStrategy;
import org.assertj.core.internal.StandardComparisonStrategy;
@@ -26,10 +26,8 @@
import org.assertj.core.internal.StringsBaseTest;
import org.assertj.core.util.StringHashCodeTestComparator;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
-/**
- * Tests for {@link Strings#assertEndsWithIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- */
class Strings_assertEndsWithIgnoringCase_Test extends StringsBaseTest {
@Test
@@ -84,4 +82,12 @@ void should_fail_if_actual_does_not_end_with_suffix_according_to_custom_comparis
// THEN
then(assertionError).hasMessage(shouldEndWithIgnoringCase("Yoda", "Luke", hashCodeComparisonStrategy).create());
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_pass_with_Turkish_default_locale() {
+ // WHEN/THEN
+ strings.assertEndsWithIgnoringCase(someInfo(), "Leia", "IA");
+ }
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertEqualsIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertEqualsIgnoringCase_Test.java
index dd5def5e9d..80f87dc5e6 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertEqualsIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertEqualsIgnoringCase_Test.java
@@ -17,15 +17,11 @@
import static org.assertj.core.test.CharArrays.arrayOf;
import static org.assertj.core.test.TestData.someInfo;
-import org.assertj.core.api.AssertionInfo;
-import org.assertj.core.internal.Strings;
import org.assertj.core.internal.StringsBaseTest;
import org.junit.jupiter.api.Test;
-
+import org.junitpioneer.jupiter.DefaultLocale;
/**
- * Tests for {@link Strings#assertEqualsIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- *
* @author Alex Ruiz
* @author Joel Costigliola
*/
@@ -103,4 +99,12 @@ void should_pass_if_both_Strings_are_equal_but_not_same_whatever_custom_comparis
void should_pass_if_both_Strings_are_equal_ignoring_case_whatever_custom_comparison_strategy_is() {
stringsWithCaseInsensitiveComparisonStrategy.assertEqualsIgnoringCase(someInfo(), "Yoda", "YODA");
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_pass_with_Turkish_default_locale() {
+ // WHEN/THEN
+ strings.assertEqualsIgnoringCase(someInfo(), "Leia", "LEIA");
+ }
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertNotEqualsIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertNotEqualsIgnoringCase_Test.java
index 8aa6ff735f..4cc65be840 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertNotEqualsIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertNotEqualsIgnoringCase_Test.java
@@ -15,20 +15,19 @@
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.assertj.core.api.BDDAssertions.then;
import static org.assertj.core.error.ShouldNotBeEqualIgnoringCase.shouldNotBeEqualIgnoringCase;
import static org.assertj.core.test.CharArrays.arrayOf;
import static org.assertj.core.test.TestData.someInfo;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.mockito.Mockito.verify;
import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.StringsBaseTest;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
/**
- * Tests for
- * {@link org.assertj.core.internal.Strings#assertNotEqualsIgnoringCase(org.assertj.core.api.AssertionInfo, CharSequence, CharSequence)}
- * .
- *
* @author Alexander Bischof
*/
class Strings_assertNotEqualsIgnoringCase_Test extends StringsBaseTest {
@@ -127,4 +126,14 @@ void should_fail_if_both_Strings_are_equal_ignoring_case_whatever_custom_compari
assertThat(error).isInstanceOf(AssertionError.class);
verifyFailureThrownWhenStringsAreNotEqual(info, "Yoda", "YODA");
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_fail_with_Turkish_default_locale() {
+ // WHEN
+ AssertionError assertionError = expectAssertionError(() -> strings.assertNotEqualsIgnoringCase(INFO, "Leia", "LEIA"));
+ // THEN
+ then(assertionError).hasMessage(shouldNotBeEqualIgnoringCase("Leia", "LEIA").create());
+ }
+
}
diff --git a/src/test/java/org/assertj/core/internal/strings/Strings_assertStartsWithIgnoringCase_Test.java b/src/test/java/org/assertj/core/internal/strings/Strings_assertStartsWithIgnoringCase_Test.java
index cbe1fd2fa3..25e4b4d96a 100644
--- a/src/test/java/org/assertj/core/internal/strings/Strings_assertStartsWithIgnoringCase_Test.java
+++ b/src/test/java/org/assertj/core/internal/strings/Strings_assertStartsWithIgnoringCase_Test.java
@@ -18,7 +18,6 @@
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
import static org.assertj.core.util.FailureMessages.actualIsNull;
-import org.assertj.core.api.AssertionInfo;
import org.assertj.core.internal.ComparatorBasedComparisonStrategy;
import org.assertj.core.internal.ComparisonStrategy;
import org.assertj.core.internal.StandardComparisonStrategy;
@@ -26,10 +25,8 @@
import org.assertj.core.internal.StringsBaseTest;
import org.assertj.core.util.StringHashCodeTestComparator;
import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
-/**
- * Tests for {@link Strings#assertStartsWithIgnoringCase(AssertionInfo, CharSequence, CharSequence)}.
- */
class Strings_assertStartsWithIgnoringCase_Test extends StringsBaseTest {
@Test
@@ -82,4 +79,12 @@ void should_fail_if_actual_does_not_start_with_prefix_according_to_custom_compar
// THEN
then(assertionError).hasMessage(shouldStartWithIgnoringCase("Yoda", "Luke", hashCodeComparisonStrategy).create());
}
+
+ @Test
+ @DefaultLocale("tr-TR")
+ void should_pass_with_Turkish_default_locale() {
+ // WHEN/THEN
+ strings.assertStartsWithIgnoringCase(INFO, "Leia", "LEI");
+ }
+
}
diff --git a/src/test/java/org/assertj/core/osgi/AssumptionsTest.java b/src/test/java/org/assertj/core/osgi/AssumptionsTest.java
index 032fc1b48a..4eefdeea77 100644
--- a/src/test/java/org/assertj/core/osgi/AssumptionsTest.java
+++ b/src/test/java/org/assertj/core/osgi/AssumptionsTest.java
@@ -20,11 +20,11 @@
import org.assertj.core.api.Assumptions;
import org.assertj.core.configuration.PreferredAssumptionException;
+import org.assertj.core.test.MutatesGlobalConfiguration;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.parallel.Isolated;
import org.opentest4j.TestAbortedException;
-@Isolated // Isolated as the preferred assumption class is mutated globally here.
+@MutatesGlobalConfiguration
class AssumptionsTest {
@Test
diff --git a/src/test/java/org/assertj/core/presentation/StandardRepresentation_throwable_format_Test.java b/src/test/java/org/assertj/core/presentation/StandardRepresentation_throwable_format_Test.java
index fed27510dd..c508135a67 100644
--- a/src/test/java/org/assertj/core/presentation/StandardRepresentation_throwable_format_Test.java
+++ b/src/test/java/org/assertj/core/presentation/StandardRepresentation_throwable_format_Test.java
@@ -20,7 +20,7 @@
import static org.mockito.Mockito.when;
import org.assertj.core.configuration.Configuration;
-import org.junit.jupiter.api.AfterEach;
+import org.assertj.core.test.MutatesGlobalConfiguration;
import org.junit.jupiter.api.Test;
/**
@@ -28,6 +28,7 @@
*
* @author XiaoMingZHM Eveneko
*/
+@MutatesGlobalConfiguration
class StandardRepresentation_throwable_format_Test {
private static final Representation REPRESENTATION = new StandardRepresentation();
@@ -46,12 +47,6 @@ static void boom() {
}
}
- @AfterEach
- void afterEach() {
- // Restore default configuration after each test
- DEFAULT_CONFIGURATION.apply();
- }
-
@Test
void should_not_display_stacktrace_if_maxStackTraceElementsDisplayed_is_zero() {
// GIVEN
diff --git a/src/test/java/org/assertj/core/util/CaseInsensitiveCharSequenceComparator.java b/src/test/java/org/assertj/core/test/CaseInsensitiveCharSequenceComparator.java
similarity index 76%
rename from src/test/java/org/assertj/core/util/CaseInsensitiveCharSequenceComparator.java
rename to src/test/java/org/assertj/core/test/CaseInsensitiveCharSequenceComparator.java
index f822bf85de..3ff95b608a 100644
--- a/src/test/java/org/assertj/core/util/CaseInsensitiveCharSequenceComparator.java
+++ b/src/test/java/org/assertj/core/test/CaseInsensitiveCharSequenceComparator.java
@@ -10,22 +10,20 @@
*
* Copyright 2012-2022 the original author or authors.
*/
-package org.assertj.core.util;
+package org.assertj.core.test;
import java.util.Comparator;
-import org.assertj.core.test.CaseInsensitiveStringComparator;
-
/**
* @author Mikhail Mazursky
*/
public class CaseInsensitiveCharSequenceComparator implements ComparatorBy using this annotation, any tests that mutate this configuration will have the configuration + * reset to the default values after each test case runs. + * + * @author Ashley Scopes + */ +@ExtendWith(AssumptionMutatingExtension.class) +@Isolated("Mutates global state") +@Target(ElementType.TYPE) +public @interface MutatesGlobalConfiguration { + + final class AssumptionMutatingExtension implements AfterEachCallback, AfterAllCallback { + + @Override + public void afterEach(ExtensionContext context) { + resetAll(); + } + + @Override + public void afterAll(ExtensionContext context) { + resetAll(); + } + + private void resetAll() { + ConfigurationProvider.CONFIGURATION_PROVIDER.configuration().setDefaults(); + } + } +}