diff options
Diffstat (limited to 'hamcrest-core/src/test')
27 files changed, 1448 insertions, 0 deletions
diff --git a/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java new file mode 100644 index 0000000..22f823b --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java @@ -0,0 +1,77 @@ +package org.hamcrest; + +import junit.framework.TestCase; +import org.junit.Assert; + +public abstract class AbstractMatcherTest extends TestCase { + + /** + * Create an instance of the Matcher so some generic safety-net tests can be run on it. + */ + protected abstract Matcher<?> createMatcher(); + + public static <T> void assertMatches(Matcher<T> matcher, T arg) { + assertMatches("Expected match, but mismatched", matcher, arg); + } + + public static <T> void assertMatches(String message, Matcher<T> matcher, T arg) { + if (!matcher.matches(arg)) { + Assert.fail(message + " because: '" + mismatchDescription(matcher, arg) + "'"); + } + } + + public static <T> void assertDoesNotMatch(Matcher<? super T> c, T arg) { + assertDoesNotMatch("Unexpected match", c, arg); + } + + public static <T> void assertDoesNotMatch(String message, Matcher<? super T> c, T arg) { + Assert.assertFalse(message, c.matches(arg)); + } + + public static void assertDescription(String expected, Matcher<?> matcher) { + Description description = new StringDescription(); + description.appendDescriptionOf(matcher); + Assert.assertEquals("Expected description", expected, description.toString().trim()); + } + + public static <T> void assertMismatchDescription(String expected, Matcher<? super T> matcher, T arg) { + Assert.assertFalse("Precondition: Matcher should not match item.", matcher.matches(arg)); + Assert.assertEquals("Expected mismatch description", expected, mismatchDescription(matcher, arg)); + } + + public static void assertNullSafe(Matcher<?> matcher) { + try { + matcher.matches(null); + } + catch (Exception e) { + Assert.fail("Matcher was not null safe"); + } + } + + public static void assertUnknownTypeSafe(Matcher<?> matcher) { + try { + matcher.matches(new UnknownType()); + } + catch (Exception e) { + Assert.fail("Matcher was not unknown type safe"); + } + } + + public static <T> String mismatchDescription(Matcher<? super T> matcher, T arg) { + Description description = new StringDescription(); + matcher.describeMismatch(arg, description); + return description.toString().trim(); + } + + public void testIsNullSafe() { + assertNullSafe(createMatcher()); + } + + public void testCopesWithUnknownTypes() { + assertUnknownTypeSafe(createMatcher()); + } + + public static class UnknownType { + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java b/hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java new file mode 100644 index 0000000..8b70725 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java @@ -0,0 +1,78 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public final class BaseDescriptionTest { + + private final StringBuilder result = new StringBuilder(); + + private final BaseDescription baseDescription = new BaseDescription() { + @Override protected void append(char c) { + result.append(c); + } + }; + + @Test public void + describesAppendedNullValue() { + baseDescription.appendValue(null); + assertEquals("null", result.toString()); + } + + @Test public void + quotesAppendedStringValue() { + baseDescription.appendValue("foo"); + assertEquals("\"foo\"", result.toString()); + } + + @Test public void + quotesAppendedCharacterValue() { + baseDescription.appendValue('f'); + assertEquals("\"f\"", result.toString()); + } + + @Test public void + bracketsAppendedShortValue() { + baseDescription.appendValue(Short.valueOf("2")); + assertEquals("<2s>", result.toString()); + } + + @Test public void + bracketsAppendedLongValue() { + baseDescription.appendValue(Long.valueOf("2")); + assertEquals("<2L>", result.toString()); + } + + @Test public void + bracketsAppendedFloatValue() { + baseDescription.appendValue(Float.valueOf("1.2")); + assertEquals("<1.2F>", result.toString()); + } + + @Test public void + describesAppendedArrayValue() { + baseDescription.appendValue(new String[] {"2", "3"}); + assertEquals("[\"2\", \"3\"]", result.toString()); + } + + @Test public void + bracketsAppendedObjectValue() { + final Object value = new Object(); + baseDescription.appendValue(value); + assertEquals("<" + value.toString() + ">", result.toString()); + } + + @Test public void + safelyDescribesAppendedValueOfObjectWhoseToStringThrowsAnException() { + final Object value = new Object() { + @Override public String toString() { + throw new UnsupportedOperationException(); + } + }; + + final String expected = value.getClass().getName() + "@" + Integer.toHexString(value.hashCode()); + baseDescription.appendValue(value); + assertEquals("<" + expected + ">", result.toString()); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/BaseMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/BaseMatcherTest.java new file mode 100644 index 0000000..e663f04 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/BaseMatcherTest.java @@ -0,0 +1,26 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public final class BaseMatcherTest { + + @Test + public void + describesItselfWithToStringMethod() { + Matcher<Object> someMatcher = new BaseMatcher<Object>() { + @Override + public boolean matches(Object item) { + throw new UnsupportedOperationException(); + } + + @Override + public void describeTo(Description description) { + description.appendText("SOME DESCRIPTION"); + } + }; + + assertEquals("SOME DESCRIPTION", someMatcher.toString()); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java new file mode 100644 index 0000000..08649f7 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java @@ -0,0 +1,20 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.assertDescription; + +public final class CustomMatcherTest { + + @Test public void + usesStaticDescription() throws Exception { + Matcher<String> matcher = new CustomMatcher<String>("I match strings") { + @Override + public boolean matches(Object item) { + return (item instanceof String); + } + }; + + assertDescription("I match strings", matcher); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java new file mode 100644 index 0000000..2c86712 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java @@ -0,0 +1,41 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; + +public final class CustomTypeSafeMatcherTest { + private static final String STATIC_DESCRIPTION = "I match non empty strings"; + + private final Matcher<String> customMatcher = new CustomTypeSafeMatcher<String>(STATIC_DESCRIPTION) { + @Override + public boolean matchesSafely(String item) { + return false; + } + + @Override + public void describeMismatchSafely(String item, Description mismatchDescription) { + mismatchDescription.appendText("an " + item); + } + }; + + @Test public void + usesStaticDescription() throws Exception { + assertDescription(STATIC_DESCRIPTION, customMatcher); + } + + @Test public void + reportsMismatch() { + assertMismatchDescription("an item", customMatcher, "item"); + } + + @Test public void + isNullSafe() { + assertNullSafe(customMatcher); + } + + @Test public void + copesWithUnknownTypes() { + assertUnknownTypeSafe(customMatcher); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java new file mode 100644 index 0000000..f0cbdd5 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java @@ -0,0 +1,68 @@ +package org.hamcrest; + +import org.hamcrest.core.IsEqual; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.junit.Assert.assertEquals; + +public final class FeatureMatcherTest { + private final FeatureMatcher<Thingy, String> resultMatcher = resultMatcher(); + + @Test public void + matchesPartOfAnObject() { + assertMatches("feature", resultMatcher, new Thingy("bar")); + assertDescription("Thingy with result \"bar\"", resultMatcher); + } + + @Test public void + mismatchesPartOfAnObject() { + assertMismatchDescription("result mismatch-description", resultMatcher, new Thingy("foo")); + } + + @Test public void + doesNotThrowNullPointerException() { + assertMismatchDescription("was null", resultMatcher, null); + } + + @Test public void + doesNotThrowClassCastException() { + resultMatcher.matches(new ShouldNotMatch()); + StringDescription mismatchDescription = new StringDescription(); + resultMatcher.describeMismatch(new ShouldNotMatch(), mismatchDescription); + assertEquals("was <ShouldNotMatch>", mismatchDescription.toString()); + } + + public static class Match extends IsEqual<String> { + public Match(String equalArg) { super(equalArg); } + @Override public void describeMismatch(Object item, Description description) { + description.appendText("mismatch-description"); + } + } + + public static class Thingy { + private final String result; + + public Thingy(String result) { + this.result = result; + } + + public String getResult() { + return result; + } + } + + public static class ShouldNotMatch { + @Override public String toString() { return "ShouldNotMatch"; } + } + + private static FeatureMatcher<Thingy, String> resultMatcher() { + return new FeatureMatcher<Thingy, String>(new Match("bar"), "Thingy with result", "result") { + @Override + public String featureValueOf(Thingy actual) { + return actual.getResult(); + } + }; + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java b/hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java new file mode 100644 index 0000000..b57c4d7 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java @@ -0,0 +1,96 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.junit.Assert.*; + +public final class MatcherAssertTest { + + @Test public void + includesDescriptionOfTestedValueInErrorMessage() { + String expected = "expected"; + String actual = "actual"; + + String expectedMessage = "identifier\nExpected: \"expected\"\n but: was \"actual\""; + + try { + assertThat("identifier", actual, equalTo(expected)); + } + catch (AssertionError e) { + assertTrue(e.getMessage().startsWith(expectedMessage)); + return; + } + + fail("should have failed"); + } + + @Test public void + descriptionCanBeElided() { + String expected = "expected"; + String actual = "actual"; + + String expectedMessage = "\nExpected: \"expected\"\n but: was \"actual\""; + + try { + assertThat(actual, equalTo(expected)); + } + catch (AssertionError e) { + assertTrue(e.getMessage().startsWith(expectedMessage)); + return; + } + + fail("should have failed"); + } + + @Test public void + canTestBooleanDirectly() { + assertThat("success reason message", true); + + try { + assertThat("failing reason message", false); + } + catch (AssertionError e) { + assertEquals("failing reason message", e.getMessage()); + return; + } + + fail("should have failed"); + } + + @Test public void + includesMismatchDescription() { + Matcher<String> matcherWithCustomMismatchDescription = new BaseMatcher<String>() { + @Override + public boolean matches(Object item) { + return false; + } + + @Override + public void describeTo(Description description) { + description.appendText("Something cool"); + } + + @Override + public void describeMismatch(Object item, Description mismatchDescription) { + mismatchDescription.appendText("Not cool"); + } + }; + + String expectedMessage = "\nExpected: Something cool\n but: Not cool"; + + try { + assertThat("Value", matcherWithCustomMismatchDescription); + fail("should have failed"); + } + catch (AssertionError e) { + assertEquals(expectedMessage, e.getMessage()); + } + } + + @Test public void + canAssertSubtypes() { + assertThat(1, equalTo((Number) 1)); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java b/hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java new file mode 100644 index 0000000..cccece0 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java @@ -0,0 +1,18 @@ +package org.hamcrest; + +import org.hamcrest.Description.NullDescription; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public final class NullDescriptionTest { + + private final NullDescription nullDescription = new Description.NullDescription(); + + @Test public void + isUnchangedByAppendedText() { + nullDescription.appendText("myText"); + assertEquals("", nullDescription.toString()); + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java new file mode 100644 index 0000000..e23bab8 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java @@ -0,0 +1,40 @@ +package org.hamcrest; + +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.assertMismatchDescription; +import static org.junit.Assert.assertFalse; + +public final class TypeSafeMatcherTest { + private final Matcher<String> matcher = new TypeSafeMatcherSubclass(); + + public static class TypeSafeMatcherSubclass extends TypeSafeMatcher<String> { + @Override + public boolean matchesSafely(String item) { + return false; + } + + @Override + public void describeMismatchSafely(String item, Description mismatchDescription) { + mismatchDescription.appendText("The mismatch"); + } + + @Override + public void describeTo(Description description) { + } + } + + @Test public void + canDetermineMatcherTypeFromProtectedMatchesSafelyMethod() { + assertFalse(matcher.matches(null)); + assertFalse(matcher.matches(10)); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test public void + describesMismatches() { + assertMismatchDescription("was null", matcher, null); + assertMismatchDescription("was a java.lang.Integer (<3>)", (Matcher)matcher, 3); + assertMismatchDescription("The mismatch", matcher, "a string"); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java new file mode 100644 index 0000000..4815002 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java @@ -0,0 +1,63 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.AllOf.allOf; +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsNull.notNullValue; +import static org.hamcrest.core.StringEndsWith.endsWith; +import static org.hamcrest.core.StringStartsWith.startsWith; + +public final class AllOfTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<String> matcher = allOf(equalTo("irrelevant"), startsWith("irr")); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + evaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() { + Matcher<String> matcher = allOf(startsWith("goo"), endsWith("ood")); + + assertMatches("didn't pass both sub-matchers", matcher, "good"); + assertDoesNotMatch("didn't fail first sub-matcher", matcher, "mood"); + assertDoesNotMatch("didn't fail second sub-matcher", matcher, "goon"); + assertDoesNotMatch("didn't fail both sub-matchers", matcher, "fred"); + } + + @Test public void + evaluatesToTheTheLogicalConjunctionOfManyOtherMatchers() { + Matcher<String> matcher = allOf(startsWith("g"), startsWith("go"), endsWith("d"), startsWith("go"), startsWith("goo")); + + assertMatches("didn't pass all sub-matchers", matcher, "good"); + assertDoesNotMatch("didn't fail middle sub-matcher", matcher, "goon"); + } + + @Test public void + supportsMixedTypes() { + final Matcher<SampleSubClass> matcher = allOf( + equalTo(new SampleBaseClass("bad")), + is(notNullValue()), + equalTo(new SampleBaseClass("good")), + equalTo(new SampleSubClass("ugly"))); + + assertDoesNotMatch("didn't fail last sub-matcher", matcher, new SampleSubClass("good")); + } + + @Test public void + hasAReadableDescription() { + assertDescription("(\"good\" and \"bad\" and \"ugly\")", + allOf(equalTo("good"), equalTo("bad"), equalTo("ugly"))); + } + + @Test public void + hasAMismatchDescriptionDescribingTheFirstFailingMatch() { + assertMismatchDescription("\"good\" was \"bad\"", allOf(equalTo("bad"), equalTo("good")), "bad"); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java new file mode 100644 index 0000000..11c053c --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java @@ -0,0 +1,56 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.AnyOf.anyOf; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.StringEndsWith.endsWith; +import static org.hamcrest.core.StringStartsWith.startsWith; + +public final class AnyOfTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<String> matcher = anyOf(equalTo("irrelevant"), startsWith("irr")); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + evaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers() { + Matcher<String> matcher = anyOf(startsWith("goo"), endsWith("ood")); + + assertMatches("didn't pass both sub-matchers", matcher, "good"); + assertMatches("didn't pass second sub-matcher", matcher, "mood"); + assertMatches("didn't pass first sub-matcher", matcher, "goon"); + assertDoesNotMatch("didn't fail both sub-matchers", matcher, "flan"); + } + + @Test public void + evaluatesToTheTheLogicalDisjunctionOfManyOtherMatchers() { + Matcher<String> matcher = anyOf(startsWith("g"), startsWith("go"), endsWith("d"), startsWith("go"), startsWith("goo")); + + assertMatches("didn't pass middle sub-matcher", matcher, "vlad"); + assertDoesNotMatch("didn't fail all sub-matchers", matcher, "flan"); + } + + @SuppressWarnings("unchecked") + @Test public void + supportsMixedTypes() { + final Matcher<SampleSubClass> matcher = anyOf( + equalTo(new SampleBaseClass("bad")), + equalTo(new SampleBaseClass("good")), + equalTo(new SampleSubClass("ugly"))); + + assertMatches("didn't pass middle sub-matcher", matcher, new SampleSubClass("good")); + } + + @Test public void + hasAReadableDescription() { + assertDescription("(\"good\" or \"bad\" or \"ugly\")", + anyOf(equalTo("good"), equalTo("bad"), equalTo("ugly"))); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java new file mode 100644 index 0000000..e89c493 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java @@ -0,0 +1,68 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsNot.not; +import static org.hamcrest.core.IsNull.notNullValue; + +public final class CombinableTest { + private static final CombinableMatcher<Integer> EITHER_3_OR_4 = CombinableMatcher.<Integer>either(equalTo(3)).or(equalTo(4)); + private static final CombinableMatcher<Integer> NOT_3_AND_NOT_4 = CombinableMatcher.<Integer>both(not(equalTo(3))).and(not(equalTo(4))); + + @Test public void + copesWithNullsAndUnknownTypes() { + assertNullSafe(EITHER_3_OR_4); + assertNullSafe(NOT_3_AND_NOT_4); + assertUnknownTypeSafe(EITHER_3_OR_4); + assertUnknownTypeSafe(NOT_3_AND_NOT_4); + } + + @Test public void + bothAcceptsAndRejects() { + assertMatches("both didn't pass", NOT_3_AND_NOT_4, 2); + assertDoesNotMatch("both didn't fail", NOT_3_AND_NOT_4, 3); + } + + @Test public void + acceptsAndRejectsThreeAnds() { + CombinableMatcher<? super Integer> tripleAnd = NOT_3_AND_NOT_4.and(equalTo(2)); + + assertMatches("tripleAnd didn't pass", tripleAnd, 2); + assertDoesNotMatch("tripleAnd didn't fail", tripleAnd, 3); + } + + @Test public void + bothDescribesItself() { + assertDescription("(not <3> and not <4>)", NOT_3_AND_NOT_4); + assertMismatchDescription("not <3> was <3>", NOT_3_AND_NOT_4, 3); + } + + @Test public void + eitherAcceptsAndRejects() { + assertMatches("either didn't pass", EITHER_3_OR_4, 3); + assertDoesNotMatch("either didn't fail", EITHER_3_OR_4, 6); + } + + @Test public void + acceptsAndRejectsThreeOrs() { + final CombinableMatcher<Integer> tripleOr = EITHER_3_OR_4.or(equalTo(11)); + + assertMatches("tripleOr didn't pass", tripleOr, 11); + assertDoesNotMatch("tripleOr didn't fail", tripleOr, 9); + } + + @Test public void + eitherDescribesItself() { + assertDescription("(<3> or <4>)", EITHER_3_OR_4); + assertMismatchDescription("was <6>", EITHER_3_OR_4, 6); + } + + @Test public void + picksUpTypeFromLeftHandSideOfExpression() { + @SuppressWarnings("unused") + Matcher<String> matcher = CombinableMatcher.both(equalTo("yellow")).and(notNullValue(String.class)); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java new file mode 100644 index 0000000..5c76af9 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java @@ -0,0 +1,49 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.DescribedAs.describedAs; +import static org.hamcrest.core.IsAnything.anything; +import static org.hamcrest.core.IsEqual.equalTo; + +public final class DescribedAsTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<Object> matcher = describedAs("irrelevant", anything()); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + overridesDescriptionOfOtherMatcherWithThatPassedToConstructor() { + Matcher<?> matcher = describedAs("my description", anything()); + + assertDescription("my description", matcher); + } + + @Test public void + appendsValuesToDescription() { + Matcher<?> matcher = describedAs("value 1 = %0, value 2 = %1", anything(), 33, 97); + + assertDescription("value 1 = <33>, value 2 = <97>", matcher); + } + + @Test public void + celegatesMatchingToAnotherMatcher() { + Matcher<String> matcher = describedAs("irrelevant", equalTo("hi")); + + assertMatches(matcher, "hi"); + assertDoesNotMatch("matched", matcher, "oi"); + } + + @Test public void + delegatesMismatchDescriptionToAnotherMatcher() { + Matcher<Integer> matcher = describedAs("irrelevant", equalTo(2)); + + assertMismatchDescription("was <1>", matcher, 1); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java new file mode 100644 index 0000000..e45e881 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java @@ -0,0 +1,43 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import java.util.ArrayList; + +import static java.util.Arrays.asList; +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.StringContains.containsString; + +public final class EveryTest { + + private final Matcher<Iterable<? extends String>> matcher = Every.everyItem(containsString("a")); + + @Test public void + copesWithNullsAndUnknownTypes() { + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + matchesOnlyWhenEveryItemMatches() { + assertMatches(matcher, asList("AaA", "BaB", "CaC")); + assertDoesNotMatch(matcher, asList("AaA", "BXB", "CaC")); + } + + @Test public void + matchesEmptyLists() { + assertMatches("didn't match empty list", matcher, new ArrayList<String>()); + } + + @Test public void + describesItself() { + assertDescription("every item is a string containing \"a\"", matcher); + } + + @Test public void + describesAMismatch() { + assertMismatchDescription("an item was \"BXB\"", matcher, asList("BXB")); + } +} + diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java new file mode 100644 index 0000000..4983bf7 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java @@ -0,0 +1,35 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.assertDescription; +import static org.hamcrest.AbstractMatcherTest.assertMatches; +import static org.hamcrest.core.IsAnything.anything; + +public final class IsAnythingTest { + + private final Matcher<Object> matcher = anything(); + + private static class CustomThing { } + + @Test public void + alwaysEvaluatesToTrue() { + assertMatches("didn't match null", matcher, null); + assertMatches("didn't match Object", matcher, new Object()); + assertMatches("didn't match custom object", matcher, new CustomThing()); + assertMatches("didn't match String", matcher, "hi"); + } + + @Test public void + hasUsefulDefaultDescription() { + assertDescription("ANYTHING", matcher); + } + + @Test public void + canOverrideDescription() { + String description = "description"; + assertDescription(description, anything(description)); + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java new file mode 100644 index 0000000..a9007cd --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java @@ -0,0 +1,107 @@ +package org.hamcrest.core; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import static java.util.Arrays.asList; +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsCollectionContaining.hasItem; +import static org.hamcrest.core.IsCollectionContaining.hasItems; +import static org.hamcrest.core.IsEqual.equalTo; + +public final class IsCollectionContainingTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<?> matcher = hasItem(equalTo("irrelevant")); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + matchesACollectionThatContainsAnElementForTheGivenMatcher() { + final Matcher<Iterable<? super String>> itemMatcher = hasItem(equalTo("a")); + + assertMatches("list containing 'a'", itemMatcher, asList("a", "b", "c")); + } + + @Test public void + doesNotMatchCollectionWithoutAnElementForGivenMatcher() { + final Matcher<Iterable<? super String>> matcher = hasItem(mismatchable("a")); + + assertMismatchDescription("mismatches were: [mismatched: b, mismatched: c]", matcher, asList("b", "c")); + assertMismatchDescription("was empty", matcher, new ArrayList<String>()); + } + + @Test public void + doesNotMatchNull() { + assertDoesNotMatch("doesn't match null", hasItem(equalTo("a")), null); + } + + @Test public void + hasAReadableDescription() { + assertDescription("a collection containing mismatchable: a", hasItem(mismatchable("a"))); + } + + @Test public void + canMatchItemWhenCollectionHoldsSuperclass() { // Issue 24 + final Set<Number> s = new HashSet<Number>(); + s.add(2); + + assertMatches(new IsCollectionContaining<Number>(new IsEqual<Number>(2)), s); + assertMatches(IsCollectionContaining.hasItem(2), s); + } + + @SuppressWarnings("unchecked") + @Test public void + matchesMultipleItemsInCollection() { + final Matcher<Iterable<String>> matcher1 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items", matcher1, asList("a", "b", "c")); + + final Matcher<Iterable<String>> matcher2 = hasItems("a", "b", "c"); + assertMatches("list containing all items (without matchers)", matcher2, asList("a", "b", "c")); + + final Matcher<Iterable<String>> matcher3 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items in any order", matcher3, asList("c", "b", "a")); + + final Matcher<Iterable<String>> matcher4 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items plus others", matcher4, asList("e", "c", "b", "a", "d")); + + final Matcher<Iterable<String>> matcher5 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertDoesNotMatch("not match list unless it contains all items", matcher5, asList("e", "c", "b", "d")); // 'a' missing + } + + @Test public void + reportsMismatchWithAReadableDescriptionForMultipleItems() { + final Matcher<Iterable<Integer>> matcher = hasItems(3, 4); + + assertMismatchDescription("a collection containing <4> mismatches were: [was <1>, was <2>, was <3>]", + matcher, asList(1, 2, 3)); + } + + private static Matcher<? super String> mismatchable(final String string) { + return new TypeSafeDiagnosingMatcher<String>() { + @Override + protected boolean matchesSafely(String item, Description mismatchDescription) { + if (string.equals(item)) + return true; + + mismatchDescription.appendText("mismatched: " + item); + return false; + } + + @Override + public void describeTo(Description description) { + description.appendText("mismatchable: " + string); + } + }; + } +} + diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsEqualTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsEqualTest.java new file mode 100644 index 0000000..9df73e4 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsEqualTest.java @@ -0,0 +1,143 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsEqual.equalToObject; + +public final class IsEqualTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<?> matcher = equalTo("irrelevant"); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + comparesObjectsUsingEqualsMethod() { + final Matcher<String> matcher1 = equalTo("hi"); + assertMatches(matcher1, "hi"); + assertDoesNotMatch(matcher1, "bye"); + assertDoesNotMatch(matcher1, null); + + final Matcher<Integer> matcher2 = equalTo(1); + assertMatches(matcher2, 1); + assertDoesNotMatch(matcher2, 2); + assertDoesNotMatch(matcher2, null); + } + + @Test public void + canCompareNullValues() { + final Matcher<Object> matcher = equalTo(null); + + assertMatches(matcher, null); + assertDoesNotMatch(matcher, 2); + assertDoesNotMatch(matcher, "hi"); + assertDoesNotMatch(matcher, new String[] {"a", "b"}); + } + + @SuppressWarnings("EqualsWhichDoesntCheckParameterClass") + @Test public void + honoursIsEqualImplementationEvenWithNullValues() { + Object alwaysEqual = new Object() { + @Override + public boolean equals(Object obj) { + return true; + } + }; + Object neverEqual = new Object() { + @Override + public boolean equals(Object obj) { + return false; + } + }; + + Matcher<Object> matcher = equalTo(null); + + assertMatches(matcher, alwaysEqual); + assertDoesNotMatch(matcher, neverEqual); + } + + @Test public void + comparesTheElementsOfAnObjectArray() { + String[] s1 = {"a", "b"}; + String[] s2 = {"a", "b"}; + String[] s3 = {"c", "d"}; + String[] s4 = {"a", "b", "c", "d"}; + + final Matcher<String[]> matcher = equalTo(s1); + assertMatches(matcher, s1); + assertMatches(matcher, s2); + assertDoesNotMatch(matcher, s3); + assertDoesNotMatch(matcher, s4); + assertDoesNotMatch(matcher, null); + } + + @Test public void + comparesTheElementsOfAnArrayOfPrimitiveTypes() { + int[] i1 = new int[]{1, 2}; + int[] i2 = new int[]{1, 2}; + int[] i3 = new int[]{3, 4}; + int[] i4 = new int[]{1, 2, 3, 4}; + + final Matcher<int[]> matcher = equalTo(i1); + assertMatches(matcher, i1); + assertMatches(matcher, i2); + assertDoesNotMatch(matcher, i3); + assertDoesNotMatch(matcher, i4); + assertDoesNotMatch(matcher, null); + } + + @Test public void + recursivelyTestsElementsOfArrays() { + int[][] i1 = new int[][]{{1, 2}, {3, 4}}; + int[][] i2 = new int[][]{{1, 2}, {3, 4}}; + int[][] i3 = new int[][]{{5, 6}, {7, 8}}; + int[][] i4 = new int[][]{{1, 2, 3, 4}, {3, 4}}; + + final Matcher<int[][]> matcher = equalTo(i1); + assertMatches(matcher, i1); + assertMatches(matcher, i2); + assertDoesNotMatch(matcher, i3); + assertDoesNotMatch(matcher, i4); + assertDoesNotMatch(matcher, null); + } + + @Test public void + hasUntypedVariant() { + Object original = 10; + + assertMatches(equalToObject(10), original); + assertDoesNotMatch(equalToObject(0), original); + assertDoesNotMatch(equalToObject("10"), original); + assertDoesNotMatch(equalToObject(10), "10"); + } + + @Test public void + includesTheResultOfCallingToStringOnItsArgumentInTheDescription() { + final String argumentDescription = "ARGUMENT DESCRIPTION"; + Object argument = new Object() { + @Override + public String toString() { + return argumentDescription; + } + }; + assertDescription("<" + argumentDescription + ">", equalTo(argument)); + } + + @Test public void + returnsAnObviousDescriptionIfCreatedWithANestedMatcherByMistake() { + Matcher<? super String> innerMatcher = equalTo("NestedMatcher"); + assertDescription("<" + innerMatcher.toString() + ">", equalTo(innerMatcher)); + } + + @Test public void + returnsGoodDescriptionIfCreatedWithNullReference() { + assertDescription("null", equalTo(null)); + } +} + diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java new file mode 100644 index 0000000..8dd85af --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java @@ -0,0 +1,69 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsInstanceOf.any; +import static org.hamcrest.core.IsInstanceOf.instanceOf; + +public final class IsInstanceOfTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<?> matcher = instanceOf(Number.class); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + evaluatesToTrueIfArgumentIsInstanceOfASpecificClass() { + final Matcher<Object> matcher = instanceOf(Number.class); + + assertMatches(matcher, 1); + assertMatches(matcher, 1.1); + assertDoesNotMatch(matcher, null); + assertDoesNotMatch(matcher, new Object()); + } + + @Test public void + hasAReadableDescription() { + assertDescription("an instance of java.lang.Number", instanceOf(Number.class)); + } + + @Test public void + describesActualClassInMismatchMessage() { + assertMismatchDescription("\"some text\" is a java.lang.String", instanceOf(Number.class), "some text"); + } + + @Test public void + matchesPrimitiveTypes() { + assertMatches(any(boolean.class), true); + assertMatches(any(byte.class), (byte)1); + assertMatches(any(char.class), 'x'); + assertMatches(any(double.class), 5.0); + assertMatches(any(float.class), 5.0f); + assertMatches(any(int.class), 2); + assertMatches(any(long.class), 4L); + assertMatches(any(short.class), (short)1); + } + + @Test public void + instanceOfRequiresACastToReturnTheCorrectTypeForUseInJMock() { + @SuppressWarnings("unused") + Integer anInteger = (Integer)with(instanceOf(Integer.class)); + } + + @Test public void + anyWillReturnTheCorrectTypeForUseInJMock() { + @SuppressWarnings("unused") + Integer anInteger = with(any(Integer.class)); + } + + + private static <T> T with(@SuppressWarnings("unused") Matcher<T> matcher) { + return null; + } +} + diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java new file mode 100644 index 0000000..79f4683 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java @@ -0,0 +1,42 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsInstanceOf.instanceOf; +import static org.hamcrest.core.IsNot.not; + +public final class IsNotTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<String> matcher = not("something"); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + evaluatesToTheTheLogicalNegationOfAnotherMatcher() { + final Matcher<String> matcher = not(equalTo("A")); + + assertMatches(matcher, "B"); + assertDoesNotMatch(matcher, "A"); + } + + @Test public void + providesConvenientShortcutForNotEqualTo() { + final Matcher<String> matcher = not("A"); + + assertMatches(matcher, "B"); + assertDoesNotMatch(matcher, "A"); + } + + @Test public void + usesDescriptionOfNegatedMatcherWithPrefix() { + assertDescription("not an instance of java.lang.String", not(instanceOf(String.class))); + assertDescription("not \"A\"", not("A")); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsNullTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsNullTest.java new file mode 100644 index 0000000..74b046b --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsNullTest.java @@ -0,0 +1,43 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsNull.notNullValue; +import static org.hamcrest.core.IsNull.nullValue; + + +public final class IsNullTest { + + private final Matcher<Object> nullMatcher = nullValue(); + private final Matcher<Object> notNullMatcher = notNullValue(); + + @Test public void + copesWithNullsAndUnknownTypes() { + assertNullSafe(nullMatcher); + assertUnknownTypeSafe(nullMatcher); + + assertNullSafe(notNullMatcher); + assertUnknownTypeSafe(notNullMatcher); + } + + @Test public void + evaluatesToTrueIfArgumentIsNull() { + assertMatches(nullMatcher, null); + assertDoesNotMatch(nullMatcher, new Object()); + + assertMatches(notNullMatcher, new Object()); + assertDoesNotMatch(notNullMatcher, null); + } + + @Test public void + supportsStaticTyping() { + requiresStringMatcher(nullValue(String.class)); + requiresStringMatcher(notNullValue(String.class)); + } + + private void requiresStringMatcher(@SuppressWarnings("unused") Matcher<String> arg) { + // no-op + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java new file mode 100644 index 0000000..a4a2010 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java @@ -0,0 +1,48 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.IsSame.sameInstance; +import static org.hamcrest.core.IsSame.theInstance; + + +public final class IsSameTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<String> matcher = sameInstance("irrelevant"); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + evaluatesToTrueIfArgumentIsReferenceToASpecifiedObject() { + Object o1 = new Object(); + Matcher<Object> matcher = sameInstance(o1); + + assertMatches(matcher, o1); + assertDoesNotMatch(matcher, new Object()); + } + + @Test public void + alternativeFactoryMethodAlsoMatchesOnlyIfArgumentIsReferenceToASpecifiedObject() { + Object o1 = new Object(); + Matcher<Object> matcher = theInstance(o1); + + assertMatches(matcher, o1); + assertDoesNotMatch(matcher, new Object()); + } + + @Test public void + returnsReadableDescriptionFromToString() { + assertDescription("sameInstance(\"ARG\")", sameInstance("ARG")); + } + + @Test public void + returnsReadableDescriptionFromToStringWhenInitialisedWithNull() { + assertDescription("sameInstance(null)", sameInstance(null)); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java new file mode 100644 index 0000000..6656e6d --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java @@ -0,0 +1,51 @@ +package org.hamcrest.core; + +import org.hamcrest.Matcher; +import org.junit.Test; + +import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.Is.isA; +import static org.hamcrest.core.IsEqual.equalTo; + +public final class IsTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher<String> matcher = is("something"); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + matchesTheSameWayTheUnderlyingMatcherDoes() { + final Matcher<Boolean> matcher = is(equalTo(true)); + + assertMatches(matcher, true); + assertDoesNotMatch(matcher, false); + } + + @Test public void + generatesIsPrefixInDescription() { + assertDescription("is <true>", is(equalTo(true))); + assertDescription("is \"A\"", is("A")); + } + + @Test public void + providesConvenientShortcutForIsEqualTo() { + final Matcher<String> matcher = is("A"); + + assertMatches(matcher, "A"); + assertDoesNotMatch(is("A"), "B"); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test public void + providesConvenientShortcutForIsInstanceOf() { + final Matcher matcher = isA(Integer.class); + assertMatches(matcher, 1); + assertDoesNotMatch(matcher, new Object()); + assertDoesNotMatch(matcher, null); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/SampleBaseClass.java b/hamcrest-core/src/test/java/org/hamcrest/core/SampleBaseClass.java new file mode 100644 index 0000000..baf4d8e --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/SampleBaseClass.java @@ -0,0 +1,24 @@ +package org.hamcrest.core; + +public class SampleBaseClass { + String value; + + public SampleBaseClass(String value) { + this.value = value; + } + + @Override + public String toString() { + return value; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof SampleBaseClass && value.equals(((SampleBaseClass) obj).value); + } + + @Override + public int hashCode() { + return value.hashCode(); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java b/hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java new file mode 100644 index 0000000..bdaa160 --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java @@ -0,0 +1,9 @@ +package org.hamcrest.core; + +public class SampleSubClass extends SampleBaseClass { + + public SampleSubClass(String value) { + super(value); + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/StringContainsTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/StringContainsTest.java new file mode 100644 index 0000000..93dd05c --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/StringContainsTest.java @@ -0,0 +1,43 @@ +package org.hamcrest.core; + +import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.Matcher; + +import static org.hamcrest.core.StringContains.containsString; +import static org.hamcrest.core.StringContains.containsStringIgnoringCase; + + +public class StringContainsTest extends AbstractMatcherTest { + static final String EXCERPT = "EXCERPT"; + final Matcher<String> stringContains = containsString(EXCERPT); + + @Override + protected Matcher<?> createMatcher() { + return stringContains; + } + + public void testMatchesSubstrings() { + assertMatches(stringContains, EXCERPT + "END"); + assertMatches(stringContains, "START" + EXCERPT); + assertMatches(stringContains, "START" + EXCERPT + "END"); + assertMatches(stringContains, EXCERPT); + assertDoesNotMatch(stringContains, EXCERPT.toLowerCase()); + assertMatches(stringContains, EXCERPT + EXCERPT); + assertDoesNotMatch(stringContains, "XC"); + + assertMismatchDescription("was \"Something else\"", stringContains, "Something else"); + assertDescription("a string containing \"EXCERPT\"", stringContains); + } + + public void testMatchesSubstringsIgnoringCase() { + final Matcher<String> ignoringCase = containsStringIgnoringCase("ExCert"); + assertMatches(ignoringCase, "eXcERT" + "END"); + assertMatches(ignoringCase, "START" + "EXCert"); + assertMatches(ignoringCase, "START" + "excERT" + "END"); + assertMatches(ignoringCase, "eXCert" + "excErt"); + assertDoesNotMatch(ignoringCase, "xc"); + + assertMismatchDescription("was \"Something else\"", ignoringCase, "Something else"); + assertDescription("a string containing \"ExCert\" ignoring case", ignoringCase); + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/StringEndsWithTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/StringEndsWithTest.java new file mode 100644 index 0000000..f482cbf --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/StringEndsWithTest.java @@ -0,0 +1,45 @@ +package org.hamcrest.core; + +import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.Matcher; + +import static org.hamcrest.core.StringEndsWith.endsWith; +import static org.hamcrest.core.StringEndsWith.endsWithIgnoringCase; + + +public class StringEndsWithTest extends AbstractMatcherTest { + static final String EXCERPT = "EXCERPT"; + final Matcher<String> stringEndsWith = endsWith(EXCERPT); + + @Override + protected Matcher<?> createMatcher() { + return stringEndsWith; + } + + public void testMatchesSubstringAtEnd() { + assertDoesNotMatch(stringEndsWith, EXCERPT + "END"); + assertMatches(stringEndsWith, "START" + EXCERPT); + assertMatches(stringEndsWith, EXCERPT); + assertDoesNotMatch(stringEndsWith, EXCERPT.toLowerCase()); + assertDoesNotMatch(stringEndsWith, "START" + EXCERPT + "END"); + assertMatches(stringEndsWith, EXCERPT + EXCERPT); + assertDoesNotMatch(stringEndsWith, "EXCER"); + + assertMismatchDescription("was \"Something else\"", stringEndsWith, "Something else"); + assertDescription("a string ending with \"EXCERPT\"", stringEndsWith); + } + + public void testMatchesSubstringAtEndIngoringCase() { + final Matcher<String> ignoringCase = endsWithIgnoringCase("EXCERpt"); + assertDoesNotMatch(ignoringCase, "eXCErpt" + "END"); + assertMatches(ignoringCase, "START" + "EXceRpt"); + assertMatches(ignoringCase, "EXcerPT"); + assertDoesNotMatch(ignoringCase, "START" + "ExcERpt" + "END"); + assertMatches(ignoringCase, "exCERpt" + "EXCerPt"); + assertDoesNotMatch(ignoringCase, "ExcER"); + + assertMismatchDescription("was \"Something else\"", ignoringCase, "Something else"); + assertDescription("a string ending with \"EXCERpt\" ignoring case", ignoringCase); + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java new file mode 100644 index 0000000..f093acb --- /dev/null +++ b/hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java @@ -0,0 +1,46 @@ +package org.hamcrest.core; + +import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.Matcher; + +import static org.hamcrest.core.StringStartsWith.startsWith; +import static org.hamcrest.core.StringStartsWith.startsWithIgnoringCase; + + +public class StringStartsWithTest extends AbstractMatcherTest { + static final String EXCERPT = "EXCERPT"; + final Matcher<String> stringStartsWith = startsWith(EXCERPT); + + @Override + protected Matcher<?> createMatcher() { + return stringStartsWith; + } + + public void testMatchesStringAtStart() { + assertMatches(stringStartsWith, EXCERPT + "END"); + assertDoesNotMatch(stringStartsWith, "START" + EXCERPT); + assertDoesNotMatch(stringStartsWith, "START" + EXCERPT + "END"); + assertMatches(stringStartsWith, EXCERPT); + assertDoesNotMatch(stringStartsWith, EXCERPT.toLowerCase()); + assertMatches(stringStartsWith, EXCERPT + EXCERPT); + assertDoesNotMatch(stringStartsWith, "EXCER"); + + assertDescription("a string starting with \"EXCERPT\"", stringStartsWith); + assertMismatchDescription("was \"Something else\"", stringStartsWith, "Something else"); + } + + public void testMatchesStringAtStartIgnoringCase() { + final Matcher<String> ignoreCase = startsWithIgnoringCase("EXCerPT"); + + assertMatches(ignoreCase, "exCerPT" + "END"); + assertDoesNotMatch(ignoreCase, "START" + "EXCerpt"); + assertDoesNotMatch(ignoreCase, "START" + "EXcerpT" + "END"); + assertMatches(ignoreCase, "excERPT"); + assertMatches(ignoreCase, "ExcerPT" + "EXCerpt"); + assertDoesNotMatch(ignoreCase, "ExcER"); + + assertDescription("a string starting with \"EXCerPT\" ignoring case", ignoreCase); + assertMismatchDescription("was \"Something else\"", ignoreCase, "Something else"); + } + +} |