Uses of Class org.hamcrest.Factory (Hamcrest)
Date: 2012-07-09

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
org.hamcrest.Factory

Packages that use Factory
org.hamcrest.beans | Matchers of Java Bean properties and their values.
org.hamcrest.collection | Matchers of arrays and collections.
org.hamcrest.core | Fundamental matchers of objects and values, and composite matchers.
org.hamcrest.number | Matchers that perform numeric comparisons.
org.hamcrest.object | Matchers that inspect objects and classes.
org.hamcrest.text | Matchers that perform text comparisons.
org.hamcrest.xml | Matchers of XML documents.

Uses of Factory in org.hamcrest.beans

Methods in org.hamcrest.beans with annotations of type Factory
`static
`<T> Matcher<T>`
` | `HasProperty.hasProperty(java.lang.String propertyName)` Creates a matcher that matches when the examined object has a JavaBean property with the specified name.
`static
`<T> Matcher<T>`
` | `HasPropertyWithValue.hasProperty(java.lang.String propertyName, Matcher<?> valueMatcher)` Creates a matcher that matches when the examined object has a JavaBean property with the specified name whose value satisfies the specified matcher.
`static
`<T> Matcher<T>`
` | `SamePropertyValuesAs.samePropertyValuesAs(T expectedBean)` Creates a matcher that matches when the examined object has values for all of its JavaBean properties that are equal to the corresponding values of the specified bean.

Uses of Factory in org.hamcrest.collection

