diff options
author | Paul Duffin <paulduffin@google.com> | 2017-01-20 13:50:23 +0000 |
---|---|---|
committer | Paul Duffin <paulduffin@google.com> | 2017-01-20 13:50:23 +0000 |
commit | 74299c53a59140905e0259cb0a1130cb719733d8 (patch) | |
tree | aa4a6a53609f47d386dfa114be0abfc01e0e5dff /hamcrest-library/src | |
parent | f1015b50e715aefc3070d83d95340cbc29811329 (diff) | |
download | hamcrest-74299c53a59140905e0259cb0a1130cb719733d8.tar.gz |
Match upstream file structure
Bug: 30946317
Test: make checkbuild and run cts CtsTextTestCases
Change-Id: I6c1773018f95855eb6599d66f6fb5923c7d48b03
Diffstat (limited to 'hamcrest-library/src')
25 files changed, 1162 insertions, 0 deletions
diff --git a/hamcrest-library/src/main/java/org/hamcrest/Matchers.java b/hamcrest-library/src/main/java/org/hamcrest/Matchers.java new file mode 100644 index 0000000..ce550b5 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/Matchers.java @@ -0,0 +1,308 @@ +// Generated source. +package org.hamcrest; + +public class Matchers { + + /** + * Decorates another Matcher, retaining the behavior but allowing tests + * to be slightly more expressive. + * + * eg. assertThat(cheese, equalTo(smelly)) + * vs assertThat(cheese, is(equalTo(smelly))) + */ + public static <T> org.hamcrest.Matcher<T> is(org.hamcrest.Matcher<T> matcher) { + return org.hamcrest.core.Is.is(matcher); + } + + /** + * This is a shortcut to the frequently used is(equalTo(x)). + * + * eg. assertThat(cheese, is(equalTo(smelly))) + * vs assertThat(cheese, is(smelly)) + */ + public static <T> org.hamcrest.Matcher<T> is(T value) { + return org.hamcrest.core.Is.is(value); + } + + /** + * This is a shortcut to the frequently used is(instanceOf(SomeClass.class)). + * + * eg. assertThat(cheese, is(instanceOf(Cheddar.class))) + * vs assertThat(cheese, is(Cheddar.class)) + */ + public static org.hamcrest.Matcher<java.lang.Object> is(java.lang.Class<?> type) { + return org.hamcrest.core.Is.is(type); + } + + /** + * Inverts the rule. + */ + public static <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher) { + return org.hamcrest.core.IsNot.not(matcher); + } + + /** + * This is a shortcut to the frequently used not(equalTo(x)). + * + * eg. assertThat(cheese, is(not(equalTo(smelly)))) + * vs assertThat(cheese, is(not(smelly))) + */ + public static <T> org.hamcrest.Matcher<T> not(T value) { + return org.hamcrest.core.IsNot.not(value); + } + + /** + * Is the value equal to another value, as tested by the + * {@link java.lang.Object#equals} invokedMethod? + */ + public static <T> org.hamcrest.Matcher<T> equalTo(T operand) { + return org.hamcrest.core.IsEqual.equalTo(operand); + } + + /** + * Is the value an instance of a particular type? + */ + public static org.hamcrest.Matcher<java.lang.Object> instanceOf(java.lang.Class<?> type) { + return org.hamcrest.core.IsInstanceOf.instanceOf(type); + } + + /** + * Evaluates to true only if ALL of the passed in matchers evaluate to true. + */ + public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? extends T>... matchers) { + return org.hamcrest.core.AllOf.<T>allOf(matchers); + } + + /** + * Evaluates to true only if ALL of the passed in matchers evaluate to true. + */ + public static <T> org.hamcrest.Matcher<T> allOf(java.lang.Iterable<org.hamcrest.Matcher<? extends T>> matchers) { + return org.hamcrest.core.AllOf.allOf(matchers); + } + + /** + * Evaluates to true if ANY of the passed in matchers evaluate to true. + */ + public static <T> org.hamcrest.Matcher<T> anyOf(org.hamcrest.Matcher<? extends T>... matchers) { + return org.hamcrest.core.AnyOf.<T>anyOf(matchers); + } + + /** + * Evaluates to true if ANY of the passed in matchers evaluate to true. + */ + public static <T> org.hamcrest.Matcher<T> anyOf(java.lang.Iterable<org.hamcrest.Matcher<? extends T>> matchers) { + return org.hamcrest.core.AnyOf.anyOf(matchers); + } + + /** + * Creates a new instance of IsSame + * + * @param object The predicate evaluates to true only when the argument is + * this object. + */ + public static <T> org.hamcrest.Matcher<T> sameInstance(T object) { + return org.hamcrest.core.IsSame.sameInstance(object); + } + + /** + * This matcher always evaluates to true. + */ + public static <T> org.hamcrest.Matcher<T> anything() { + return org.hamcrest.core.IsAnything.anything(); + } + + /** + * This matcher always evaluates to true. + * + * @param description A meaningful string used when describing itself. + */ + public static <T> org.hamcrest.Matcher<T> anything(java.lang.String description) { + return org.hamcrest.core.IsAnything.anything(description); + } + + /** + * This matcher always evaluates to true. With type inference. + */ + public static <T> org.hamcrest.Matcher<T> any(java.lang.Class<T> type) { + return org.hamcrest.core.IsAnything.any(type); + } + + /** + * Matches if value is null. + */ + public static <T> org.hamcrest.Matcher<T> nullValue() { + return org.hamcrest.core.IsNull.nullValue(); + } + + /** + * Matches if value is null. With type inference. + */ + public static <T> org.hamcrest.Matcher<T> nullValue(java.lang.Class<T> type) { + return org.hamcrest.core.IsNull.nullValue(type); + } + + /** + * Matches if value is not null. + */ + public static <T> org.hamcrest.Matcher<T> notNullValue() { + return org.hamcrest.core.IsNull.notNullValue(); + } + + /** + * Matches if value is not null. With type inference. + */ + public static <T> org.hamcrest.Matcher<T> notNullValue(java.lang.Class<T> type) { + return org.hamcrest.core.IsNull.notNullValue(type); + } + + /** + * Wraps an existing matcher and overrides the description when it fails. + */ + public static <T> org.hamcrest.Matcher<T> describedAs(java.lang.String description, org.hamcrest.Matcher<T> matcher, java.lang.Object... values) { + return org.hamcrest.core.DescribedAs.describedAs(description, matcher, values); + } + + public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(org.hamcrest.Matcher<T> elementMatcher) { + return org.hamcrest.collection.IsArrayContaining.hasItemInArray(elementMatcher); + } + + public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(T element) { + return org.hamcrest.collection.IsArrayContaining.hasItemInArray(element); + } + + public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(T element) { + return org.hamcrest.collection.IsCollectionContaining.hasItem(element); + } + + public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(org.hamcrest.Matcher<? extends T> elementMatcher) { + return org.hamcrest.collection.IsCollectionContaining.<T>hasItem(elementMatcher); + } + + public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? extends T>... elementMatchers) { + return org.hamcrest.collection.IsCollectionContaining.<T>hasItems(elementMatchers); + } + + public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... elements) { + return org.hamcrest.collection.IsCollectionContaining.hasItems(elements); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasEntry(org.hamcrest.Matcher<K> keyMatcher, org.hamcrest.Matcher<V> valueMatcher) { + return org.hamcrest.collection.IsMapContaining.hasEntry(keyMatcher, valueMatcher); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasEntry(K key, V value) { + return org.hamcrest.collection.IsMapContaining.hasEntry(key, value); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasKey(org.hamcrest.Matcher<K> keyMatcher) { + return org.hamcrest.collection.IsMapContaining.hasKey(keyMatcher); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasKey(K key) { + return org.hamcrest.collection.IsMapContaining.hasKey(key); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasValue(org.hamcrest.Matcher<V> valueMatcher) { + return org.hamcrest.collection.IsMapContaining.hasValue(valueMatcher); + } + + public static <K, V> org.hamcrest.Matcher<java.util.Map<K, V>> hasValue(V value) { + return org.hamcrest.collection.IsMapContaining.hasValue(value); + } + + public static <T> org.hamcrest.Matcher<T> isIn(java.util.Collection<T> collection) { + return org.hamcrest.collection.IsIn.isIn(collection); + } + + public static <T> org.hamcrest.Matcher<T> isIn(T[] param1) { + return org.hamcrest.collection.IsIn.isIn(param1); + } + + public static <T> org.hamcrest.Matcher<T> isOneOf(T... elements) { + return org.hamcrest.collection.IsIn.isOneOf(elements); + } + + public static org.hamcrest.Matcher<java.lang.Double> closeTo(double operand, double error) { + return org.hamcrest.number.IsCloseTo.closeTo(operand, error); + } + + public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> greaterThan(T value) { + return org.hamcrest.number.OrderingComparisons.greaterThan(value); + } + + public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> greaterThanOrEqualTo(T value) { + return org.hamcrest.number.OrderingComparisons.greaterThanOrEqualTo(value); + } + + public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> lessThan(T value) { + return org.hamcrest.number.OrderingComparisons.lessThan(value); + } + + public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> lessThanOrEqualTo(T value) { + return org.hamcrest.number.OrderingComparisons.lessThanOrEqualTo(value); + } + + public static org.hamcrest.Matcher<java.lang.String> equalToIgnoringCase(java.lang.String string) { + return org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase(string); + } + + public static org.hamcrest.Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String string) { + return org.hamcrest.text.IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace(string); + } + + public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.String substring) { + return org.hamcrest.text.StringContains.containsString(substring); + } + + public static org.hamcrest.Matcher<java.lang.String> endsWith(java.lang.String substring) { + return org.hamcrest.text.StringEndsWith.endsWith(substring); + } + + public static org.hamcrest.Matcher<java.lang.String> startsWith(java.lang.String substring) { + return org.hamcrest.text.StringStartsWith.startsWith(substring); + } + + public static <T> org.hamcrest.Matcher<T> hasToString(org.hamcrest.Matcher<java.lang.String> toStringMatcher) { + return org.hamcrest.object.HasToString.hasToString(toStringMatcher); + } + + public static <T> org.hamcrest.Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType) { + return org.hamcrest.object.IsCompatibleType.typeCompatibleWith(baseType); + } + + /** + * Constructs an IsEventFrom Matcher that returns true for any object + * derived from <var>eventClass</var> announced by <var>source</var>. + */ + public static org.hamcrest.Matcher<java.util.EventObject> eventFrom(java.lang.Class<? extends java.util.EventObject> eventClass, java.lang.Object source) { + return org.hamcrest.object.IsEventFrom.eventFrom(eventClass, source); + } + + /** + * Constructs an IsEventFrom Matcher that returns true for any object + * derived from {@link java.util.EventObject} announced by <var>source + * </var>. + */ + public static org.hamcrest.Matcher<java.util.EventObject> eventFrom(java.lang.Object source) { + return org.hamcrest.object.IsEventFrom.eventFrom(source); + } + + /* android-changed REMOVE + public static <T> org.hamcrest.Matcher<T> hasProperty(java.lang.String propertyName) { + return org.hamcrest.beans.HasProperty.hasProperty(propertyName); + } + + public static <T> org.hamcrest.Matcher<T> hasProperty(java.lang.String propertyName, org.hamcrest.Matcher value) { + return org.hamcrest.beans.HasPropertyWithValue.hasProperty(propertyName, value); + } + */ + + public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, org.hamcrest.Matcher<java.lang.String> valueMatcher) { + return org.hamcrest.xml.HasXPath.hasXPath(xPath, valueMatcher); + } + + public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath) { + return org.hamcrest.xml.HasXPath.hasXPath(xPath); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java new file mode 100644 index 0000000..6a26ef1 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java @@ -0,0 +1,64 @@ +package org.hamcrest.collection; + +import java.util.Arrays; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; + +public class IsArray<T> extends TypeSafeMatcher<T[]> { + private final Matcher<T>[] elementMatchers; + + public IsArray(Matcher<T>[] elementMatchers) { + this.elementMatchers = elementMatchers.clone(); + } + + public boolean matchesSafely(T[] array) { + if (array.length != elementMatchers.length) return false; + + for (int i = 0; i < array.length; i++) { + if (!elementMatchers[i].matches(array[i])) return false; + } + + return true; + } + + public void describeTo(Description description) { + description.appendList(descriptionStart(), descriptionSeparator(), descriptionEnd(), + Arrays.asList(elementMatchers)); + } + + /** + * Returns the string that starts the description. + * + * Can be overridden in subclasses to customise how the matcher is + * described. + */ + protected String descriptionStart() { + return "["; + } + + /** + * Returns the string that separates the elements in the description. + * + * Can be overridden in subclasses to customise how the matcher is + * described. + */ + protected String descriptionSeparator() { + return ", "; + } + + /** + * Returns the string that ends the description. + * + * Can be overridden in subclasses to customise how the matcher is + * described. + */ + protected String descriptionEnd() { + return "]"; + } + + public static <T> IsArray<T> array(Matcher<T>... elementMatchers) { + return new IsArray<T>(elementMatchers); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java new file mode 100644 index 0000000..76ddf9d --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java @@ -0,0 +1,42 @@ +package org.hamcrest.collection; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeMatcher; +import static org.hamcrest.core.IsEqual.equalTo; + +public class IsArrayContaining<T> extends TypeSafeMatcher<T[]> { + + private final Matcher<T> elementMatcher; + + public IsArrayContaining(Matcher<T> elementMatcher) { + this.elementMatcher = elementMatcher; + } + + public boolean matchesSafely(T[] array) { + for (T item : array) { + if (elementMatcher.matches(item)) { + return true; + } + } + return false; + } + + public void describeTo(Description description) { + description + .appendText("an array containing ") + .appendDescriptionOf(elementMatcher); + } + + @Factory + public static <T> Matcher<T[]> hasItemInArray(Matcher<T> elementMatcher) { + return new IsArrayContaining<T>(elementMatcher); + } + + @Factory + public static <T> Matcher<T[]> hasItemInArray(T element) { + return hasItemInArray(equalTo(element)); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionContaining.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionContaining.java new file mode 100644 index 0000000..ba98630 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionContaining.java @@ -0,0 +1,65 @@ +package org.hamcrest.collection; + +import static org.hamcrest.core.AllOf.allOf; +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeMatcher; +import static org.hamcrest.core.IsEqual.equalTo; + +import java.util.Collection; +import java.util.ArrayList; + +public class IsCollectionContaining<T> extends TypeSafeMatcher<Iterable<T>> { + private final Matcher<? extends T> elementMatcher; + + public IsCollectionContaining(Matcher<? extends T> elementMatcher) { + this.elementMatcher = elementMatcher; + } + + public boolean matchesSafely(Iterable<T> collection) { + for (T item : collection) { + if (elementMatcher.matches(item)){ + return true; + } + } + return false; + } + + public void describeTo(Description description) { + description + .appendText("a collection containing ") + .appendDescriptionOf(elementMatcher); + } + + @Factory + public static <T> Matcher<Iterable<T>> hasItem(Matcher<? extends T> elementMatcher) { + return new IsCollectionContaining<T>(elementMatcher); + } + + @Factory + public static <T> Matcher<Iterable<T>> hasItem(T element) { + return hasItem(equalTo(element)); + } + + @Factory + public static <T> Matcher<Iterable<T>> hasItems(Matcher<? extends T>... elementMatchers) { + Collection<Matcher<? extends Iterable<T>>> all + = new ArrayList<Matcher<? extends Iterable<T>>>(elementMatchers.length); + for (Matcher<? extends T> elementMatcher : elementMatchers) { + all.add(hasItem(elementMatcher)); + } + return allOf(all); + } + + @Factory + public static <T> Matcher<Iterable<T>> hasItems(T... elements) { + Collection<Matcher<? extends Iterable<T>>> all + = new ArrayList<Matcher<? extends Iterable<T>>>(elements.length); + for (T element : elements) { + all.add(hasItem(element)); + } + return allOf(all); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java new file mode 100644 index 0000000..0a7bbb5 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java @@ -0,0 +1,45 @@ +package org.hamcrest.collection; + +import java.util.Arrays; +import java.util.Collection; + +import org.hamcrest.BaseMatcher; +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.Matcher; + +public class IsIn<T> extends BaseMatcher<T> { + private final Collection<T> collection; + + public IsIn(Collection<T> collection) { + this.collection = collection; + } + + public IsIn(T[] elements) { + collection = Arrays.asList(elements); + } + + public boolean matches(Object o) { + return collection.contains(o); + } + + public void describeTo(Description buffer) { + buffer.appendText("one of "); + buffer.appendValueList("{", ", ", "}", collection); + } + + @Factory + public static <T> Matcher<T> isIn(Collection<T> collection) { + return new IsIn<T>(collection); + } + + @Factory + public static <T> Matcher<T> isIn(T[] elements) { + return new IsIn<T>(elements); + } + + @Factory + public static <T> Matcher<T> isOneOf(T... elements) { + return isIn(elements); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java new file mode 100644 index 0000000..74572dd --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java @@ -0,0 +1,70 @@ +package org.hamcrest.collection; + +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; +import org.hamcrest.core.IsAnything; + +import static org.hamcrest.core.IsEqual.equalTo; + +import java.util.Map; +import java.util.Map.Entry; + +public class IsMapContaining<K,V> extends TypeSafeMatcher<Map<K, V>> { + + private final Matcher<K> keyMatcher; + private final Matcher<V> valueMatcher; + + public IsMapContaining(Matcher<K> keyMatcher, Matcher<V> valueMatcher) { + this.keyMatcher = keyMatcher; + this.valueMatcher = valueMatcher; + } + + public boolean matchesSafely(Map<K, V> map) { + for (Entry<K, V> entry : map.entrySet()) { + if (keyMatcher.matches(entry.getKey()) && valueMatcher.matches(entry.getValue())) { + return true; + } + } + return false; + } + + public void describeTo(Description description) { + description.appendText("map containing [") + .appendDescriptionOf(keyMatcher) + .appendText("->") + .appendDescriptionOf(valueMatcher) + .appendText("]"); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasEntry(Matcher<K> keyMatcher, Matcher<V> valueMatcher) { + return new IsMapContaining<K,V>(keyMatcher, valueMatcher); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasEntry(K key, V value) { + return hasEntry(equalTo(key), equalTo(value)); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasKey(Matcher<K> keyMatcher) { + return hasEntry(keyMatcher, IsAnything.<V>anything()); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasKey(K key) { + return hasKey(equalTo(key)); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasValue(Matcher<V> valueMatcher) { + return hasEntry(IsAnything.<K>anything(), valueMatcher); + } + + @Factory + public static <K,V> Matcher<Map<K,V>> hasValue(V value) { + return hasValue(equalTo(value)); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/package.html b/hamcrest-library/src/main/java/org/hamcrest/collection/package.html new file mode 100644 index 0000000..6248d8d --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/collection/package.html @@ -0,0 +1,7 @@ +<html> +<head> +</head> +<body> + <p>Matchers of arrays and collections.</p> +</body> +</html> diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java b/hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java new file mode 100644 index 0000000..dc183e8 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java @@ -0,0 +1,40 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.number; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeMatcher; + + +/** + * Is the value a number equal to a value within some range of + * acceptable error? + */ +public class IsCloseTo extends TypeSafeMatcher<Double> { + private final double error; + private final double value; + + public IsCloseTo(double value, double error) { + this.error = error; + this.value = value; + } + + public boolean matchesSafely(Double item) { + return Math.abs((item - value)) <= error; + } + + public void describeTo(Description description) { + description.appendText("a numeric value within ") + .appendValue(error) + .appendText(" of ") + .appendValue(value); + } + + @Factory + public static Matcher<Double> closeTo(double operand, double error) { + return new IsCloseTo(operand, error); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/IsGreaterThan.java b/hamcrest-library/src/main/java/org/hamcrest/number/IsGreaterThan.java new file mode 100644 index 0000000..34046b7 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/number/IsGreaterThan.java @@ -0,0 +1,26 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.number; + +import org.hamcrest.Description; +import org.hamcrest.TypeSafeMatcher; + +/** + * Is the value less than or greater than another {@link java.lang.Comparable} value? + */ +public class IsGreaterThan<T extends Comparable<T>> extends TypeSafeMatcher<T> { + private final Comparable<T> compareTo; + + public IsGreaterThan(Comparable<T> compareTo) { + this.compareTo = compareTo; + } + + public boolean matchesSafely(T item) { + return compareTo.compareTo(item) < 0; + } + + public void describeTo(Description description) { + description.appendText("a value greater than "); + description.appendValue(compareTo); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparisons.java b/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparisons.java new file mode 100644 index 0000000..1791a40 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparisons.java @@ -0,0 +1,38 @@ +package org.hamcrest.number; + +import static org.hamcrest.core.AnyOf.anyOf; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsNot.not; +import static org.hamcrest.core.DescribedAs.describedAs; + +import org.hamcrest.Factory; +import org.hamcrest.Matcher; + +@SuppressWarnings("unchecked") +public class OrderingComparisons { + @Factory + public static <T extends Comparable<T>> Matcher<T> greaterThan(T value) { + return new IsGreaterThan<T>(value); + } + + @Factory + public static <T extends Comparable<T>> Matcher<T> greaterThanOrEqualTo(T value) { + return describedAs("a value greater than or equal to %0", + anyOf(greaterThan(value), equalTo(value)), + value); + } + + @Factory + public static <T extends Comparable<T>> Matcher<T> lessThan(T value) { + return describedAs("a value less than %0", + not(greaterThanOrEqualTo(value)), + value); + } + + @Factory + public static <T extends Comparable<T>> Matcher<T> lessThanOrEqualTo(T value) { + return describedAs("a value less than or equal to %0", + not(greaterThan(value)), + value); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/package.html b/hamcrest-library/src/main/java/org/hamcrest/number/package.html new file mode 100644 index 0000000..2fbb07f --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/number/package.html @@ -0,0 +1,7 @@ +<html> +<head> +</head> +<body> + <p>Matchers that perform numeric comparisons.</p> +</body> +</html> diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java b/hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java new file mode 100644 index 0000000..0f12ffd --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java @@ -0,0 +1,31 @@ +package org.hamcrest.object; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.BaseMatcher; + +public class HasToString<T> extends BaseMatcher<T> { + + private final Matcher<String> toStringMatcher; + + public HasToString(Matcher<String> toStringMatcher) { + this.toStringMatcher = toStringMatcher; + } + + public boolean matches(Object item) { + return item != null && toStringMatcher.matches(item.toString()); + } + + public void describeTo(Description description) { + description + .appendText("asString(") + .appendDescriptionOf(toStringMatcher) + .appendText(")"); + } + + @Factory + public static <T> Matcher<T> hasToString(Matcher<String> toStringMatcher) { + return new HasToString<T>(toStringMatcher); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java b/hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java new file mode 100644 index 0000000..3a2dc7a --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java @@ -0,0 +1,27 @@ +package org.hamcrest.object; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeMatcher; + +public class IsCompatibleType<T> extends TypeSafeMatcher<Class<?>> { + private final Class<T> type; + + public IsCompatibleType(Class<T> type) { + this.type = type; + } + + public boolean matchesSafely(Class<?> cls) { + return type.isAssignableFrom(cls); + } + + public void describeTo(Description description) { + description.appendText("type < ").appendText(type.getName()); + } + + @Factory + public static <T> Matcher<Class<?>> typeCompatibleWith(Class<T> baseType) { + return new IsCompatibleType<T>(baseType); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java b/hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java new file mode 100644 index 0000000..504a8f5 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java @@ -0,0 +1,59 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.object; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeMatcher; + +import java.util.EventObject; + + +/** + * Tests if the value is an event announced by a specific object. + */ +public class IsEventFrom extends TypeSafeMatcher<EventObject> { + private final Class eventClass; + private final Object source; + + public IsEventFrom(Class eventClass, Object source) { + this.eventClass = eventClass; + this.source = source; + } + + public boolean matchesSafely(EventObject item) { + return eventClass.isInstance(item) + && eventHasSameSource(item); + } + + private boolean eventHasSameSource(EventObject ev) { + return ev.getSource() == source; + } + + public void describeTo(Description description) { + description.appendText("an event of type ") + .appendText(eventClass.getName()) + .appendText(" from ") + .appendValue(source); + } + + /** + * Constructs an IsEventFrom Matcher that returns true for any object + * derived from <var>eventClass</var> announced by <var>source</var>. + */ + @Factory + public static Matcher<EventObject> eventFrom(Class<? extends EventObject> eventClass, Object source) { + return new IsEventFrom(eventClass, source); + } + + /** + * Constructs an IsEventFrom Matcher that returns true for any object + * derived from {@link java.util.EventObject} announced by <var>source + * </var>. + */ + @Factory + public static Matcher<EventObject> eventFrom(Object source) { + return eventFrom(EventObject.class, source); + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/package.html b/hamcrest-library/src/main/java/org/hamcrest/object/package.html new file mode 100644 index 0000000..2fde62c --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/object/package.html @@ -0,0 +1,7 @@ +<html> +<head> +</head> +<body> + <p>Matchers that inspect objects and classes.</p> +</body> +</html> diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java b/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java new file mode 100644 index 0000000..cc78c71 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java @@ -0,0 +1,42 @@ +/* Copyright (c) 2000-2006 hamcrest.org
+ */
+package org.hamcrest.text;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.Factory;
+import org.hamcrest.TypeSafeMatcher;
+
+/**
+ * Tests if a string is equal to another string, regardless of the case.
+ */
+public class IsEqualIgnoringCase extends TypeSafeMatcher<String> {
+
+ // TODO: Replace String with CharSequence to allow for easy interopability between
+ // String, StringBuffer, StringBuilder, CharBuffer, etc (joe).
+
+ private final String string;
+
+ public IsEqualIgnoringCase(String string) {
+ if (string == null) {
+ throw new IllegalArgumentException("Non-null value required by IsEqualIgnoringCase()");
+ }
+ this.string = string;
+ }
+
+ public boolean matchesSafely(String item) {
+ return string.equalsIgnoreCase(item);
+ }
+
+ public void describeTo(Description description) {
+ description.appendText("eqIgnoringCase(")
+ .appendValue(string)
+ .appendText(")");
+ }
+
+ @Factory
+ public static Matcher<String> equalToIgnoringCase(String string) {
+ return new IsEqualIgnoringCase(string);
+ }
+
+}
diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java b/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java new file mode 100644 index 0000000..dd390e8 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java @@ -0,0 +1,60 @@ +/* Copyright (c) 2000-2006 hamcrest.org
+ */
+package org.hamcrest.text;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.Factory;
+import org.hamcrest.TypeSafeMatcher;
+
+/**
+ * Tests if a string is equal to another string, ignoring any changes in whitespace.
+ */
+public class IsEqualIgnoringWhiteSpace extends TypeSafeMatcher<String> {
+
+ // TODO: Replace String with CharSequence to allow for easy interopability between
+ // String, StringBuffer, StringBuilder, CharBuffer, etc (joe).
+
+ private final String string;
+
+ public IsEqualIgnoringWhiteSpace(String string) {
+ if (string == null) {
+ throw new IllegalArgumentException("Non-null value required by IsEqualIgnoringCase()");
+ }
+ this.string = string;
+ }
+
+ public boolean matchesSafely(String item) {
+ return stripSpace(string).equalsIgnoreCase(stripSpace(item));
+ }
+
+ public void describeTo(Description description) {
+ description.appendText("eqIgnoringWhiteSpace(")
+ .appendValue(string)
+ .appendText(")");
+ }
+
+ public String stripSpace(String string) {
+ StringBuilder result = new StringBuilder();
+ boolean lastWasSpace = true;
+ for (int i = 0; i < string.length(); i++) {
+ char c = string.charAt(i);
+ if (Character.isWhitespace(c)) {
+ if (!lastWasSpace) {
+ result.append(' ');
+ }
+ lastWasSpace = true;
+ } else {
+ result.append(c);
+ lastWasSpace = false;
+ }
+ }
+ return result.toString().trim();
+ }
+
+ @Factory
+ public static Matcher<String> equalToIgnoringWhiteSpace(String string) {
+ return new IsEqualIgnoringWhiteSpace(string);
+ }
+
+}
diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/StringContains.java b/hamcrest-library/src/main/java/org/hamcrest/text/StringContains.java new file mode 100644 index 0000000..9e55560 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/StringContains.java @@ -0,0 +1,29 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.text; + +import org.hamcrest.Factory; +import org.hamcrest.Matcher; + +/** + * Tests if the argument is a string that contains a substring. + */ +public class StringContains extends SubstringMatcher { + public StringContains(String substring) { + super(substring); + } + + protected boolean evalSubstringOf(String s) { + return s.indexOf(substring) >= 0; + } + + protected String relationship() { + return "containing"; + } + + @Factory + public static Matcher<String> containsString(String substring) { + return new StringContains(substring); + } + +}
\ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/StringEndsWith.java b/hamcrest-library/src/main/java/org/hamcrest/text/StringEndsWith.java new file mode 100644 index 0000000..10e4764 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/StringEndsWith.java @@ -0,0 +1,29 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.text; + +import org.hamcrest.Factory; +import org.hamcrest.Matcher; + +/** + * Tests if the argument is a string that contains a substring. + */ +public class StringEndsWith extends SubstringMatcher { + public StringEndsWith(String substring) { + super(substring); + } + + protected boolean evalSubstringOf(String s) { + return s.endsWith(substring); + } + + protected String relationship() { + return "ending with"; + } + + @Factory + public static Matcher<String> endsWith(String substring) { + return new StringEndsWith(substring); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/StringStartsWith.java b/hamcrest-library/src/main/java/org/hamcrest/text/StringStartsWith.java new file mode 100644 index 0000000..4613101 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/StringStartsWith.java @@ -0,0 +1,29 @@ +/* Copyright (c) 2000-2006 hamcrest.org + */ +package org.hamcrest.text; + +import org.hamcrest.Factory; +import org.hamcrest.Matcher; + +/** + * Tests if the argument is a string that contains a substring. + */ +public class StringStartsWith extends SubstringMatcher { + public StringStartsWith(String substring) { + super(substring); + } + + protected boolean evalSubstringOf(String s) { + return s.startsWith(substring); + } + + protected String relationship() { + return "starting with"; + } + + @Factory + public static Matcher<String> startsWith(String substring) { + return new StringStartsWith(substring); + } + +}
\ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/SubstringMatcher.java b/hamcrest-library/src/main/java/org/hamcrest/text/SubstringMatcher.java new file mode 100644 index 0000000..8ebe739 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/SubstringMatcher.java @@ -0,0 +1,31 @@ +package org.hamcrest.text; + +import org.hamcrest.Description; +import org.hamcrest.TypeSafeMatcher; + +public abstract class SubstringMatcher extends TypeSafeMatcher<String> { + + // TODO: Replace String with CharSequence to allow for easy interopability between + // String, StringBuffer, StringBuilder, CharBuffer, etc (joe). + + protected final String substring; + + protected SubstringMatcher(final String substring) { + this.substring = substring; + } + + public boolean matchesSafely(String item) { + return evalSubstringOf(item); + } + + public void describeTo(Description description) { + description.appendText("a string ") + .appendText(relationship()) + .appendText(" ") + .appendValue(substring); + } + + protected abstract boolean evalSubstringOf(String string); + + protected abstract String relationship(); +}
\ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/X.java b/hamcrest-library/src/main/java/org/hamcrest/text/X.java new file mode 100644 index 0000000..7e85bd9 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/X.java @@ -0,0 +1,18 @@ +package org.hamcrest.text; + +import org.hamcrest.Matcher; +import org.hamcrest.CoreMatchers; + +public class X { + + public static void main(String[] args) { + + x(CoreMatchers.any(String.class)); + + + } + + private static void x(Matcher<String> s) { + + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/package.html b/hamcrest-library/src/main/java/org/hamcrest/text/package.html new file mode 100644 index 0000000..8cf576f --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/text/package.html @@ -0,0 +1,7 @@ +<html> +<head> +</head> +<body> + <p>Matchers that perform text comparisons.</p> +</body> +</html> diff --git a/hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java b/hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java new file mode 100644 index 0000000..742935b --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java @@ -0,0 +1,74 @@ +package org.hamcrest.xml; + +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; +import org.w3c.dom.Node; + +import javax.xml.xpath.XPath; +import javax.xml.xpath.XPathConstants; +import javax.xml.xpath.XPathExpression; +import javax.xml.xpath.XPathExpressionException; +import javax.xml.xpath.XPathFactory; + +/** + * Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression. + * + * @author Joe Walnes + */ +public class HasXPath extends TypeSafeMatcher<Node> { + + private final Matcher<String> valueMatcher; + private final XPathExpression compiledXPath; + private final String xpathString; + + /** + * @param xPathExpression XPath expression. + * @param valueMatcher Matcher to use at given XPath. + * May be null to specify that the XPath must exist but the value is irrelevant. + */ + public HasXPath(String xPathExpression, Matcher<String> valueMatcher) { + try { + XPath xPath = XPathFactory.newInstance().newXPath(); + compiledXPath = xPath.compile(xPathExpression); + this.xpathString = xPathExpression; + this.valueMatcher = valueMatcher; + } catch (XPathExpressionException e) { + throw new IllegalArgumentException("Invalid XPath : " + xPathExpression, e); + } + } + + public boolean matchesSafely(Node item) { + try { + String result = (String) compiledXPath.evaluate(item, XPathConstants.STRING); + if (result == null) { + return false; + } else if (valueMatcher == null) { + return !result.equals(""); + } else { + return valueMatcher.matches(result); + } + } catch (XPathExpressionException e) { + return false; + } + } + + public void describeTo(Description description) { + description.appendText("an XML document with XPath ").appendText(xpathString); + if (valueMatcher != null) { + description.appendText(" ").appendDescriptionOf(valueMatcher); + } + } + + @Factory + public static Matcher<Node> hasXPath(String xPath, Matcher<String> valueMatcher) { + return new HasXPath(xPath, valueMatcher); + } + + @Factory + public static Matcher<Node> hasXPath(String xPath) { + return hasXPath(xPath, null); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/xml/package.html b/hamcrest-library/src/main/java/org/hamcrest/xml/package.html new file mode 100644 index 0000000..d9c5f97 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/xml/package.html @@ -0,0 +1,7 @@ +<html> +<head> +</head> +<body> + <p>Matchers of XML documents.</p> +</body> +</html> |