Methods in org.hamcrest.collection with annotations of type Factory
`static
`<T> IsArray<T>`
` | `IsArray.array(Matcher<? super T>... elementMatchers)` Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInOrder.arrayContaining(E... items)` Creates a matcher for arrays that matcheswhen each item in the examined array is logically equal to the corresponding item in the specified items.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInOrder.arrayContaining(java.util.List<Matcher<? super E>> itemMatchers)` Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified list of matchers.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInOrder.arrayContaining(Matcher<? super E>... itemMatchers)` Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified matchers.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> itemMatchers)` Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified collection of matchers.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(E... items)` Creates an order agnostic matcher for arrays that matches when each item in the examined array is logically equal to one item anywhere in the specified items.
`static
`<E> Matcher<E[]>`
` | `IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers)` Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified matchers.
`static
`<E> Matcher<E[]>`
` | `IsArrayWithSize.arrayWithSize(int size)` Creates a matcher for arrays that matches when the `length` of the array equals the specified `size`.
`static
`<E> Matcher<E[]>`
` | `IsArrayWithSize.arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)` Creates a matcher for arrays that matches when the `length` of the array satisfies the specified matcher.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsIterableContainingInOrder.contains(E... items)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each logically equal to the corresponding item in the specified items.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsIterableContainingInOrder.contains(java.util.List<Matcher<? super E>> itemMatchers)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying the corresponding matcher in the specified list of matchers.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsIterableContainingInOrder.contains(Matcher<? super E>... itemMatchers)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying the corresponding matcher in the specified matchers.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsIterableContainingInOrder.contains(Matcher<? super E> itemMatcher)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a single item that satisfies the specified matcher.
`static
`<T> Matcher<java.lang.Iterable<? extends T>>`
` | `IsIterableContainingInAnyOrder.containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying one matcher anywhere in the specified collection of matchers.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsIterableContainingInAnyOrder.containsInAnyOrder(Matcher<? super E> itemMatcher)` Deprecated. use contains(Matcher itemMatcher) instead
`static
`<T> Matcher<java.lang.Iterable<? extends T>>`
` | `IsIterableContainingInAnyOrder.containsInAnyOrder(Matcher<? super T>... itemMatchers)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying one matcher anywhere in the specified matchers.
`static
`<T> Matcher<java.lang.Iterable<? extends T>>`
` | `IsIterableContainingInAnyOrder.containsInAnyOrder(T... items)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each logically equal to one item anywhere in the specified items.
`static
`<E> Matcher<java.util.Collection<? extends E>>`
` | `IsEmptyCollection.empty()` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
`static
`<E> Matcher<E[]>`
` | `IsArrayWithSize.emptyArray()` Creates a matcher for arrays that matches when the `length` of the array is zero.
`static
`<E> Matcher<java.util.Collection<E>>`
` | `IsEmptyCollection.emptyCollectionOf(java.lang.Class<E> type)` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
`static
`<E> Matcher<java.lang.Iterable<? extends E>>`
` | `IsEmptyIterable.emptyIterable()` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
`static
`<E> Matcher<java.lang.Iterable<E>>`
` | `IsEmptyIterable.emptyIterableOf(java.lang.Class<E> type)` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
`static
`<K,V> Matcher<java.util.Map<? extends K,? extends V>>`
` | `IsMapContaining.hasEntry(K key, V value)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one entry whose key equals the specified `key` and whose value equals the specified `value`.
`static
`<K,V> Matcher<java.util.Map<? extends K,? extends V>>`
` | `IsMapContaining.hasEntry(Matcher<? super K> keyMatcher, Matcher<? super V> valueMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one entry whose key satisfies the specified `keyMatcher` and whose value satisfies the specified `valueMatcher`.
`static
`<T> Matcher<T[]>`
` | `IsArrayContaining.hasItemInArray(Matcher<? super T> elementMatcher)` Creates a matcher for arrays that matches when the examined array contains at least one item that is matched by the specified `elementMatcher`.
`static
`<T> Matcher<T[]>`
` | `IsArrayContaining.hasItemInArray(T element)` A shortcut to the frequently used `hasItemInArray(equalTo(x))`.
`static
`<K> Matcher<java.util.Map<? extends K,?>>`
` | `IsMapContaining.hasKey(K key)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one key that is equal to the specified key.
`static
`<K> Matcher<java.util.Map<? extends K,?>>`
` | `IsMapContaining.hasKey(Matcher<? super K> keyMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one key that satisfies the specified matcher.
`static
`<E> Matcher<java.util.Collection<? extends E>>`
` | `IsCollectionWithSize.hasSize(int size)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value equal to the specified `size`.
`static
`<E> Matcher<java.util.Collection<? extends E>>`
` | `IsCollectionWithSize.hasSize(Matcher<? super java.lang.Integer> sizeMatcher)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value that satisfies the specified matcher.
`static
`<V> Matcher<java.util.Map<?,? extends V>>`
` | `IsMapContaining.hasValue(Matcher<? super V> valueMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one value that satisfies the specified valueMatcher.
`static
`<V> Matcher<java.util.Map<?,? extends V>>`
` | `IsMapContaining.hasValue(V value)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one value that is equal to the specified value.
`static
`<T> Matcher<T>`
` | `IsIn.isIn(java.util.Collection<T> collection)` Creates a matcher that matches when the examined object is found within the specified collection.
`static
`<T> Matcher<T>`
` | `IsIn.isIn(T[] elements)` Creates a matcher that matches when the examined object is found within the specified array.
`static
`<T> Matcher<T>`
` | `IsIn.isOneOf(T... elements)` Creates a matcher that matches when the examined object is equal to one of the specified elements.
`static
`<E> Matcher<java.lang.Iterable<E>>`
` | `IsIterableWithSize.iterableWithSize(int size)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields an item count that is equal to the specified `size` argument.
`static
`<E> Matcher<java.lang.Iterable<E>>`
` | `IsIterableWithSize.iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields an item count that satisfies the specified matcher.

Uses of Factory in org.hamcrest.core

Methods in org.hamcrest.core with annotations of type Factory
`static
`<T> Matcher<T>`
` | `AllOf.allOf(java.lang.Iterable<Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T> first, Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `AllOf.allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`static
`<T> Matcher<T>`
` | `IsInstanceOf.any(java.lang.Class<T> type)` Creates a matcher that matches when the examined object is an instance of the specified `type`, as determined by calling the `Class.isInstance(Object)` method on that type, passing the the examined object.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(java.lang.Iterable<Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<T> first, Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static
`<T> AnyOf<T>`
` | `AnyOf.anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`static Matcher<java.lang.Object>` | `IsAnything.anything()` Creates a matcher that always matches, regardless of the examined object.
`static Matcher<java.lang.Object>` | `IsAnything.anything(java.lang.String description)` Creates a matcher that always matches, regardless of the examined object, but describes itself with the specified `String`.
`static
`<LHS> CombinableMatcher.CombinableBothMatcher<LHS>`
` | `CombinableMatcher.both(Matcher<? super LHS> matcher)` Creates a matcher that matches when both of the specified matchers match the examined object.
`static Matcher<java.lang.String>` | `StringContains.containsString(java.lang.String substring)` Creates a matcher that matches if the examined `String` contains the specified `String` anywhere.
`static
`<T> Matcher<T>`
` | `DescribedAs.describedAs(java.lang.String description, Matcher<T> matcher, java.lang.Object... values)` Wraps an existing matcher, overriding its description with that specified.
`static
`<LHS> CombinableMatcher.CombinableEitherMatcher<LHS>`
` | `CombinableMatcher.either(Matcher<? super LHS> matcher)` Creates a matcher that matches when either of the specified matchers match the examined object.
`static Matcher<java.lang.String>` | `StringEndsWith.endsWith(java.lang.String suffix)` Creates a matcher that matches if the examined `String` ends with the specified `String`.
`static
`<T> Matcher<T>`
` | `IsEqual.equalTo(T operand)` Creates a matcher that matches when the examined object is logically equal to the specified `operand`, as determined by calling the `Object.equals(java.lang.Object)` method on the examined object.
`static
`<U> Matcher<java.lang.Iterable<U>>`
` | `Every.everyItem(Matcher<U> itemMatcher)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields items that are all matched by the specified `itemMatcher`.
`static
`<T> Matcher<java.lang.Iterable<? super T>>`
` | `IsCollectionContaining.hasItem(Matcher<? super T> itemMatcher)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields at least one item that is matched by the specified `itemMatcher`.
`static
`<T> Matcher<java.lang.Iterable<? super T>>`
` | `IsCollectionContaining.hasItem(T item)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields at least one item that is equal to the specified `item`.
`static
`<T> Matcher<java.lang.Iterable<T>>`
` | `IsCollectionContaining.hasItems(Matcher<? super T>... itemMatchers)` Creates a matcher for `Iterable`s that matches when consecutive passes over the examined `Iterable` yield at least one item that is matched by the corresponding matcher from the specified `itemMatchers`.
`static
`<T> Matcher<java.lang.Iterable<T>>`
` | `IsCollectionContaining.hasItems(T... items)` Creates a matcher for `Iterable`s that matches when consecutive passes over the examined `Iterable` yield at least one item that is equal to the corresponding item from the specified `items`.
`static
`<T> Matcher<T>`
` | `IsInstanceOf.instanceOf(java.lang.Class<?> type)` Creates a matcher that matches when the examined object is an instance of the specified `type`, as determined by calling the `Class.isInstance(Object)` method on that type, passing the the examined object.
`static
`<T> Matcher<T>`
` | `Is.is(java.lang.Class<T> type)` Deprecated. use isA(Class type) instead.
`static
`<T> Matcher<T>`
` | `Is.is(Matcher<T> matcher)` Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive.
`static
`<T> Matcher<T>`
` | `Is.is(T value)` A shortcut to the frequently used `is(equalTo(x))`.
`static
`<T> Matcher<T>`
` | `Is.isA(java.lang.Class<T> type)` A shortcut to the frequently used `is(instanceOf(SomeClass.class))`.
`static
`<T> Matcher<T>`
` | `IsNot.not(Matcher<T> matcher)` Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match.
`static
`<T> Matcher<T>`
` | `IsNot.not(T value)` A shortcut to the frequently used `not(equalTo(x))`.
`static Matcher<java.lang.Object>` | `IsNull.notNullValue()` A shortcut to the frequently used `not(nullValue())`.
`static
`<T> Matcher<T>`
` | `IsNull.notNullValue(java.lang.Class<T> type)` A shortcut to the frequently used `not(nullValue(X.class)).`
`static Matcher<java.lang.Object>` | `IsNull.nullValue()` Creates a matcher that matches if examined object is `null`.
`static
`<T> Matcher<T>`
` | `IsNull.nullValue(java.lang.Class<T> type)` Creates a matcher that matches if examined object is `null`.
`static
`<T> Matcher<T>`
` | `IsSame.sameInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.
`static Matcher<java.lang.String>` | `StringStartsWith.startsWith(java.lang.String prefix)` Creates a matcher that matches if the examined `String` starts with the specified `String`.
`static
`<T> Matcher<T>`
` | `IsSame.theInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.

Uses of Factory in org.hamcrest.number

Methods in org.hamcrest.number with annotations of type Factory
`static Matcher<java.math.BigDecimal>` | `BigDecimalCloseTo.closeTo(java.math.BigDecimal operand, java.math.BigDecimal error)` Creates a matcher of `BigDecimal`s that matches when an examined BigDecimal is equal to the specified `operand`, within a range of +/- `error`.
`static Matcher<java.lang.Double>` | `IsCloseTo.closeTo(double operand, double error)` Creates a matcher of `Double`s that matches when an examined double is equal to the specified `operand`, within a range of +/- `error`.
`static
`<T extends java.lang.Comparable<T>> Matcher<T>`
` | `OrderingComparison.comparesEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is equal to the specified value, as reported by the `compareTo` method of the examined object.
`static
`<T extends java.lang.Comparable<T>> Matcher<T>`
` | `OrderingComparison.greaterThan(T value)` Creates a matcher of `Comparable` object that matches when the examined object is greater than the specified value, as reported by the `compareTo` method of the examined object.
`static
`<T extends java.lang.Comparable<T>> Matcher<T>`
` | `OrderingComparison.greaterThanOrEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is greater than or equal to the specified value, as reported by the `compareTo` method of the examined object.
`static
`<T extends java.lang.Comparable<T>> Matcher<T>`
` | `OrderingComparison.lessThan(T value)` Creates a matcher of `Comparable` object that matches when the examined object is less than the specified value, as reported by the `compareTo` method of the examined object.
`static
`<T extends java.lang.Comparable<T>> Matcher<T>`
` | `OrderingComparison.lessThanOrEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is less than or equal to the specified value, as reported by the `compareTo` method of the examined object.

Uses of Factory in org.hamcrest.object

Methods in org.hamcrest.object with annotations of type Factory
`static Matcher<java.util.EventObject>` | `IsEventFrom.eventFrom(java.lang.Class<? extends java.util.EventObject> eventClass, java.lang.Object source)` Creates a matcher of `EventObject` that matches any object derived from eventClass announced by source.
`static Matcher<java.util.EventObject>` | `IsEventFrom.eventFrom(java.lang.Object source)` Creates a matcher of `EventObject` that matches any EventObject announced by source.
`static
`<T> Matcher<T>`
` | `HasToString.hasToString(Matcher<? super java.lang.String> toStringMatcher)` Creates a matcher that matches any examined object whose `toString` method returns a value that satisfies the specified matcher.
`static
`<T> Matcher<T>`
` | `HasToString.hasToString(java.lang.String expectedToString)` Creates a matcher that matches any examined object whose `toString` method returns a value equalTo the specified string.
`static
`<T> Matcher<java.lang.Class<?>>`
` | `IsCompatibleType.typeCompatibleWith(java.lang.Class<T> baseType)` Creates a matcher of `Class` that matches when the specified baseType is assignable from the examined class.

Uses of Factory in org.hamcrest.text

Methods in org.hamcrest.text with annotations of type Factory
`static Matcher<java.lang.String>` | `IsEqualIgnoringCase.equalToIgnoringCase(java.lang.String expectedString)` Creates a matcher of `String` that matches when the examined string is equal to the specified expectedString, ignoring case.
`static Matcher<java.lang.String>` | `IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace(java.lang.String expectedString)` Creates a matcher of `String` that matches when the examined string is equal to the specified expectedString, when whitespace differences are (mostly) ignored.
`static Matcher<java.lang.String>` | `IsEmptyString.isEmptyOrNullString()` Creates a matcher of `String` that matches when the examined string is `null`, or has zero length.
`static Matcher<java.lang.String>` | `IsEmptyString.isEmptyString()` Creates a matcher of `String` that matches when the examined string has zero length.
`static Matcher<java.lang.String>` | `StringContainsInOrder.stringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)` Creates a matcher of `String` that matches when the examined string contains all of the specified substrings, regardless of the order of their appearance.

Uses of Factory in org.hamcrest.xml

Methods in org.hamcrest.xml with annotations of type Factory
`static Matcher<org.w3c.dom.Node>` | `HasXPath.hasXPath(java.lang.String xPath)` Creates a matcher of `Node`s that matches when the examined node contains a node at the specified `xPath`, with any content.
`static Matcher<org.w3c.dom.Node>` | `HasXPath.hasXPath(java.lang.String xPath, Matcher<java.lang.String> valueMatcher)` Creates a matcher of `Node`s that matches when the examined node has a value at the specified `xPath` that satisfies the specified `valueMatcher`.
`static Matcher<org.w3c.dom.Node>` | `HasXPath.hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext)` Creates a matcher of `Node`s that matches when the examined node contains a node at the specified `xPath` within the specified namespace context, with any content.
`static Matcher<org.w3c.dom.Node>` | `HasXPath.hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, Matcher<java.lang.String> valueMatcher)` Creates a matcher of `Node`s that matches when the examined node has a value at the specified `xPath`, within the specified `namespaceContext`, that satisfies the specified `valueMatcher`.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES