diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 000000000..34477c7e2 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,7 @@ +version: 2 +updates: +- package-ecosystem: gradle + directory: "/" + schedule: + interval: daily + open-pull-requests-limit: 10 diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 000000000..83fbd7fa6 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,33 @@ +name: Gradle Build + +on: [push, pull_request] + +concurrency: + group: ${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + name: Java ${{ matrix.java }} build + runs-on: ubuntu-latest + continue-on-error: ${{ matrix.experimental }} + strategy: + fail-fast: true + matrix: + java: [ 8 ] + experimental: [false] + include: + - java: 17 + experimental: true + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'temurin' + cache: gradle + - name: Build with Gradle + run: ./gradlew clean build javadoc diff --git a/.gitignore b/.gitignore index a6dd54ba1..725179b25 100644 --- a/.gitignore +++ b/.gitignore @@ -1,15 +1,18 @@ -/build -/classes -/bin -/out +build/ +classes/ +bin/ +out/ .DS_Store *~ *.swp -/.idea +.idea/ *.iws *.ipr *.iml +.classpath .gradle - +.project +.settings/ gradle.properties release-key.asc +grade-wrapper.properties diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index f3e8ca3b6..000000000 --- a/.travis.yml +++ /dev/null @@ -1,9 +0,0 @@ -language: java - -jdk: - - openjdk7 - - oraclejdk7 - - oraclejdk8 - -script: - - ./gradlew clean build javadoc diff --git a/BUILDING.txt b/BUILDING.txt deleted file mode 100644 index b5af7f6f9..000000000 --- a/BUILDING.txt +++ /dev/null @@ -1,17 +0,0 @@ - ********************** -********************* Building Hamcrest ********************* - ********************** - ---[ Build requirements ]------------------------------------- - -* JDK 1.7 - ---[ Building from the command line ]------------------------- - -Execute Gradle target: - ./gradlew clean build javadoc - -This will download the correct version of Gradle, do a full -clean build, run all tests and (if successful) package up -a distribution. The resulting builds reside in the 'build' -directory. diff --git a/CHANGES.md b/CHANGES.md new file mode 100644 index 000000000..851be4dc3 --- /dev/null +++ b/CHANGES.md @@ -0,0 +1,192 @@ +# Hamcrest Changes + +## Version 3.1 (Unreleased) + +### Breaking Changes + +* As a result of the bugfix to allow matching against polymorphic collections +([PR #422](https://github.com/hamcrest/JavaHamcrest/pull/422)), the signature of the +`hasItem` and `hasItems` methods has changed. Code relying on the exact signature of +these methods will need to be updated. The following methods are affected: + * `org.hamcrest.CoreMatchers.hasItem` + * `org.hamcrest.CoreMatchers.hasItems` + * `org.hamcrest.Matchers.hasItem` + * `org.hamcrest.Matchers.hasItems` + * `org.hamcrest.core.IsCollectionContaining.hasItem` + * `org.hamcrest.core.IsCollectionContaining.hasItems` + * `org.hamcrest.core.IsIterableContaining.hasItem` + * `org.hamcrest.core.IsIterableContaining.hasItems` + * TODO: decide if these breaking changes should trigger a major version upgrade (i.e v4.0) + +### New Features + +* Optional matchers ([PR #421](https://github.com/hamcrest/JavaHamcrest/pull/421)) +* Matchers for thrown exceptions ([PR #423](https://github.com/hamcrest/JavaHamcrest/pull/423)) + +### Improvements + +* Javadoc improvements and cleanup ([PR #420](https://github.com/hamcrest/JavaHamcrest/pull/420), +[#427](https://github.com/hamcrest/JavaHamcrest/issues/427), +[PR #428](https://github.com/hamcrest/JavaHamcrest/pull/428)) +* Derive version from git tags ([PR #419](https://github.com/hamcrest/JavaHamcrest/pull/419)) +* Migrate all tests to JUnit Jupiter ([PR #424](https://github.com/hamcrest/JavaHamcrest/pull/424)) + +### Bugfixes + +* Allow matching against polymorphic collections ([#252](https://github.com/hamcrest/JavaHamcrest/issues/252), + [PR #422](https://github.com/hamcrest/JavaHamcrest/pull/422)) + +## Version 3.0 (1st August 2024) + +### Breaking Changes + +* From version 3.0, the jar distributed to Maven Central is now compiled to Java 1.8 bytecode, + and is not compatible with previous versions of Java. See + [Issue #331](https://github.com/hamcrest/JavaHamcrest/issues/331) and + [PR #411](https://github.com/hamcrest/JavaHamcrest/issues/411) for details. Developers who use Java 1.7 earlier can still + depend upon `hamcrest-2.2.jar`. + +### Improvements + +* FileMatchersTest simplification ([PR #389](https://github.com/hamcrest/JavaHamcrest/issues/389)) +* License cleanup ([PR #414](https://github.com/hamcrest/JavaHamcrest/issues/414), + [PR #415](https://github.com/hamcrest/JavaHamcrest/issues/415), see also + [#264](https://github.com/hamcrest/JavaHamcrest/issues/264), + [#355](https://github.com/hamcrest/JavaHamcrest/issues/355), + [#396](https://github.com/hamcrest/JavaHamcrest/issues/396),and + [#399](https://github.com/hamcrest/JavaHamcrest/issues/399)) + + +## Version 2.2 (17th October 2019) + +### Improvements + +* AllOf/AnyOf: Pass the matchers to constructor using varargs ([Issue #245](https://github.com/hamcrest/JavaHamcrest/pull/245)) +* Matchers.anyOf: Fix generic bounds compatibility for JDK 11 ([Issue #256](https://github.com/hamcrest/JavaHamcrest/issues/256), [Issue #257](https://github.com/hamcrest/JavaHamcrest/issues/257)) +* AssertionError message is unhelpful when match fails for byte type ([Issue #254](https://github.com/hamcrest/JavaHamcrest/issues/254), [Issue #255](https://github.com/hamcrest/JavaHamcrest/issues/255)) +* Use platform specific line breaks ([PR #267](https://github.com/hamcrest/JavaHamcrest/pull/267)) +* Build now checks for consistent use of spaces ([PR #217](https://github.com/hamcrest/JavaHamcrest/pull/217)) + +### Bugfixes +* Fix compatibility issue for development with Android D8 ([Issue #246](https://github.com/hamcrest/JavaHamcrest/issues/246)) +* Fix typo in license name ([Issue #247](https://github.com/hamcrest/JavaHamcrest/pull/247)) +* 1.3 compatible constructors for string matchers ([Issue #259](https://github.com/hamcrest/JavaHamcrest/issues/259), [Issue #260](https://github.com/hamcrest/JavaHamcrest/issues/260)) +* Fix for split packages with Java 9 modules ([Issue #269](https://github.com/hamcrest/JavaHamcrest/issues/269), [PR #270](https://github.com/hamcrest/JavaHamcrest/pull/270)) + + +## Version 2.1 (21st December 2018) + +### Overview for 2.1 + +After a long hiatus without releases, this version simplifies the packaging of +Hamcrest into a single jar: `hamcrest-.jar`. Other big changes include +Java 9 module compatibility, migrating the code repository from Google Code to +GitHub, along with numerous other new features, improvements and bug fixes. + +### Breaking Changes for 2.1 + +* The way that the project is packaged has changed. This may cause problems with + correctly upgrading transitive dependencies. Refer to the + [Hamcrest Distributables](http://hamcrest.org/JavaHamcrest/distributables.html) + documentation for more information, and in particular, + [Upgrading from Hamcrest 1.x](http://hamcrest.org/JavaHamcrest/distributables.html#upgrading-from-hamcrest-1.x) +* `org.hamcrest.Factory` has been removed. This was only used in old implementations + of the hamcrest build toolchain, and can safely be deleted from client code without + any effect. + +### Changes for 2.1 + +* Documentation updates +* Several JavaDoc improvements and corrections +* Fix JavaDoc examples +* Upgraded to Java 7 +* Build with Gradle +* Publish a single jar `hamcrest-2.1.jar` +* Publish pom-only artifacts for `hamcrest-core` and `hamcrest-library`. +* Add implementation for CharSequence length matcher +* Fix for TypeSafeDiagnosingMatcher can't detect generic types for subclass +* Make Hamcrest an OSGI bundle +* Add StringRegularExpression matcher +* Fix StringContainsInOrder to detect if a repeated pattern is missing +* Add ArrayAsIterableMatcher +* Fix description for IsEqualIgnoringCase +* Removed deprecated methods from previous release +* Improve mismatch description of hasItem/hasItems +* General improvements to mismatch descriptions +* Deprecated several matcher factory methods of the for "isXyz" +* Fix [GH issue #75](https://github.com/hamcrest/JavaHamcrest/issues/75) - address doclint errors reported in JDK 1.8 +* Fix [GH issue #69](https://github.com/hamcrest/JavaHamcrest/issues/69) - Iterable contains in order is null-safe +* Fix [GH issue #59](https://github.com/hamcrest/JavaHamcrest/issues/59) - added equalToObject() (i.e. unchecked) method +* Fix [GH issue #25](https://github.com/hamcrest/JavaHamcrest/issues/25) - arrayContaining(null, null) cause NullPointerException +* Fix [GH issue #36](https://github.com/hamcrest/JavaHamcrest/issues/36) - string matching on regular expressions +* Fix [GH issue #8](https://github.com/hamcrest/JavaHamcrest/issues/8) - isCloseTo() shows wrong delta in mismatch description +* Fix [GH issue #59](https://github.com/hamcrest/JavaHamcrest/issues/59) - add untyped version of equalTo, named equalToObject +* Fix [GC issue #131](https://code.google.com/archive/p/hamcrest/issues/131) - Implement IsEmptyMap, IsMapWithSize +* Fix [GC issue #187](https://code.google.com/archive/p/hamcrest/issues/187) - IsArray.describeMismatchSafely() should use Matcher.describeMismatch +* Fix [GC issue #155](https://code.google.com/archive/p/hamcrest/issues/155) - Add Matcher implementation for files +* Fix [GC issue #69](https://code.google.com/archive/p/hamcrest/issues/69) - fix NPE in IsIterableContainingInOrder + +## Version 1.3 (9th July 2012) + +* Introduce Condition class to ease the implementation of multi-step matches +* Upgrade qdox (included in the generator) to the latest stable version +* Correct inadvertent deprecation of the Is.isA factory method +* Fix [issue #179](https://code.google.com/archive/p/hamcrest/issues/179) - AllOf does not output mismatch description +* Fix [issue #177](https://code.google.com/archive/p/hamcrest/issues/177) - Introduced closeTo matcher for BigDecimals +* Fix [issue #152](https://code.google.com/archive/p/hamcrest/issues/152) - Factory classes missing from matchers.xml +* Fix [issue #144](https://code.google.com/archive/p/hamcrest/issues/144) - OrderingComparison doesn't describe mismatch of comparables that return values other than (-1,0,1) +* Fix [issue #134](https://code.google.com/archive/p/hamcrest/issues/134) - DescribedAs does not delegate describeMismatch +* Fix [issue #106](https://code.google.com/archive/p/hamcrest/issues/106) - deprecation warning when writing custom matchers +* Fix [issue #101](https://code.google.com/archive/p/hamcrest/issues/101) - Added theInstance alias for sameInstance factory method + +## Version 1.3 RC2 (22nd October 2010) + +* Added FeatureMatcher +* distinguish between instanceOf() and any() + +## Version 1.2 (16th May 2009) + +* Added mismatch reporting +* Added WithSamePropertyValuesAs matcher +* Moved any() from IsAnything to IsInstanceOf. It now checks the type of the matched object +* Moved MatcherAssert from integration to core +* Tightened up generics. +* Added IsMapContainingKey and IsMapContainingValue matchers to resolve a + generics bug in hasKey and hasValue static factories previously declared + in IsMapContaining (ngd) +* Added IsCollectionOnlyContaining and IsArrayOnlyContaining which matches + collections (and arrays) where all match a given matcher. E.g onlyContains(3,4,5) + or onlyContains(lessThan(9)) +* text module moved to separate project, hamcrest-text-patterns +* added more colection matchers: xContainingInAnyOrder, xContainingInOrder, xWithSize +* new text Matcher: IsEmptyString +* hamcrest generator uses method return type + +## Version 1.1 (30th June 2007) + +* Hamcrest Generator now includes JavaDoc and parameter names in generated code + by using QDox to parse the source code. +* Created hamcrest-core.jar (and removed hamcrest-api.jar). + Moved core set of matchers (and, eq, not, etc) + to this package to make it more practical for external libraries + to embed Hamcrest. +* Created CoreMatchers (static import sugar) in hamcrest-core.jar. +* StringBuilder can use any Appendable (not just StringBuffer). +* Added sensible toString() method to BaseMatcher. +* Created StringDescription.asString() alias (because toString() caused issues + with static imports). +* Relaxed isInstanceOf() matcher generic type so it can be used on any kind of + object. e.g. assertThat(someUnknownObject, isInstanceOf(String.class)); +* Added any(Class), null(Class) and notNull(Class) matchers, which returns + Matcher. Helpful when the compiler struggles with type inference. +* Modified anyOf() and allOf() to accept mixed-types. +* TypeSafeMatcher.matchesSafely() is now public. +* Generator recognizes @Factory methods that return subclass of Matcher. + (Fix by David Saff) + +## Version 1.0 (15th December 2006) + +Initial release. + +* Support for namespaces in HasXPath +* Bug fix for matching empty elements with HasXPath diff --git a/CHANGES.txt b/CHANGES.txt deleted file mode 100644 index f0a392b95..000000000 --- a/CHANGES.txt +++ /dev/null @@ -1,135 +0,0 @@ -== Version 2.0.0.0 == - -A new beginning... - -* Upgraded to Java 7 - -* Build with Gradle - -* Publish a single jar java-hamcrest-x.x.x.x.jar - -* Removed deprecated methods from previous release - -* Improve mismatch description of hasItem/hasItems - -* General improvements to mismatch descriptions - -* Several JavaDoc improvements and corrections - -* Fix gh issue #69 - Iterable contains in order is null-safe - -* Fix gh issue #59 - added equalToObject() (i.e. unchecked) method - -* Fix gh issue #25 - arrayContaining(null, null) cause NullPointerException - -* Fix gh issue #36 - string matching on regular expressions - -* Fix gh issue #8 - isCloseTo() shows wrong delta in mismatch description - -* Fix issue 131 - Implement IsEmptyMap, IsMapWithSize - -* Fix issue 155 - Deprecated several matcher factory methods of the for "isXyz" - -* Fix issue 187 - IsArray.describeMismatchSafely() should use Matcher.describeMismatch - -* Fix issue 155 - Add Matcher implementation for files - -* Fix issue 59 - add untyped version of equalTo, named equalToObject - -* Fix issue 69 - fix NPE in IsIterableContainingInOrder - -* Fix issue 75 - address doclint errors reported in JDK 1.8 - -== Version 1.3: Released July 09 2012 == - -* Introduce Condition class to ease the implementation of multi-step matches - -* Upgrade qdox (included in the generator) to the latest stable version - -* Correct inadvertent deprecation of the Is.isA factory method - -* Fix issue 179 - AllOf does not output mismatch description - -* Fix issue 177 - Introduced closeTo matcher for BigDecimals - -* Fix issue 152 - Factory classes missing from matchers.xml - -* Fix issue 144 - OrderingComparison doesn't describe mismatch of comparables that return values other than (-1,0,1) - -* Fix issue 134 - DescribedAs does not delegate describeMismatch - -* Fix issue 106 - deprecation warning when writing custom matchers - -* Fix issue 101 - Added theInstance alias for sameInstance factory method - -== Version 1.3 RC2: Released October 22 2010 == - -* Added FeatureMatcher - -* distinguish between instanceOf() and any() - -== Version 1.2: Released May 16 2009 == - -* Added mismatch reporting - -* Added WithSamePropertyValuesAs matcher - -* Moved any() from IsAnything to IsInstanceOf. It now checks the type of the matched object - -* Moved MatcherAssert from integration to core - -* Tightened up generics. - -* Added IsMapContainingKey and IsMapContainingValue matchers to resolve a - generics bug in hasKey and hasValue static factories previously declared - in IsMapContaining (ngd) - -* Added IsCollectionOnlyContaining and IsArrayOnlyContaining which matches - collections (and arrays) where all match a given matcher. E.g onlyContains(3,4,5) - or onlyContains(lessThan(9)) - -* text module moved to separate project, hamcrest-text-patterns - -* added more colection matchers: xContainingInAnyOrder, xContainingInOrder, xWithSize - -* new text Matcher: IsEmptyString - -* hamcrest generator uses method return type - -== Version 1.1: Released Jun 30 2007 == - -* Hamcrest Generator now includes JavaDoc and parameter names in generated code - by using QDox to parse the source code. - -* Created hamcrest-core.jar (and removed hamcrest-api.jar). - Moved core set of matchers (and, eq, not, etc) - to this package to make it more practical for external libraries - to embed Hamcrest. - -* Created CoreMatchers (static import sugar) in hamcrest-core.jar. - -* StringBuilder can use any Appendable (not just StringBuffer). - -* Added sensible toString() method to BaseMatcher. - -* Created StringDescription.asString() alias (because toString() caused issues - with static imports). - -* Relaxed isInstanceOf() matcher generic type so it can be used on any kind of - object. e.g. assertThat(someUnknownObject, isInstanceOf(String.class)); - -* Added any(Class), null(Class) and notNull(Class) matchers, which returns - Matcher. Helpful when the compiler struggles with type inference. - -* Modified anyOf() and allOf() to accept mixed-types. - -* TypeSafeMatcher.matchesSafely() is now public. - -* Generator recognizes @Factory methods that return subclass of Matcher. - (Fix by David Saff) - -== Version 1.0: Released Dec 15 2006 == - -Initial release. -* Support for namespaces in HasXPath -* Bug fix for matching empty elements with HasXPath diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..5a57af22a --- /dev/null +++ b/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2000-2024, www.hamcrest.org + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/LICENSE.txt b/LICENSE.txt deleted file mode 100644 index 1b8690275..000000000 --- a/LICENSE.txt +++ /dev/null @@ -1,27 +0,0 @@ -BSD License - -Copyright (c) 2000-2015 www.hamcrest.org -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list of -conditions and the following disclaimer. Redistributions in binary form must reproduce -the above copyright notice, this list of conditions and the following disclaimer in -the documentation and/or other materials provided with the distribution. - -Neither the name of Hamcrest nor the names of its contributors may be used to endorse -or promote products derived from this software without specific prior written -permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT -SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR -BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY -WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH -DAMAGE. diff --git a/README.md b/README.md index c1e1e0f57..009fdefff 100644 --- a/README.md +++ b/README.md @@ -1,63 +1,68 @@ ![JavaHamcrest](http://hamcrest.org/images/logo.jpg) -[![Build Status](https://travis-ci.org/hamcrest/JavaHamcrest.png?branch=master)](https://travis-ci.org/hamcrest/JavaHamcrest) +[![Build Status](https://github.com/hamcrest/JavaHamcrest/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/hamcrest/JavaHamcrest/actions/workflows/build.yml) +[![Maven Central](https://img.shields.io/maven-central/v/org.hamcrest/hamcrest.svg?label=Maven%20Central)](https://search.maven.org/artifact/org.hamcrest/hamcrest) +[![License](https://img.shields.io/github/license/hamcrest/JavaHamcrest.svg)](LICENSE) -Java Hamcrest -============= -Licensed under [BSD License][]. -What is Hamcrest? ------------------ +# Java Hamcrest + +## What is Hamcrest? + Hamcrest is a library of matchers, which can be combined in to create flexible expressions of intent in tests. They've also been used for other purposes. -Downloads ---------- -You can obtain Hamcrest binaries from [maven central][], or from [google code downloads][]. +The [tutorial](http://hamcrest.org/JavaHamcrest/tutorial) is good place to see how Hamcrest can be used. -Extensions ----------- +## Downloads -For Hamcrest extension projects see the [hamcrest extensions page][]. +You can obtain Hamcrest binaries from [maven central](https://search.maven.org/artifact/org.hamcrest/hamcrest). If you +are using build tooling such as Maven, Gradle, etc, you can simply add a dependency declaration to your build +definition. Learn more at [Hamcrest Distributables](http://hamcrest.org/JavaHamcrest/distributables). -Documentation -------------- -Documentation can be found on the [Hamcrest site](http://hamcrest.org). +## Documentation -Reporting Bugs/Issues ---------------------- -If you find an issue with Java Hamcrest, please report it via the -[GitHub issue tracker](https://github.com/hamcrest/JavaHamcrest/issues), -after first checking that it hasn't been raised already. +Documentation can be found on the [Hamcrest site](http://hamcrest.org). For a detailed list of recent changes, +see [CHANGES.md](CHANGES.md) -Source ------- -To build, please read BUILDING.txt +## Reporting Bugs/Issues -Acknowledgements ----------------- -Developers: +If you find an issue with Java Hamcrest, please report it via the +[GitHub issue tracker](https://github.com/hamcrest/JavaHamcrest/issues), +after first checking that it hasn't been raised already. - * Joe Walnes - * Nat Pryce - * Steve Freeman +## Build from Source -Contributors: +Building Hamcrest from source requires a minimum of JDK 1.8. + +Clone the repository, and from the top level directory in the repo workspace +run the following command: - * Robert Chatley - * Tom White - * Neil Dunn - * Dan North - * Magne Rasmussen - * David Saff - * Tom Denley +```shell +./gradlew clean build javadoc +``` +This will download the correct version of Gradle, do a full clean build, +run all tests and (if successful) package the compiled classes in a jar +file. The resulting look under the `hamcrest/build/libs` directory. -Also, thanks to everyone who has worked on DynaMock, nMock, jMock, EasyMock and MiniMock! These libraries inspired Hamcrest. +## Acknowledgements +Developers: + +* Joe Walnes +* Nat Pryce +* Steve Freeman + +Contributors: -[logo]: https://raw.github.com/hamcrest/JavaHamcrest/master/doc/images/logo.jpg -[website]: https://github.com/hamcrest/JavaHamcrest -[BSD License]: http://opensource.org/licenses/BSD-3-Clause -[Maven central]: http://search.maven.org/#search%7Cga%7C1%7Cg%3Aorg.hamcrest -[hamcrest extensions page]: https://github.com/hamcrest/JavaHamcrest/wiki/Related-Projects -[GitHub issue tracker]: https://github.com/hamcrest/JavaHamcrest/issues +* Robert Chatley +* Tom White +* Neil Dunn +* Dan North +* Magne Rasmussen +* David Saff +* Tom Denley +* Joe Schmetzer + +Also, thanks to everyone who has worked on DynaMock, nMock, jMock, EasyMock +and MiniMock! These libraries inspired Hamcrest. diff --git a/RELEASING.md b/RELEASING.md new file mode 100644 index 000000000..b7bbae55c --- /dev/null +++ b/RELEASING.md @@ -0,0 +1,137 @@ +# Release Procedure + +These instructions are a how-to guide for Hamcrest maintainers. They describe +how to release a new version of Hamcrest to Maven Central. + +## Signing Key Setup + +The Gradle `signing` plugin is used to cryptographically sign the published +artifacts. You will need to add details of your private keys to allow +the plugin to work. Follow the instructions at +https://docs.gradle.org/current/userguide/signing_plugin.html. + +You can store the signing properties in a file called `gradle.properties` +as a sibling of the top level `build.gradle` file. This file will be ignored +by `git`, and so will not be accidentally checked in. Alternatively, you +can put the `gradle.properties` file in the `GRADLE_USER_HOME` directory +(usually `~/.gradle`) + +## Sonatype Account Setup + +Before you can perform a release, you will need: +* An account on the Maven Central staging server at https://oss.sonatype.org/ +* Permissions in the `org.hamcrest` group + +### Register an Account + +You will need to register an account with https://central.sonatype.com/. +Follow the instructions at https://central.sonatype.org/register/legacy/#create-an-account +for actually creating an account. Do not follow the instructions to +"Create a Namespace". `org.hamcrest` is already managed through the legacy +project infrastructure. That may change in the future, but for now +(July 2024) these instructions work as described below. + +### Request to be Added to `org.hamcrest` + +Sonatype needs to be notified that you have access to publish to +`org.hamcrest`. This must be done by one of the current publishers +(e.g. `@tumbarumba` or `@sf105`). Ask one of those people to follow +the instructions at https://central.sonatype.org/register/legacy/#contact-central-support-at-sonatype. +This may take up to 2 days before your permissions are applied. + +### Configure Access Tokens + +https://oss.sonatype.org/ will no longer accept a username and password +when publishing. Rather, you will need to create an access token. Follow +the instructions at https://central.sonatype.org/publish/generate-token/, +and store the values in `ossrhUsername` and `ossrhPassword` in the same +`gradle.properties` file used to hold the signing keys. + +In the end, you should have a `gradle.properties` file with (at least) the +following keys: + +```properties +signing.keyId=... +signing.password=... +signing.secretKeyRingFile=... +ossrhUsername=... +ossrhPassword=... +``` + +## Publishing Process + +### Update Version + +The version is defined as a property at the top of the `build.gradle` file +in the root of the repository. Normally, this has a `-SNAPSHOT` suffix. When +doing a release, the `-SNAPSHOT` suffix is removed. + +Edit the file to set the `version` property to the actual version required. +Save the file and test out the publishing process locally by running the +command: + +```shell +./gradlew clean jar publishToMavenLocal +``` + +To check the local publish worked correctly, look in the directory +`~/.m2/repository/org/hamcrest/hamcrest` and verify the versioned files +are all present and correct. + +When you are satisfied that the build is working correctly, you can commit +the change, tag the repository, and push to GitHub. + +e.g. this is the commands for version 3.0: + +```shell +git add build.gradle +git commit -m "Version 3.0" +git tag v3.0 +git push origin --tags +``` + +### Publishing to Sonatype Staging + +When ready, run the command: + +```shell +./gradlew publishAllPublicationsToMavenRepository +``` + +Wait. + +Wait a bit more. Sometimes it times out. Sometimes you will get 502 errors. +Keep on trying. It will eventually work. + + +### Release to Maven Central + +Look at the staging repositories: https://oss.sonatype.org/#stagingRepositories +and find the published artifacts. Make sure that everything is present +and accounted for. + +When you are happy, you will need to "Close" the repository - you won't be +able to publish any more artifacts to this repository, but you will then +be able to release the repository. + +Once it is closed, you will be able to "Release" the repository, which will +transfer all artifacts to Maven Central. It can take up to half an hour +for the jars to appear. Look in https://mvnrepository.com/artifact/org.hamcrest/hamcrest +and check for the new version. + +### Prepare for Next Snapshot + +Edit the `build.gradle` file, and change the version back to the next +snapshot version. For example, if you just published version `3.0`, the +next version will be `3.1-SNAPSHOT`. + +Commit this change and push to GitHub. + +### Share and Enjoy + +Put a message out on the mailing lists to give people the good news. + +# Future Improvements + +Look at https://github.com/gradle-nexus/publish-plugin/ to automate all +this. diff --git a/build.gradle b/build.gradle index dbc65583d..0a6791b6d 100644 --- a/build.gradle +++ b/build.gradle @@ -1,120 +1,178 @@ -import static org.gradle.api.JavaVersion.VERSION_1_7 - -apply plugin: 'java' -apply plugin: 'maven' -apply plugin: 'signing' - -sourceCompatibility = VERSION_1_7 -targetCompatibility = VERSION_1_7 -archivesBaseName = "java-hamcrest" +plugins { + id "signing" + id "maven-publish" +} +apply from: "gradle/versioning.gradle" group = "org.hamcrest" -version = "2.0.0.0" +version = getMavenVersion() + +tasks.register("showVersion") { + group = "Build" + description = "Show the version, as derived from git tags" + doLast { + println("git version: " + getGitVersion()) + println("mvn version: " + getMavenVersion()) + } +} +subprojects { + apply plugin: 'checkstyle' + apply plugin: 'java-library' -repositories { - mavenCentral() -} + group = rootProject.group + version = rootProject.version -dependencies { - testCompile(group: 'junit', name: 'junit', version: '4.12') { - transitive = false + java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 } -} -sourceSets { - main { - java { - srcDirs 'hamcrest-core/src/main/java', 'hamcrest-library/src/main/java' + repositories { + mavenCentral() + } + + checkstyle { + + project.ext.checkstyleVersion = '9.3' + //works with a JDK 7 version which is supposed to be supported although + //deprecated, see https://github.com/hamcrest/JavaHamcrest/pull/211 for + //the discussion about the support + + sourceSets = [ project.sourceSets.main, project.sourceSets.test ] + ignoreFailures = false + configFile = file("${project.rootDir}/checkstyle.xml") + + configurations { + checkstyle } + dependencies{ + assert project.hasProperty("checkstyleVersion") + checkstyle "com.puppycrawl.tools:checkstyle:${checkstyleVersion}" + } } + test { - java { - srcDirs 'hamcrest-core/src/test/java', 'hamcrest-library/src/test/java' + testLogging { + exceptionFormat = 'full' } } -} -jar { - manifest { - attributes 'Implementation-Title': 'hamcrest-all', - 'Implementation-Vendor': 'hamcrest.org', - 'Implementation-Version': version + jar { + metaInf { + from rootProject.file('LICENSE') + } } -} -task sourcesJar(type: Jar) { - classifier = 'sources' - from sourceSets.main.allSource -} + task sourcesJar(type: Jar) { + archiveClassifier = 'sources' + from sourceSets.main.allSource + } -task javadocJar(type: Jar) { - classifier = 'javadoc' - from javadoc + task javadocJar(type: Jar) { + archiveClassifier = 'javadoc' + from javadoc + } } -artifacts { - archives sourcesJar, javadocJar +allprojects { + tasks.withType(JavaCompile) { + options.compilerArgs << '-Xlint:-options' + } } -signing { - required { gradle.taskGraph.hasTask("uploadArchives") } - sign configurations.archives -} +def pomConfigurationFor(String pomName, String pomDescription) { + return { + name = pomName + description = pomDescription + url = 'http://hamcrest.org/JavaHamcrest/' -uploadArchives { - if (hasProperty('ossrhUsername') && hasProperty('ossrhPassword')) { - repositories { - mavenDeployer { - beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) } + scm { + connection = 'scm:git:https://github.com/hamcrest/JavaHamcrest.git' + developerConnection = 'scm:git:ssh://github.com/hamcrest/JavaHamcrest.git' + url = 'https://github.com/hamcrest/JavaHamcrest' + } - repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") { - authentication(userName: ossrhUsername, password: ossrhPassword) - } + licenses { + license { + name = 'BSD-3-Clause' + url = 'https://raw.githubusercontent.com/hamcrest/JavaHamcrest/master/LICENSE' + } + } - snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") { - authentication(userName: ossrhUsername, password: ossrhPassword) - } + developers { + developer { + id = 'joewalnes' + name = 'Joe Walnes' + } + developer { + id = 'npryce' + name = 'Nat Pryce' + } + developer { + id = 'sf105' + name = 'Steve Freeman' + } + } + } +} + +def publishToOssrh = project.hasProperty('ossrhUsername') && project.hasProperty('ossrhPassword') + +publishing { + publications { + def hamcrestProject = project(':hamcrest') + hamcrest(MavenPublication) { + from hamcrestProject.components.java + artifactId hamcrestProject.name + artifact hamcrestProject.sourcesJar + artifact hamcrestProject.javadocJar + pom pomConfigurationFor( + 'Hamcrest', + 'Core API and libraries of hamcrest matcher framework.') + } - pom.project { - name 'Java Hamcrest' - packaging 'jar' - description 'Hamcrest matcher library for Java' - url 'http://hamcrest.org/JavaHamcrest/' - - scm { - connection 'git@github.com:hamcrest/JavaHamcrest.git' - url 'https://github.com/hamcrest/JavaHamcrest' - } - - licenses { - license { - name 'BSD Licence 3' - url 'http://opensource.org/licenses/BSD-3-Clause' - } - } - - developers { - developer { - id 'joewalnes' - name 'Joe Walnes' - } - developer { - id 'npryce' - name 'Nat Pryce' - } - developer { - id 'sf105' - name 'Steve Freeman' - } - } + def hamcrestCoreProject = project(':hamcrest-core') + hamcrestCore(MavenPublication) { + from hamcrestCoreProject.components.java + artifactId hamcrestCoreProject.name + artifact hamcrestCoreProject.sourcesJar + artifact hamcrestCoreProject.javadocJar + pom pomConfigurationFor( + 'Hamcrest Core', + 'Core Hamcrest API - deprecated, please use "hamcrest" instead') + } + + def hamcrestLibraryProject = project(':hamcrest-library') + hamcrestLibrary(MavenPublication) { + from hamcrestLibraryProject.components.java + artifactId hamcrestLibraryProject.name + artifact hamcrestLibraryProject.sourcesJar + artifact hamcrestLibraryProject.javadocJar + pom pomConfigurationFor( + 'Hamcrest Library', + 'A library of Hamcrest matchers - deprecated, please use "hamcrest" instead') + } + } + repositories { + if (publishToOssrh) { + maven { + def snapshotRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/" + def stagingRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/" + url = version.contains('SNAPSHOT') ? snapshotRepoUrl : stagingRepoUrl + credentials { + username = ossrhUsername + password = ossrhPassword } } } } } -task wrapper(type: Wrapper) { - gradleVersion = '2.3' +signing { + required { publishToOssrh } + sign publishing.publications.hamcrest + sign publishing.publications.hamcrestCore + sign publishing.publications.hamcrestLibrary } diff --git a/build.xml.original b/build.xml.original deleted file mode 100644 index 95662ee07..000000000 --- a/build.xml.original +++ /dev/null @@ -1,289 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/checkstyle.xml b/checkstyle.xml new file mode 100644 index 000000000..c1dbabf32 --- /dev/null +++ b/checkstyle.xml @@ -0,0 +1,11 @@ + + + + + + + + + diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 000000000..10e6731ad --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1 @@ +markdown: kramdown diff --git a/docs/_includes/head.html b/docs/_includes/head.html new file mode 100644 index 000000000..84c2c4f68 --- /dev/null +++ b/docs/_includes/head.html @@ -0,0 +1,12 @@ + + + + + + + + {{ page.title }} + + + + diff --git a/docs/_layouts/default.html b/docs/_layouts/default.html new file mode 100644 index 000000000..a3369dfd6 --- /dev/null +++ b/docs/_layouts/default.html @@ -0,0 +1,18 @@ + + + + {% include head.html %} + + +
+ {{ content }} +
+ + Fork me on GitHub + + diff --git a/docs/css/hamcrest.css b/docs/css/hamcrest.css new file mode 100644 index 000000000..c456ed902 --- /dev/null +++ b/docs/css/hamcrest.css @@ -0,0 +1,44 @@ +@import url(https://fonts.googleapis.com/css?family=Cabin+Sketch); +@import url(https://fonts.googleapis.com/css?family=Alegreya); +body { + font-family: "Alegreya"; + margin: 40px auto; + width: 700px; +} +.content { + position: relative; +} +footer { + padding: 2em 0 1em 0; + font-size: 12px; +} +h1 { + font-size: 80px; + margin-top: .3em; + margin-bottom: 0; +} +h1 + h2 { + margin-top: 0; +} +h2 { + font-weight: 400; + font-size: 20px; +} +h1, h2 { + font-family: "Cabin Sketch"; + text-rendering: optimizeLegibility; +} +.content > p { + line-height: 1.5em; + text-rendering: optimizeLegibility; +} +.logo { + height: 60px; + padding-left: 0px; + padding-right: 40px; +} +pre.highlight { + border: 1px solid #ccc; + background-color: #eee; + padding: 0.5em; +} \ No newline at end of file diff --git a/docs/css/pygments-default.css b/docs/css/pygments-default.css new file mode 100644 index 000000000..8070f2fb6 --- /dev/null +++ b/docs/css/pygments-default.css @@ -0,0 +1,61 @@ +.highlight .hll { background-color: #ffffcc } +.highlight .c { color: #408080; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #FF0000 } /* Error */ +.highlight .k { color: #008000; font-weight: bold } /* Keyword */ +.highlight .o { color: #666666 } /* Operator */ +.highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #BC7A00 } /* Comment.Preproc */ +.highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #408080; font-style: italic } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .gr { color: #FF0000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #00A000 } /* Generic.Inserted */ +.highlight .go { color: #808080 } /* Generic.Output */ +.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #0040D0 } /* Generic.Traceback */ +.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #008000 } /* Keyword.Pseudo */ +.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #B00040 } /* Keyword.Type */ +.highlight .m { color: #666666 } /* Literal.Number */ +.highlight .s { color: #BA2121 } /* Literal.String */ +.highlight .na { color: #7D9029 } /* Name.Attribute */ +.highlight .nb { color: #008000 } /* Name.Builtin */ +.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */ +.highlight .no { color: #880000 } /* Name.Constant */ +.highlight .nd { color: #AA22FF } /* Name.Decorator */ +.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */ +.highlight .nf { color: #0000FF } /* Name.Function */ +.highlight .nl { color: #A0A000 } /* Name.Label */ +.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #19177C } /* Name.Variable */ +.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #bbbbbb } /* Text.Whitespace */ +.highlight .mf { color: #666666 } /* Literal.Number.Float */ +.highlight .mh { color: #666666 } /* Literal.Number.Hex */ +.highlight .mi { color: #666666 } /* Literal.Number.Integer */ +.highlight .mo { color: #666666 } /* Literal.Number.Oct */ +.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */ +.highlight .sc { color: #BA2121 } /* Literal.String.Char */ +.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #BA2121 } /* Literal.String.Double */ +.highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */ +.highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */ +.highlight .sx { color: #008000 } /* Literal.String.Other */ +.highlight .sr { color: #BB6688 } /* Literal.String.Regex */ +.highlight .s1 { color: #BA2121 } /* Literal.String.Single */ +.highlight .ss { color: #19177C } /* Literal.String.Symbol */ +.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */ +.highlight .vc { color: #19177C } /* Name.Variable.Class */ +.highlight .vg { color: #19177C } /* Name.Variable.Global */ +.highlight .vi { color: #19177C } /* Name.Variable.Instance */ +.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */ diff --git a/docs/distributables.md b/docs/distributables.md new file mode 100644 index 000000000..daf06c2d4 --- /dev/null +++ b/docs/distributables.md @@ -0,0 +1,151 @@ +--- +title: Hamcrest Distributables +layout: default +--- +[Java Hamcrest Home](index) + +# Hamcrest Distributables +{:.no_toc} + +## Introduction +{:.no_toc} + +This document describes the current and previous versions of the various Hamcrest +distributables, and the functionality contained in each of them. + +The latest version of Hamcrest consists of a single jar file which contains base +classes and a library of useful matcher implementations. This is different from +older versions. + +Older versions of Hamcrest consisted of a number of different jars matching the +different needs of applications. The change in the jar packaging requires care +when upgrading. + +## Table of Contents +{:.no_toc} + +* TOC +{:toc} + +## The Hamcrest Jar + +All the base classes and standard matcher implementations are contained in a +single jar file called `hamcrest-3.0.jar`. + +### Using Hamcrest in a Gradle Project + +Add `"org.hamcrest:hamcrest:3.0"` to the dependencies section of your +`build.gradle`, for example: + +```gradle +apply plugin: 'java' + +dependencies { + testImplementation 'org.hamcrest:hamcrest:3.0' +} +``` + +Note: older versions of Gradle use the `testCompile` configuration +instead of the `testImplementation` configuration. + +### Using Hamcrest in a Maven Project + +Add the following to the `` section in your `pom.xml`: + +```xml + + org.hamcrest + hamcrest + 3.0 + test + +``` + +### Download the Hamcrest Jar + +You can download the jars directly from Maven Central. You can find the jars by searching Maven Central for groupId `org.hamcrest` +using the following link: + +> [https://search.maven.org/artifact/org.hamcrest/hamcrest](https://search.maven.org/artifact/org.hamcrest/hamcrest) + +## Previous Versions of Hamcrest + +Prior to version 2.x, Hamcrest was distributed through multiple jars, described +below. + +* **`hamcrest-core.jar`**: This was the core API to be used by third-party framework +providers. This includes a foundation set of matcher implementations for common +operations. This library was used as a dependency for many third-party libraries, +including JUnit 4.x. From Hamcrest version 2.x, all the classes in +`hamcrest-core.jar` were moved into `hamcrest.jar`. +* **`hamcrest-library.jar`**: The library of Matcher implementations which are based +on the core functionality in hamcrest-core.jar. From Hamcrest version 2.x, all the +classes in `hamcrest-core.jar` were moved into `hamcrest.jar`. +* **`hamcrest-integration.jar`**: Provides integration between Hamcrest and other +testing tools, such as jMock and EasyMock. It depends upon `hamcrest-core.jar` and +`hamcrest-library.jar`. There are no new releases of this library since version 1.3. +* **`hamcrest-generator.jar`**: A tool to allow many Matcher implementations to be +combined into a single class with static methods returning the different matchers +so users don't have to remember many classes/packages to import. Generates code. +This library is only used internally at compile time. It is not necessary for the +use of any of the other hamcrest libraries at runtime. There are no new releases of +this library since version 1.3. +* **`hamcrest-all.jar`**: One jar containing all classes of all the other jars. +There are no new releases of this library since version 1.3. Please use the single +`hamcrest.jar` instead. + +### Upgrading from Hamcrest 1.x + +Care must be taken when upgrading from Hamcrest 1.3 or earlier. Due to the change in +packaging, the version conflict resolution that happens in dependency management +tools won't happen automatically. A common example is projects that depend upon +JUnit 4. JUnit 4 declares a transitive dependency upon `hamcrest-core-1.3.jar`. +Because `hamcrest-core` is not the same artifact as `hamcrest`, it will not be +upgraded. + +To address this issue, Hamcrest 2.1 and later also publish artifacts for +`hamcrest-core` and `hamcrest-library`. Although these jars contain no classes, +they trigger the version conflict upgrade in the dependency manager, and correctly +declare transitive dependencies upon the new `hamcrest` packaging. Users can +directly declare a dependency upon these shim jars to force the upgrade. + +#### Gradle Upgrade Example + +```gradle +apply plugin: 'java' + +dependencies { + testImplementation 'org.hamcrest:hamcrest:3.0' + testImplementation 'org.hamcrest:hamcrest-library:3.0' + testImplementation 'junit:junit:4.13.2' +} +``` + +#### Maven Upgrade Example + +**Warning**: +Maven users should declare a dependency upon `hamcrest-library` **before** other +dependencies, otherwise the older version will take precedence. + +```xml + + + org.hamcrest + hamcrest + 3.0 + test + + + org.hamcrest + hamcrest-library + 3.0 + test + + + junit + junit + 4.13.2 + test + + +``` diff --git a/doc/images/logo.jpg b/docs/images/logo.jpg similarity index 100% rename from doc/images/logo.jpg rename to docs/images/logo.jpg diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 000000000..1af974b46 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,25 @@ +--- +title: Java Hamcrest +layout: default +--- +# ![Hamcrest Surfer](http://hamcrest.org/images/logo.jpg){:.logo}Java Hamcrest + +## Matchers that can be combined to create flexible expressions of intent + +### Documentation + +* [Getting Started](tutorial) +* [API Documentation (JavaDoc)](javadoc/) + +### Downloads + +* [Distributables and Dependency Configuration](distributables) +* [Source Repository](http://github.com/hamcrest/JavaHamcrest) +* [Project License](http://opensource.org/licenses/BSD-3-Clause) +* [Extensions and Related Projects](related) + +### User Support + +* [Hamcrest Java Users Mailing List](https://groups.google.com/forum/?fromgroups#!forum/hamcrest-java) +* [Hamcrest Developer Mailing List](https://groups.google.com/forum/?fromgroups#!forum/hamcrest-dev) +* [Issue Tracker](https://github.com/hamcrest/JavaHamcrest/issues) diff --git a/docs/javadoc/1.3/allclasses-frame.html b/docs/javadoc/1.3/allclasses-frame.html new file mode 100644 index 000000000..63ba802ba --- /dev/null +++ b/docs/javadoc/1.3/allclasses-frame.html @@ -0,0 +1,181 @@ + + + + + + +All Classes (Hamcrest) + + + + + + + + + + + +All Classes +
+ + + + + +
AllOf +
+AnyOf +
+ArrayIterator +
+BaseDescription +
+BaseMatcher +
+BigDecimalCloseTo +
+CombinableMatcher +
+CombinableMatcher.CombinableBothMatcher +
+CombinableMatcher.CombinableEitherMatcher +
+Condition +
+Condition.Step +
+CoreMatchers +
+CustomMatcher +
+CustomTypeSafeMatcher +
+DescribedAs +
+Description +
+Description.NullDescription +
+DiagnosingMatcher +
+EasyMock2Adapter +
+EasyMock2Matchers +
+Every +
+Factory +
+FeatureMatcher +
+HasProperty +
+HasPropertyWithValue +
+HasToString +
+HasXPath +
+Is +
+IsAnything +
+IsArray +
+IsArrayContaining +
+IsArrayContainingInAnyOrder +
+IsArrayContainingInOrder +
+IsArrayWithSize +
+IsCloseTo +
+IsCollectionContaining +
+IsCollectionWithSize +
+IsCompatibleType +
+IsEmptyCollection +
+IsEmptyIterable +
+IsEmptyString +
+IsEqual +
+IsEqualIgnoringCase +
+IsEqualIgnoringWhiteSpace +
+IsEventFrom +
+IsIn +
+IsInstanceOf +
+IsIterableContainingInAnyOrder +
+IsIterableContainingInOrder +
+IsIterableWithSize +
+IsMapContaining +
+IsNot +
+IsNull +
+IsSame +
+JavaLangMatcherAssert +
+JMock1Adapter +
+JMock1Matchers +
+Matcher +
+MatcherAssert +
+Matchers +
+OrderingComparison +
+PropertyUtil +
+ReflectiveTypeFinder +
+SamePropertyValuesAs +
+SamePropertyValuesAs.PropertyMatcher +
+SelfDescribing +
+SelfDescribingValue +
+SelfDescribingValueIterator +
+StringContains +
+StringContainsInOrder +
+StringDescription +
+StringEndsWith +
+StringStartsWith +
+SubstringMatcher +
+TypeSafeDiagnosingMatcher +
+TypeSafeMatcher +
+
+ + + diff --git a/docs/javadoc/1.3/allclasses-noframe.html b/docs/javadoc/1.3/allclasses-noframe.html new file mode 100644 index 000000000..f0ab63137 --- /dev/null +++ b/docs/javadoc/1.3/allclasses-noframe.html @@ -0,0 +1,181 @@ + + + + + + +All Classes (Hamcrest) + + + + + + + + + + + +All Classes +
+ + + + + +
AllOf +
+AnyOf +
+ArrayIterator +
+BaseDescription +
+BaseMatcher +
+BigDecimalCloseTo +
+CombinableMatcher +
+CombinableMatcher.CombinableBothMatcher +
+CombinableMatcher.CombinableEitherMatcher +
+Condition +
+Condition.Step +
+CoreMatchers +
+CustomMatcher +
+CustomTypeSafeMatcher +
+DescribedAs +
+Description +
+Description.NullDescription +
+DiagnosingMatcher +
+EasyMock2Adapter +
+EasyMock2Matchers +
+Every +
+Factory +
+FeatureMatcher +
+HasProperty +
+HasPropertyWithValue +
+HasToString +
+HasXPath +
+Is +
+IsAnything +
+IsArray +
+IsArrayContaining +
+IsArrayContainingInAnyOrder +
+IsArrayContainingInOrder +
+IsArrayWithSize +
+IsCloseTo +
+IsCollectionContaining +
+IsCollectionWithSize +
+IsCompatibleType +
+IsEmptyCollection +
+IsEmptyIterable +
+IsEmptyString +
+IsEqual +
+IsEqualIgnoringCase +
+IsEqualIgnoringWhiteSpace +
+IsEventFrom +
+IsIn +
+IsInstanceOf +
+IsIterableContainingInAnyOrder +
+IsIterableContainingInOrder +
+IsIterableWithSize +
+IsMapContaining +
+IsNot +
+IsNull +
+IsSame +
+JavaLangMatcherAssert +
+JMock1Adapter +
+JMock1Matchers +
+Matcher +
+MatcherAssert +
+Matchers +
+OrderingComparison +
+PropertyUtil +
+ReflectiveTypeFinder +
+SamePropertyValuesAs +
+SamePropertyValuesAs.PropertyMatcher +
+SelfDescribing +
+SelfDescribingValue +
+SelfDescribingValueIterator +
+StringContains +
+StringContainsInOrder +
+StringDescription +
+StringEndsWith +
+StringStartsWith +
+SubstringMatcher +
+TypeSafeDiagnosingMatcher +
+TypeSafeMatcher +
+
+ + + diff --git a/docs/javadoc/1.3/constant-values.html b/docs/javadoc/1.3/constant-values.html new file mode 100644 index 000000000..3b472d2aa --- /dev/null +++ b/docs/javadoc/1.3/constant-values.html @@ -0,0 +1,146 @@ + + + + + + +Constant Field Values (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Constant Field Values

+
+
+Contents
    +
+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/deprecated-list.html b/docs/javadoc/1.3/deprecated-list.html new file mode 100644 index 000000000..260fc82d1 --- /dev/null +++ b/docs/javadoc/1.3/deprecated-list.html @@ -0,0 +1,191 @@ + + + + + + +Deprecated List (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Deprecated API

+
+
+Contents + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Deprecated Methods
org.hamcrest.Matcher._dont_implement_Matcher___instead_extend_BaseMatcher_() +
+          to make 
org.hamcrest.BaseMatcher._dont_implement_Matcher___instead_extend_BaseMatcher_() +
+           
org.hamcrest.Matchers.containsInAnyOrder(Matcher) +
+          use contains(Matcher itemMatcher) instead 
org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(Matcher) +
+          use contains(Matcher itemMatcher) instead 
org.hamcrest.Matchers.is(Class) +
+          use isA(Class type) instead. 
org.hamcrest.CoreMatchers.is(Class) +
+          use isA(Class type) instead. 
org.hamcrest.core.Is.is(Class) +
+          use isA(Class type) instead. 
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/help-doc.html b/docs/javadoc/1.3/help-doc.html new file mode 100644 index 000000000..e7f01c0fb --- /dev/null +++ b/docs/javadoc/1.3/help-doc.html @@ -0,0 +1,223 @@ + + + + + + +API Help (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+How This API Document Is Organized

+
+This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.

+Overview

+
+ +

+The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

+

+Package

+
+ +

+Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:

    +
  • Interfaces (italic)
  • Classes
  • Enums
  • Exceptions
  • Errors
  • Annotation Types
+
+

+Class/Interface

+
+ +

+Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:

    +
  • Class inheritance diagram
  • Direct Subclasses
  • All Known Subinterfaces
  • All Known Implementing Classes
  • Class/interface declaration
  • Class/interface description +

    +

  • Nested Class Summary
  • Field Summary
  • Constructor Summary
  • Method Summary +

    +

  • Field Detail
  • Constructor Detail
  • Method Detail
+Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
+ +

+Annotation Type

+
+ +

+Each annotation type has its own separate page with the following sections:

    +
  • Annotation Type declaration
  • Annotation Type description
  • Required Element Summary
  • Optional Element Summary
  • Element Detail
+
+ +

+Enum

+
+ +

+Each enum has its own separate page with the following sections:

    +
  • Enum declaration
  • Enum description
  • Enum Constant Summary
  • Enum Constant Detail
+
+

+Use

+
+Each documented package, class and interface has its own Use page. This page describes what packages, classes, methods, constructors and fields use any part of the given class or package. Given a class or interface A, its Use page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
+

+Tree (Class Hierarchy)

+
+There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
    +
  • When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
  • When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
+
+

+Deprecated API

+
+The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
+

+Index

+
+The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
+

+Prev/Next

+These links take you to the next or previous class, interface, package, or related page.

+Frames/No Frames

+These links show and hide the HTML frames. All pages are available with or without frames. +

+

+Serialized Form

+Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description. +

+

+Constant Field Values

+The Constant Field Values page lists the static final fields and their values. +

+ + +This help file applies to API documentation generated using the standard doclet. + +
+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/index-all.html b/docs/javadoc/1.3/index-all.html new file mode 100644 index 000000000..40ed7de90 --- /dev/null +++ b/docs/javadoc/1.3/index-all.html @@ -0,0 +1,2032 @@ + + + + + + +Index (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +A B C D E F G H I J L M N O P R S T _
+

+A

+
+
adapt(Matcher<?>) - +Static method in class org.hamcrest.integration.EasyMock2Adapter +
Convenience factory method that will adapt a + Hamcrest Matcher to act as an + EasyMock IArgumentMatcher and + report it to EasyMock so it can be kept track of. +
adapt(Matcher<?>) - +Static method in class org.hamcrest.integration.JMock1Adapter +
Convenience factory method that will adapt a + Hamcrest Matcher to act as an + jMock Constraint. +
AllOf<T> - Class in org.hamcrest.core
Calculates the logical conjunction of multiple matchers.
AllOf(Iterable<Matcher<? super T>>) - +Constructor for class org.hamcrest.core.AllOf +
  +
allOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>...) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AllOf +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>...) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +
and(Condition.Step<? super T, U>) - +Method in class org.hamcrest.Condition +
  +
and(Matcher<? super T>) - +Method in class org.hamcrest.core.CombinableMatcher +
  +
and(Matcher<? super X>) - +Method in class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher +
  +
any(Class<T>) - +Static method in class org.hamcrest.core.IsInstanceOf +
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. +
any(Class<T>) - +Static method in class org.hamcrest.CoreMatchers +
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. +
any(Class<T>) - +Static method in class org.hamcrest.Matchers +
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. +
AnyOf<T> - Class in org.hamcrest.core
Calculates the logical disjunction of multiple matchers.
AnyOf(Iterable<Matcher<? super T>>) - +Constructor for class org.hamcrest.core.AnyOf +
  +
anyOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<? super T>...) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.core.AnyOf +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<? super T>...) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Iterable<Matcher<? super T>>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<T>, Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anyOf(Matcher<? super T>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +
anything() - +Static method in class org.hamcrest.core.IsAnything +
Creates a matcher that always matches, regardless of the examined object. +
anything(String) - +Static method in class org.hamcrest.core.IsAnything +
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +
anything() - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that always matches, regardless of the examined object. +
anything(String) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +
anything() - +Static method in class org.hamcrest.Matchers +
Creates a matcher that always matches, regardless of the examined object. +
anything(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +
append(String) - +Method in class org.hamcrest.BaseDescription +
Append the String str to the description. +
append(char) - +Method in class org.hamcrest.BaseDescription +
Append the char c to the description. +
append(String) - +Method in class org.hamcrest.StringDescription +
  +
append(char) - +Method in class org.hamcrest.StringDescription +
  +
appendDescriptionOf(SelfDescribing) - +Method in class org.hamcrest.BaseDescription +
  +
appendDescriptionOf(SelfDescribing) - +Method in interface org.hamcrest.Description +
Appends the description of a SelfDescribing value to this description. +
appendDescriptionOf(SelfDescribing) - +Method in class org.hamcrest.Description.NullDescription +
  +
appendList(String, String, String, Iterable<? extends SelfDescribing>) - +Method in class org.hamcrest.BaseDescription +
  +
appendList(String, String, String, Iterable<? extends SelfDescribing>) - +Method in interface org.hamcrest.Description +
Appends a list of SelfDescribing objects + to the description. +
appendList(String, String, String, Iterable<? extends SelfDescribing>) - +Method in class org.hamcrest.Description.NullDescription +
  +
appendText(String) - +Method in class org.hamcrest.BaseDescription +
  +
appendText(String) - +Method in interface org.hamcrest.Description +
Appends some plain text to the description. +
appendText(String) - +Method in class org.hamcrest.Description.NullDescription +
  +
appendTo(StringBuffer) - +Method in class org.hamcrest.integration.EasyMock2Adapter +
  +
appendValue(Object) - +Method in class org.hamcrest.BaseDescription +
  +
appendValue(Object) - +Method in interface org.hamcrest.Description +
Appends an arbitary value to the description. +
appendValue(Object) - +Method in class org.hamcrest.Description.NullDescription +
  +
appendValueList(String, String, String, T...) - +Method in class org.hamcrest.BaseDescription +
  +
appendValueList(String, String, String, Iterable<T>) - +Method in class org.hamcrest.BaseDescription +
  +
appendValueList(String, String, String, T...) - +Method in interface org.hamcrest.Description +
Appends a list of values to the description. +
appendValueList(String, String, String, Iterable<T>) - +Method in interface org.hamcrest.Description +
Appends a list of values to the description. +
appendValueList(String, String, String, T...) - +Method in class org.hamcrest.Description.NullDescription +
  +
appendValueList(String, String, String, Iterable<T>) - +Method in class org.hamcrest.Description.NullDescription +
  +
apply(I, Description) - +Method in interface org.hamcrest.Condition.Step +
  +
array(Matcher<? super T>...) - +Static method in class org.hamcrest.collection.IsArray +
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. +
array(Matcher<? super T>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. +
arrayContaining(E...) - +Static method in class org.hamcrest.collection.IsArrayContainingInOrder +
Creates a matcher for arrays that matcheswhen each item in the examined array is + logically equal to the corresponding item in the specified items. +
arrayContaining(Matcher<? super E>...) - +Static method in class org.hamcrest.collection.IsArrayContainingInOrder +
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers. +
arrayContaining(List<Matcher<? super E>>) - +Static method in class org.hamcrest.collection.IsArrayContainingInOrder +
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers. +
arrayContaining(List<Matcher<? super E>>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers. +
arrayContaining(E...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matcheswhen each item in the examined array is + logically equal to the corresponding item in the specified items. +
arrayContaining(Matcher<? super E>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers. +
arrayContainingInAnyOrder(Matcher<? super E>...) - +Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers. +
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - +Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
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. +
arrayContainingInAnyOrder(E...) - +Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
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. +
arrayContainingInAnyOrder(E...) - +Static method in class org.hamcrest.Matchers +
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. +
arrayContainingInAnyOrder(Matcher<? super E>...) - +Static method in class org.hamcrest.Matchers +
Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers. +
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - +Static method in class org.hamcrest.Matchers +
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. +
ArrayIterator - Class in org.hamcrest.internal
 
ArrayIterator(Object) - +Constructor for class org.hamcrest.internal.ArrayIterator +
  +
arrayWithSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.collection.IsArrayWithSize +
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. +
arrayWithSize(int) - +Static method in class org.hamcrest.collection.IsArrayWithSize +
Creates a matcher for arrays that matches when the length of the array + equals the specified size. +
arrayWithSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. +
arrayWithSize(int) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when the length of the array + equals the specified size. +
assertThat(T, Matcher<? super T>) - +Static method in class org.hamcrest.MatcherAssert +
  +
assertThat(String, T, Matcher<? super T>) - +Static method in class org.hamcrest.MatcherAssert +
  +
assertThat(String, boolean) - +Static method in class org.hamcrest.MatcherAssert +
  +
asString(SelfDescribing) - +Static method in class org.hamcrest.StringDescription +
Alias for StringDescription.toString(SelfDescribing). +
+
+

+B

+
+
BaseDescription - Class in org.hamcrest
A Description that is stored as a string.
BaseDescription() - +Constructor for class org.hamcrest.BaseDescription +
  +
BaseMatcher<T> - Class in org.hamcrest
BaseClass for all Matcher implementations.
BaseMatcher() - +Constructor for class org.hamcrest.BaseMatcher +
  +
BigDecimalCloseTo - Class in org.hamcrest.number
 
BigDecimalCloseTo(BigDecimal, BigDecimal) - +Constructor for class org.hamcrest.number.BigDecimalCloseTo +
  +
both(Matcher<? super LHS>) - +Static method in class org.hamcrest.core.CombinableMatcher +
Creates a matcher that matches when both of the specified matchers match the examined object. +
both(Matcher<? super LHS>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches when both of the specified matchers match the examined object. +
both(Matcher<? super LHS>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when both of the specified matchers match the examined object. +
+
+

+C

+
+
canObtainExpectedTypeFrom(Method) - +Method in class org.hamcrest.internal.ReflectiveTypeFinder +
  +
closeTo(double, double) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. +
closeTo(BigDecimal, BigDecimal) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. +
closeTo(BigDecimal, BigDecimal) - +Static method in class org.hamcrest.number.BigDecimalCloseTo +
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. +
closeTo(double, double) - +Static method in class org.hamcrest.number.IsCloseTo +
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. +
CombinableMatcher<T> - Class in org.hamcrest.core
 
CombinableMatcher(Matcher<? super T>) - +Constructor for class org.hamcrest.core.CombinableMatcher +
  +
CombinableMatcher.CombinableBothMatcher<X> - Class in org.hamcrest.core
 
CombinableMatcher.CombinableBothMatcher(Matcher<? super X>) - +Constructor for class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher +
  +
CombinableMatcher.CombinableEitherMatcher<X> - Class in org.hamcrest.core
 
CombinableMatcher.CombinableEitherMatcher(Matcher<? super X>) - +Constructor for class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher +
  +
comparesEqualTo(T) - +Static method in class org.hamcrest.Matchers +
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. +
comparesEqualTo(T) - +Static method in class org.hamcrest.number.OrderingComparison +
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. +
Condition<T> - Class in org.hamcrest
A Condition implements part of a multi-step match.
Condition.Step<I,O> - Interface in org.hamcrest
 
contains(E...) - +Static method in class org.hamcrest.collection.IsIterableContainingInOrder +
Creates a matcher for Iterables 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. +
contains(Matcher<? super E>) - +Static method in class org.hamcrest.collection.IsIterableContainingInOrder +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. +
contains(Matcher<? super E>...) - +Static method in class org.hamcrest.collection.IsIterableContainingInOrder +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. +
contains(List<Matcher<? super E>>) - +Static method in class org.hamcrest.collection.IsIterableContainingInOrder +
Creates a matcher for Iterables 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. +
contains(Matcher<? super E>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. +
contains(E...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables 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. +
contains(Matcher<? super E>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. +
contains(List<Matcher<? super E>>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables 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. +
containsInAnyOrder(Matcher<? super E>) - +Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
Deprecated. use contains(Matcher itemMatcher) instead +
containsInAnyOrder(Matcher<? super T>...) - +Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. +
containsInAnyOrder(T...) - +Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
Creates an order agnostic matcher for Iterables 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. +
containsInAnyOrder(Collection<Matcher<? super T>>) - +Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
Creates an order agnostic matcher for Iterables 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. +
containsInAnyOrder(T...) - +Static method in class org.hamcrest.Matchers +
Creates an order agnostic matcher for Iterables 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. +
containsInAnyOrder(Collection<Matcher<? super T>>) - +Static method in class org.hamcrest.Matchers +
Creates an order agnostic matcher for Iterables 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. +
containsInAnyOrder(Matcher<? super T>...) - +Static method in class org.hamcrest.Matchers +
Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. +
containsInAnyOrder(Matcher<? super E>) - +Static method in class org.hamcrest.Matchers +
Deprecated. use contains(Matcher itemMatcher) instead +
containsString(String) - +Static method in class org.hamcrest.core.StringContains +
Creates a matcher that matches if the examined String contains the specified + String anywhere. +
containsString(String) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined String contains the specified + String anywhere. +
containsString(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined String contains the specified + String anywhere. +
CoreMatchers - Class in org.hamcrest
 
CoreMatchers() - +Constructor for class org.hamcrest.CoreMatchers +
  +
CustomMatcher<T> - Class in org.hamcrest
Utility class for writing one off matchers.
CustomMatcher(String) - +Constructor for class org.hamcrest.CustomMatcher +
  +
CustomTypeSafeMatcher<T> - Class in org.hamcrest
Utility class for writing one off matchers.
CustomTypeSafeMatcher(String) - +Constructor for class org.hamcrest.CustomTypeSafeMatcher +
  +
+
+

+D

+
+
DescribedAs<T> - Class in org.hamcrest.core
Provides a custom description to another matcher.
DescribedAs(String, Matcher<T>, Object[]) - +Constructor for class org.hamcrest.core.DescribedAs +
  +
describedAs(String, Matcher<T>, Object...) - +Static method in class org.hamcrest.core.DescribedAs +
Wraps an existing matcher, overriding its description with that specified. +
describedAs(String, Matcher<T>, Object...) - +Static method in class org.hamcrest.CoreMatchers +
Wraps an existing matcher, overriding its description with that specified. +
describedAs(String, Matcher<T>, Object...) - +Static method in class org.hamcrest.Matchers +
Wraps an existing matcher, overriding its description with that specified. +
describeMismatch(Object, Description) - +Method in class org.hamcrest.BaseMatcher +
  +
describeMismatch(Object, Description) - +Method in class org.hamcrest.core.DescribedAs +
  +
describeMismatch(Object, Description) - +Method in class org.hamcrest.core.Is +
  +
describeMismatch(Object, Description) - +Method in class org.hamcrest.DiagnosingMatcher +
  +
describeMismatch(Object, Description) - +Method in interface org.hamcrest.Matcher +
Generate a description of why the matcher has not accepted the item. +
describeMismatch(Object, Description) - +Method in class org.hamcrest.TypeSafeDiagnosingMatcher +
  +
describeMismatch(Object, Description) - +Method in class org.hamcrest.TypeSafeMatcher +
  +
describeMismatchSafely(T, Description) - +Method in class org.hamcrest.beans.HasProperty +
  +
describeMismatchSafely(T[], Description) - +Method in class org.hamcrest.collection.IsArray +
  +
describeMismatchSafely(T[], Description) - +Method in class org.hamcrest.collection.IsArrayContaining +
  +
describeMismatchSafely(E[], Description) - +Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
  +
describeMismatchSafely(E[], Description) - +Method in class org.hamcrest.collection.IsArrayContainingInOrder +
  +
describeMismatchSafely(Collection<? extends E>, Description) - +Method in class org.hamcrest.collection.IsEmptyCollection +
  +
describeMismatchSafely(Iterable<? extends E>, Description) - +Method in class org.hamcrest.collection.IsEmptyIterable +
  +
describeMismatchSafely(Map<? extends K, ? extends V>, Description) - +Method in class org.hamcrest.collection.IsMapContaining +
  +
describeMismatchSafely(String, Description) - +Method in class org.hamcrest.core.SubstringMatcher +
  +
describeMismatchSafely(BigDecimal, Description) - +Method in class org.hamcrest.number.BigDecimalCloseTo +
  +
describeMismatchSafely(Double, Description) - +Method in class org.hamcrest.number.IsCloseTo +
  +
describeMismatchSafely(T, Description) - +Method in class org.hamcrest.number.OrderingComparison +
  +
describeMismatchSafely(Class<?>, Description) - +Method in class org.hamcrest.object.IsCompatibleType +
  +
describeMismatchSafely(String, Description) - +Method in class org.hamcrest.text.IsEqualIgnoringCase +
  +
describeMismatchSafely(String, Description) - +Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
  +
describeMismatchSafely(String, Description) - +Method in class org.hamcrest.text.StringContainsInOrder +
  +
describeMismatchSafely(T, Description) - +Method in class org.hamcrest.TypeSafeMatcher +
Subclasses should override this. +
describeTo(Description) - +Method in class org.hamcrest.beans.HasProperty +
  +
describeTo(Description) - +Method in class org.hamcrest.beans.HasPropertyWithValue +
  +
describeTo(Description) - +Method in class org.hamcrest.beans.SamePropertyValuesAs +
  +
describeTo(Description) - +Method in class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsArray +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsArrayContaining +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsArrayContainingInOrder +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsEmptyCollection +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsEmptyIterable +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsIn +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsIterableContainingInOrder +
  +
describeTo(Description) - +Method in class org.hamcrest.collection.IsMapContaining +
  +
describeTo(Description) - +Method in class org.hamcrest.core.AllOf +
  +
describeTo(Description) - +Method in class org.hamcrest.core.AnyOf +
  +
describeTo(Description) - +Method in class org.hamcrest.core.CombinableMatcher +
  +
describeTo(Description) - +Method in class org.hamcrest.core.DescribedAs +
  +
describeTo(Description) - +Method in class org.hamcrest.core.Every +
  +
describeTo(Description) - +Method in class org.hamcrest.core.Is +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsAnything +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsCollectionContaining +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsEqual +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsInstanceOf +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsNot +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsNull +
  +
describeTo(Description) - +Method in class org.hamcrest.core.IsSame +
  +
describeTo(Description) - +Method in class org.hamcrest.core.SubstringMatcher +
  +
describeTo(Description) - +Method in class org.hamcrest.CustomMatcher +
  +
describeTo(Description) - +Method in class org.hamcrest.CustomTypeSafeMatcher +
  +
describeTo(Description) - +Method in class org.hamcrest.FeatureMatcher +
  +
describeTo(StringBuffer) - +Method in class org.hamcrest.integration.JMock1Adapter +
  +
describeTo(Description) - +Method in class org.hamcrest.internal.SelfDescribingValue +
  +
describeTo(Description) - +Method in class org.hamcrest.number.BigDecimalCloseTo +
  +
describeTo(Description) - +Method in class org.hamcrest.number.IsCloseTo +
  +
describeTo(Description) - +Method in class org.hamcrest.number.OrderingComparison +
  +
describeTo(Description) - +Method in class org.hamcrest.object.IsCompatibleType +
  +
describeTo(Description) - +Method in class org.hamcrest.object.IsEventFrom +
  +
describeTo(Description) - +Method in interface org.hamcrest.SelfDescribing +
Generates a description of the object. +
describeTo(Description) - +Method in class org.hamcrest.text.IsEmptyString +
  +
describeTo(Description) - +Method in class org.hamcrest.text.IsEqualIgnoringCase +
  +
describeTo(Description) - +Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
  +
describeTo(Description) - +Method in class org.hamcrest.text.StringContainsInOrder +
  +
describeTo(Description) - +Method in class org.hamcrest.xml.HasXPath +
  +
Description - Interface in org.hamcrest
A description of a Matcher.
Description.NullDescription - Class in org.hamcrest
 
Description.NullDescription() - +Constructor for class org.hamcrest.Description.NullDescription +
  +
descriptionEnd() - +Method in class org.hamcrest.collection.IsArray +
Returns the string that ends the description. +
descriptionSeparator() - +Method in class org.hamcrest.collection.IsArray +
Returns the string that separates the elements in the description. +
descriptionStart() - +Method in class org.hamcrest.collection.IsArray +
Returns the string that starts the description. +
DiagnosingMatcher<T> - Class in org.hamcrest
TODO(ngd): Document.
DiagnosingMatcher() - +Constructor for class org.hamcrest.DiagnosingMatcher +
  +
+
+

+E

+
+
EasyMock2Adapter - Class in org.hamcrest.integration
An adapter allowing a Hamcrest Matcher + to act as an EasyMock IArgumentMatcher.
EasyMock2Adapter(Matcher<?>) - +Constructor for class org.hamcrest.integration.EasyMock2Adapter +
  +
EasyMock2Matchers - Class in org.hamcrest
 
EasyMock2Matchers() - +Constructor for class org.hamcrest.EasyMock2Matchers +
  +
either(Matcher<? super LHS>) - +Static method in class org.hamcrest.core.CombinableMatcher +
Creates a matcher that matches when either of the specified matchers match the examined object. +
either(Matcher<? super LHS>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches when either of the specified matchers match the examined object. +
either(Matcher<? super LHS>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when either of the specified matchers match the examined object. +
empty() - +Static method in class org.hamcrest.collection.IsEmptyCollection +
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +
empty() - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +
emptyArray() - +Static method in class org.hamcrest.collection.IsArrayWithSize +
Creates a matcher for arrays that matches when the length of the array + is zero. +
emptyArray() - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when the length of the array + is zero. +
emptyCollectionOf(Class<E>) - +Static method in class org.hamcrest.collection.IsEmptyCollection +
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +
emptyCollectionOf(Class<E>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +
emptyIterable() - +Static method in class org.hamcrest.collection.IsEmptyIterable +
Creates a matcher for Iterables matching examined iterables that yield no items. +
emptyIterable() - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables matching examined iterables that yield no items. +
emptyIterableOf(Class<E>) - +Static method in class org.hamcrest.collection.IsEmptyIterable +
Creates a matcher for Iterables matching examined iterables that yield no items. +
emptyIterableOf(Class<E>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables matching examined iterables that yield no items. +
endsWith(String) - +Static method in class org.hamcrest.core.StringEndsWith +
Creates a matcher that matches if the examined String ends with the specified + String. +
endsWith(String) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined String ends with the specified + String. +
endsWith(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined String ends with the specified + String. +
equalTo(T) - +Static method in class org.hamcrest.core.IsEqual +
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. +
equalTo(T) - +Static method in class org.hamcrest.CoreMatchers +
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. +
equalTo(String) - +Static method in class org.hamcrest.EasyMock2Matchers +
  +
equalTo(String) - +Static method in class org.hamcrest.JMock1Matchers +
  +
equalTo(T) - +Static method in class org.hamcrest.Matchers +
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. +
equalToIgnoringCase(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. +
equalToIgnoringCase(String) - +Static method in class org.hamcrest.text.IsEqualIgnoringCase +
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. +
equalToIgnoringWhiteSpace(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored. +
equalToIgnoringWhiteSpace(String) - +Static method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored. +
eval(Object) - +Method in class org.hamcrest.integration.JMock1Adapter +
  +
evalSubstringOf(String) - +Method in class org.hamcrest.core.StringContains +
  +
evalSubstringOf(String) - +Method in class org.hamcrest.core.StringEndsWith +
  +
evalSubstringOf(String) - +Method in class org.hamcrest.core.StringStartsWith +
  +
evalSubstringOf(String) - +Method in class org.hamcrest.core.SubstringMatcher +
  +
eventFrom(Class<? extends EventObject>, Object) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source. +
eventFrom(Object) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of EventObject that matches any EventObject + announced by source. +
eventFrom(Class<? extends EventObject>, Object) - +Static method in class org.hamcrest.object.IsEventFrom +
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source. +
eventFrom(Object) - +Static method in class org.hamcrest.object.IsEventFrom +
Creates a matcher of EventObject that matches any EventObject + announced by source. +
Every<T> - Class in org.hamcrest.core
 
Every(Matcher<? super T>) - +Constructor for class org.hamcrest.core.Every +
  +
everyItem(Matcher<U>) - +Static method in class org.hamcrest.core.Every +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +
everyItem(Matcher<U>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +
everyItem(Matcher<U>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +
expectedTypeFrom(Method) - +Method in class org.hamcrest.internal.ReflectiveTypeFinder +
  +
+
+

+F

+
+
Factory - Annotation Type in org.hamcrest
Marks a Hamcrest static factory method so tools recognise them.
FeatureMatcher<T,U> - Class in org.hamcrest
Supporting class for matching a feature of an object.
FeatureMatcher(Matcher<? super U>, String, String) - +Constructor for class org.hamcrest.FeatureMatcher +
Constructor +
featureValueOf(E[]) - +Method in class org.hamcrest.collection.IsArrayWithSize +
  +
featureValueOf(Collection<? extends E>) - +Method in class org.hamcrest.collection.IsCollectionWithSize +
  +
featureValueOf(Iterable<E>) - +Method in class org.hamcrest.collection.IsIterableWithSize +
  +
featureValueOf(T) - +Method in class org.hamcrest.FeatureMatcher +
Implement this to extract the interesting feature. +
featureValueOf(T) - +Method in class org.hamcrest.object.HasToString +
  +
findExpectedType(Class<?>) - +Method in class org.hamcrest.internal.ReflectiveTypeFinder +
  +
+
+

+G

+
+
getPropertyDescriptor(String, Object) - +Static method in class org.hamcrest.beans.PropertyUtil +
Returns the description of the property with the provided + name on the provided object's interface. +
greaterThan(T) - +Static method in class org.hamcrest.Matchers +
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. +
greaterThan(T) - +Static method in class org.hamcrest.number.OrderingComparison +
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. +
greaterThanOrEqualTo(T) - +Static method in class org.hamcrest.Matchers +
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. +
greaterThanOrEqualTo(T) - +Static method in class org.hamcrest.number.OrderingComparison +
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. +
+
+

+H

+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. +
hasEntry(K, V) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. +
hasEntry(K, V) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. +
hasEntry(Matcher<? super K>, Matcher<? super V>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. +
hasItem(Matcher<? super T>) - +Static method in class org.hamcrest.core.IsCollectionContaining +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. +
hasItem(T) - +Static method in class org.hamcrest.core.IsCollectionContaining +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. +
hasItem(T) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. +
hasItem(Matcher<? super T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. +
hasItem(T) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. +
hasItem(Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. +
hasItemInArray(Matcher<? super T>) - +Static method in class org.hamcrest.collection.IsArrayContaining +
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher. +
hasItemInArray(T) - +Static method in class org.hamcrest.collection.IsArrayContaining +
A shortcut to the frequently used hasItemInArray(equalTo(x)). +
hasItemInArray(T) - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used hasItemInArray(equalTo(x)). +
hasItemInArray(Matcher<? super T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher. +
hasItems(Matcher<? super T>...) - +Static method in class org.hamcrest.core.IsCollectionContaining +
Creates a matcher for Iterables 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. +
hasItems(T...) - +Static method in class org.hamcrest.core.IsCollectionContaining +
Creates a matcher for Iterables 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. +
hasItems(T...) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher for Iterables 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. +
hasItems(Matcher<? super T>...) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher for Iterables 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. +
hasItems(T...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables 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. +
hasItems(Matcher<? super T>...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables 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. +
hasKey(Matcher<? super K>) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. +
hasKey(K) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. +
hasKey(Matcher<? super K>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. +
hasKey(K) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. +
hasNext() - +Method in class org.hamcrest.internal.ArrayIterator +
  +
hasNext() - +Method in class org.hamcrest.internal.SelfDescribingValueIterator +
  +
HasProperty<T> - Class in org.hamcrest.beans
A Matcher that checks that an object has a JavaBean property + with the specified name.
HasProperty(String) - +Constructor for class org.hamcrest.beans.HasProperty +
  +
hasProperty(String) - +Static method in class org.hamcrest.beans.HasProperty +
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. +
hasProperty(String, Matcher<?>) - +Static method in class org.hamcrest.beans.HasPropertyWithValue +
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher. +
hasProperty(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. +
hasProperty(String, Matcher<?>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher. +
HasPropertyWithValue<T> - Class in org.hamcrest.beans
Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
HasPropertyWithValue(String, Matcher<?>) - +Constructor for class org.hamcrest.beans.HasPropertyWithValue +
  +
hasSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.collection.IsCollectionWithSize +
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. +
hasSize(int) - +Static method in class org.hamcrest.collection.IsCollectionWithSize +
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. +
hasSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. +
hasSize(int) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. +
hasToString(Matcher<? super String>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher. +
hasToString(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. +
HasToString<T> - Class in org.hamcrest.object
 
HasToString(Matcher<? super String>) - +Constructor for class org.hamcrest.object.HasToString +
  +
hasToString(Matcher<? super String>) - +Static method in class org.hamcrest.object.HasToString +
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher. +
hasToString(String) - +Static method in class org.hamcrest.object.HasToString +
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. +
hasValue(Matcher<? super V>) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. +
hasValue(V) - +Static method in class org.hamcrest.collection.IsMapContaining +
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. +
hasValue(V) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. +
hasValue(Matcher<? super V>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. +
hasXPath(String, NamespaceContext) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. +
hasXPath(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. +
hasXPath(String, NamespaceContext, Matcher<String>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. +
hasXPath(String, Matcher<String>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. +
HasXPath - Class in org.hamcrest.xml
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
HasXPath(String, Matcher<String>) - +Constructor for class org.hamcrest.xml.HasXPath +
  +
HasXPath(String, NamespaceContext, Matcher<String>) - +Constructor for class org.hamcrest.xml.HasXPath +
  +
hasXPath(String, Matcher<String>) - +Static method in class org.hamcrest.xml.HasXPath +
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. +
hasXPath(String, NamespaceContext, Matcher<String>) - +Static method in class org.hamcrest.xml.HasXPath +
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. +
hasXPath(String) - +Static method in class org.hamcrest.xml.HasXPath +
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. +
hasXPath(String, NamespaceContext) - +Static method in class org.hamcrest.xml.HasXPath +
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. +
+
+

+I

+
+
instanceOf(Class<?>) - +Static method in class org.hamcrest.core.IsInstanceOf +
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. +
instanceOf(Class<?>) - +Static method in class org.hamcrest.CoreMatchers +
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. +
instanceOf(Class<?>) - +Static method in class org.hamcrest.Matchers +
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. +
Is<T> - Class in org.hamcrest.core
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
Is(Matcher<T>) - +Constructor for class org.hamcrest.core.Is +
  +
is(Matcher<T>) - +Static method in class org.hamcrest.core.Is +
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +
is(T) - +Static method in class org.hamcrest.core.Is +
A shortcut to the frequently used is(equalTo(x)). +
is(Class<T>) - +Static method in class org.hamcrest.core.Is +
Deprecated. use isA(Class type) instead. +
is(T) - +Static method in class org.hamcrest.CoreMatchers +
A shortcut to the frequently used is(equalTo(x)). +
is(Matcher<T>) - +Static method in class org.hamcrest.CoreMatchers +
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +
is(Class<T>) - +Static method in class org.hamcrest.CoreMatchers +
Deprecated. use isA(Class type) instead. +
is(T) - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used is(equalTo(x)). +
is(Matcher<T>) - +Static method in class org.hamcrest.Matchers +
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +
is(Class<T>) - +Static method in class org.hamcrest.Matchers +
Deprecated. use isA(Class type) instead. +
isA(Class<T>) - +Static method in class org.hamcrest.core.Is +
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +
isA(Class<T>) - +Static method in class org.hamcrest.CoreMatchers +
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +
isA(Class<T>) - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +
IsAnything<T> - Class in org.hamcrest.core
A matcher that always returns true.
IsAnything() - +Constructor for class org.hamcrest.core.IsAnything +
  +
IsAnything(String) - +Constructor for class org.hamcrest.core.IsAnything +
  +
IsArray<T> - Class in org.hamcrest.collection
Matcher for array whose elements satisfy a sequence of matchers.
IsArray(Matcher<? super T>[]) - +Constructor for class org.hamcrest.collection.IsArray +
  +
IsArrayContaining<T> - Class in org.hamcrest.collection
Matches if an array contains an item satisfying a nested matcher.
IsArrayContaining(Matcher<? super T>) - +Constructor for class org.hamcrest.collection.IsArrayContaining +
  +
IsArrayContainingInAnyOrder<E> - Class in org.hamcrest.collection
 
IsArrayContainingInAnyOrder(Collection<Matcher<? super E>>) - +Constructor for class org.hamcrest.collection.IsArrayContainingInAnyOrder +
  +
IsArrayContainingInOrder<E> - Class in org.hamcrest.collection
 
IsArrayContainingInOrder(List<Matcher<? super E>>) - +Constructor for class org.hamcrest.collection.IsArrayContainingInOrder +
  +
IsArrayWithSize<E> - Class in org.hamcrest.collection
Matches if array size satisfies a nested matcher.
IsArrayWithSize(Matcher<? super Integer>) - +Constructor for class org.hamcrest.collection.IsArrayWithSize +
  +
IsCloseTo - Class in org.hamcrest.number
Is the value a number equal to a value within some range of + acceptable error?
IsCloseTo(double, double) - +Constructor for class org.hamcrest.number.IsCloseTo +
  +
IsCollectionContaining<T> - Class in org.hamcrest.core
 
IsCollectionContaining(Matcher<? super T>) - +Constructor for class org.hamcrest.core.IsCollectionContaining +
  +
IsCollectionWithSize<E> - Class in org.hamcrest.collection
Matches if collection size satisfies a nested matcher.
IsCollectionWithSize(Matcher<? super Integer>) - +Constructor for class org.hamcrest.collection.IsCollectionWithSize +
  +
IsCompatibleType<T> - Class in org.hamcrest.object
 
IsCompatibleType(Class<T>) - +Constructor for class org.hamcrest.object.IsCompatibleType +
  +
IsEmptyCollection<E> - Class in org.hamcrest.collection
Tests if collection is empty.
IsEmptyCollection() - +Constructor for class org.hamcrest.collection.IsEmptyCollection +
  +
IsEmptyIterable<E> - Class in org.hamcrest.collection
Tests if collection is empty.
IsEmptyIterable() - +Constructor for class org.hamcrest.collection.IsEmptyIterable +
  +
isEmptyOrNullString() - +Static method in class org.hamcrest.Matchers +
Creates a matcher of String that matches when the examined string is null, or + has zero length. +
isEmptyOrNullString() - +Static method in class org.hamcrest.text.IsEmptyString +
Creates a matcher of String that matches when the examined string is null, or + has zero length. +
isEmptyString() - +Static method in class org.hamcrest.Matchers +
Creates a matcher of String that matches when the examined string has zero length. +
IsEmptyString - Class in org.hamcrest.text
Matches empty Strings (and null).
IsEmptyString() - +Constructor for class org.hamcrest.text.IsEmptyString +
  +
isEmptyString() - +Static method in class org.hamcrest.text.IsEmptyString +
Creates a matcher of String that matches when the examined string has zero length. +
IsEqual<T> - Class in org.hamcrest.core
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
IsEqual(T) - +Constructor for class org.hamcrest.core.IsEqual +
  +
IsEqualIgnoringCase - Class in org.hamcrest.text
Tests if a string is equal to another string, regardless of the case.
IsEqualIgnoringCase(String) - +Constructor for class org.hamcrest.text.IsEqualIgnoringCase +
  +
IsEqualIgnoringWhiteSpace - Class in org.hamcrest.text
Tests if a string is equal to another string, ignoring any changes in whitespace.
IsEqualIgnoringWhiteSpace(String) - +Constructor for class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
  +
IsEventFrom - Class in org.hamcrest.object
Tests if the value is an event announced by a specific object.
IsEventFrom(Class<?>, Object) - +Constructor for class org.hamcrest.object.IsEventFrom +
  +
IsIn<T> - Class in org.hamcrest.collection
 
IsIn(Collection<T>) - +Constructor for class org.hamcrest.collection.IsIn +
  +
IsIn(T[]) - +Constructor for class org.hamcrest.collection.IsIn +
  +
isIn(Collection<T>) - +Static method in class org.hamcrest.collection.IsIn +
Creates a matcher that matches when the examined object is found within the + specified collection. +
isIn(T[]) - +Static method in class org.hamcrest.collection.IsIn +
Creates a matcher that matches when the examined object is found within the + specified array. +
isIn(Collection<T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when the examined object is found within the + specified collection. +
isIn(T[]) - +Static method in class org.hamcrest.Matchers +
  +
IsInstanceOf - Class in org.hamcrest.core
Tests whether the value is an instance of a class.
IsInstanceOf(Class<?>) - +Constructor for class org.hamcrest.core.IsInstanceOf +
Creates a new instance of IsInstanceOf +
IsIterableContainingInAnyOrder<T> - Class in org.hamcrest.collection
 
IsIterableContainingInAnyOrder(Collection<Matcher<? super T>>) - +Constructor for class org.hamcrest.collection.IsIterableContainingInAnyOrder +
  +
IsIterableContainingInOrder<E> - Class in org.hamcrest.collection
 
IsIterableContainingInOrder(List<Matcher<? super E>>) - +Constructor for class org.hamcrest.collection.IsIterableContainingInOrder +
  +
IsIterableWithSize<E> - Class in org.hamcrest.collection
 
IsIterableWithSize(Matcher<? super Integer>) - +Constructor for class org.hamcrest.collection.IsIterableWithSize +
  +
IsMapContaining<K,V> - Class in org.hamcrest.collection
 
IsMapContaining(Matcher<? super K>, Matcher<? super V>) - +Constructor for class org.hamcrest.collection.IsMapContaining +
  +
IsNot<T> - Class in org.hamcrest.core
Calculates the logical negation of a matcher.
IsNot(Matcher<T>) - +Constructor for class org.hamcrest.core.IsNot +
  +
IsNull<T> - Class in org.hamcrest.core
Is the value null?
IsNull() - +Constructor for class org.hamcrest.core.IsNull +
  +
isOneOf(T...) - +Static method in class org.hamcrest.collection.IsIn +
Creates a matcher that matches when the examined object is equal to one of the + specified elements. +
isOneOf(T...) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches when the examined object is equal to one of the + specified elements. +
IsSame<T> - Class in org.hamcrest.core
Is the value the same object as another value?
IsSame(T) - +Constructor for class org.hamcrest.core.IsSame +
  +
iterableWithSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.collection.IsIterableWithSize +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. +
iterableWithSize(int) - +Static method in class org.hamcrest.collection.IsIterableWithSize +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. +
iterableWithSize(Matcher<? super Integer>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. +
iterableWithSize(int) - +Static method in class org.hamcrest.Matchers +
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. +
+
+

+J

+
+
JavaLangMatcherAssert - Class in org.hamcrest
Integration method for use with Java's assert keyword.
JMock1Adapter - Class in org.hamcrest.integration
An adapter allowing a Hamcrest Matcher + to act as an jMock1 Constraint.
JMock1Adapter(Matcher<?>) - +Constructor for class org.hamcrest.integration.JMock1Adapter +
  +
JMock1Matchers - Class in org.hamcrest
 
JMock1Matchers() - +Constructor for class org.hamcrest.JMock1Matchers +
  +
+
+

+L

+
+
lessThan(T) - +Static method in class org.hamcrest.Matchers +
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. +
lessThan(T) - +Static method in class org.hamcrest.number.OrderingComparison +
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. +
lessThanOrEqualTo(T) - +Static method in class org.hamcrest.Matchers +
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. +
lessThanOrEqualTo(T) - +Static method in class org.hamcrest.number.OrderingComparison +
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. +
+
+

+M

+
+
matched(T, Description) - +Static method in class org.hamcrest.Condition +
  +
Matcher<T> - Interface in org.hamcrest
A matcher over acceptable values.
MatcherAssert - Class in org.hamcrest
 
MatcherAssert() - +Constructor for class org.hamcrest.MatcherAssert +
  +
Matchers - Class in org.hamcrest
 
Matchers() - +Constructor for class org.hamcrest.Matchers +
  +
matches(Object, Description) - +Method in class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher +
  +
matches(Object) - +Method in class org.hamcrest.collection.IsIn +
  +
matches(Object, Description) - +Method in class org.hamcrest.core.AllOf +
  +
matches(Object) - +Method in class org.hamcrest.core.AnyOf +
  +
matches(Object) - +Method in class org.hamcrest.core.DescribedAs +
  +
matches(Object) - +Method in class org.hamcrest.core.Is +
  +
matches(Object) - +Method in class org.hamcrest.core.IsAnything +
  +
matches(Object) - +Method in class org.hamcrest.core.IsEqual +
  +
matches(Object, Description) - +Method in class org.hamcrest.core.IsInstanceOf +
  +
matches(Object) - +Method in class org.hamcrest.core.IsNot +
  +
matches(Object) - +Method in class org.hamcrest.core.IsNull +
  +
matches(Object) - +Method in class org.hamcrest.core.IsSame +
  +
matches(Object) - +Method in class org.hamcrest.DiagnosingMatcher +
  +
matches(Object, Description) - +Method in class org.hamcrest.DiagnosingMatcher +
  +
matches(Object) - +Method in class org.hamcrest.integration.EasyMock2Adapter +
  +
matches(Object) - +Method in interface org.hamcrest.Matcher +
Evaluates the matcher for argument item. +
matches(Object) - +Method in class org.hamcrest.text.IsEmptyString +
  +
matches(Object) - +Method in class org.hamcrest.TypeSafeDiagnosingMatcher +
  +
matches(Object) - +Method in class org.hamcrest.TypeSafeMatcher +
Methods made final to prevent accidental override. +
matchesSafely(T) - +Method in class org.hamcrest.beans.HasProperty +
  +
matchesSafely(T, Description) - +Method in class org.hamcrest.beans.HasPropertyWithValue +
  +
matchesSafely(T, Description) - +Method in class org.hamcrest.beans.SamePropertyValuesAs +
  +
matchesSafely(T[]) - +Method in class org.hamcrest.collection.IsArray +
  +
matchesSafely(T[]) - +Method in class org.hamcrest.collection.IsArrayContaining +
  +
matchesSafely(E[]) - +Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder +
  +
matchesSafely(E[]) - +Method in class org.hamcrest.collection.IsArrayContainingInOrder +
  +
matchesSafely(Collection<? extends E>) - +Method in class org.hamcrest.collection.IsEmptyCollection +
  +
matchesSafely(Iterable<? extends E>) - +Method in class org.hamcrest.collection.IsEmptyIterable +
  +
matchesSafely(Iterable<? extends T>, Description) - +Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder +
  +
matchesSafely(Iterable<? extends E>, Description) - +Method in class org.hamcrest.collection.IsIterableContainingInOrder +
  +
matchesSafely(Map<? extends K, ? extends V>) - +Method in class org.hamcrest.collection.IsMapContaining +
  +
matchesSafely(T, Description) - +Method in class org.hamcrest.core.CombinableMatcher +
  +
matchesSafely(Iterable<T>, Description) - +Method in class org.hamcrest.core.Every +
  +
matchesSafely(Iterable<? super T>, Description) - +Method in class org.hamcrest.core.IsCollectionContaining +
  +
matchesSafely(String) - +Method in class org.hamcrest.core.SubstringMatcher +
  +
matchesSafely(T, Description) - +Method in class org.hamcrest.FeatureMatcher +
  +
matchesSafely(BigDecimal) - +Method in class org.hamcrest.number.BigDecimalCloseTo +
  +
matchesSafely(Double) - +Method in class org.hamcrest.number.IsCloseTo +
  +
matchesSafely(T) - +Method in class org.hamcrest.number.OrderingComparison +
  +
matchesSafely(Class<?>) - +Method in class org.hamcrest.object.IsCompatibleType +
  +
matchesSafely(EventObject, Description) - +Method in class org.hamcrest.object.IsEventFrom +
  +
matchesSafely(String) - +Method in class org.hamcrest.text.IsEqualIgnoringCase +
  +
matchesSafely(String) - +Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
  +
matchesSafely(String) - +Method in class org.hamcrest.text.StringContainsInOrder +
  +
matchesSafely(T, Description) - +Method in class org.hamcrest.TypeSafeDiagnosingMatcher +
Subclasses should implement this. +
matchesSafely(T) - +Method in class org.hamcrest.TypeSafeMatcher +
Subclasses should implement this. +
matchesSafely(Node, Description) - +Method in class org.hamcrest.xml.HasXPath +
  +
matching(Matcher<T>, String) - +Method in class org.hamcrest.Condition +
  +
matching(Matcher<T>) - +Method in class org.hamcrest.Condition +
  +
+
+

+N

+
+
next() - +Method in class org.hamcrest.internal.ArrayIterator +
  +
next() - +Method in class org.hamcrest.internal.SelfDescribingValueIterator +
  +
NO_ARGUMENTS - +Static variable in class org.hamcrest.beans.PropertyUtil +
  +
NO_NAMESPACE_CONTEXT - +Static variable in class org.hamcrest.xml.HasXPath +
  +
NONE - +Static variable in interface org.hamcrest.Description +
A description that consumes input but does nothing. +
not(Matcher<T>) - +Static method in class org.hamcrest.core.IsNot +
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +
not(T) - +Static method in class org.hamcrest.core.IsNot +
A shortcut to the frequently used not(equalTo(x)). +
not(Matcher<T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +
not(T) - +Static method in class org.hamcrest.CoreMatchers +
A shortcut to the frequently used not(equalTo(x)). +
not(Matcher<T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +
not(T) - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used not(equalTo(x)). +
NOT_MATCHED - +Static variable in class org.hamcrest.Condition +
  +
notMatched() - +Static method in class org.hamcrest.Condition +
  +
notNullValue() - +Static method in class org.hamcrest.core.IsNull +
A shortcut to the frequently used not(nullValue()). +
notNullValue(Class<T>) - +Static method in class org.hamcrest.core.IsNull +
A shortcut to the frequently used not(nullValue(X.class)). +
notNullValue() - +Static method in class org.hamcrest.CoreMatchers +
A shortcut to the frequently used not(nullValue()). +
notNullValue(Class<T>) - +Static method in class org.hamcrest.CoreMatchers +
A shortcut to the frequently used not(nullValue(X.class)). +
notNullValue() - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used not(nullValue()). +
notNullValue(Class<T>) - +Static method in class org.hamcrest.Matchers +
A shortcut to the frequently used not(nullValue(X.class)). +
nullValue() - +Static method in class org.hamcrest.core.IsNull +
Creates a matcher that matches if examined object is null. +
nullValue(Class<T>) - +Static method in class org.hamcrest.core.IsNull +
Creates a matcher that matches if examined object is null. +
nullValue() - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if examined object is null. +
nullValue(Class<T>) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if examined object is null. +
nullValue() - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if examined object is null. +
nullValue(Class<T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if examined object is null. +
+
+

+O

+
+
or(Matcher<? super X>) - +Method in class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher +
  +
or(Matcher<? super T>) - +Method in class org.hamcrest.core.CombinableMatcher +
  +
OrderingComparison<T extends java.lang.Comparable<T>> - Class in org.hamcrest.number
 
org.hamcrest - package org.hamcrest
The stable API defining Matcher and its associated interfaces and classes.
org.hamcrest.beans - package org.hamcrest.beans
Matchers of Java Bean properties and their values.
org.hamcrest.collection - package org.hamcrest.collection
Matchers of arrays and collections.
org.hamcrest.core - package org.hamcrest.core
Fundamental matchers of objects and values, and composite matchers.
org.hamcrest.integration - package org.hamcrest.integration
 
org.hamcrest.internal - package org.hamcrest.internal
 
org.hamcrest.number - package org.hamcrest.number
Matchers that perform numeric comparisons.
org.hamcrest.object - package org.hamcrest.object
Matchers that inspect objects and classes.
org.hamcrest.text - package org.hamcrest.text
Matchers that perform text comparisons.
org.hamcrest.xml - package org.hamcrest.xml
Matchers of XML documents.
+
+

+P

+
+
propertyDescriptorsFor(Object, Class<Object>) - +Static method in class org.hamcrest.beans.PropertyUtil +
Returns all the property descriptors for the class associated with the given object +
PropertyUtil - Class in org.hamcrest.beans
Utility class for accessing properties on JavaBean objects.
PropertyUtil() - +Constructor for class org.hamcrest.beans.PropertyUtil +
  +
+
+

+R

+
+
ReflectiveTypeFinder - Class in org.hamcrest.internal
 
ReflectiveTypeFinder(String, int, int) - +Constructor for class org.hamcrest.internal.ReflectiveTypeFinder +
  +
relationship() - +Method in class org.hamcrest.core.StringContains +
  +
relationship() - +Method in class org.hamcrest.core.StringEndsWith +
  +
relationship() - +Method in class org.hamcrest.core.StringStartsWith +
  +
relationship() - +Method in class org.hamcrest.core.SubstringMatcher +
  +
remove() - +Method in class org.hamcrest.internal.ArrayIterator +
  +
remove() - +Method in class org.hamcrest.internal.SelfDescribingValueIterator +
  +
+
+

+S

+
+
sameInstance(T) - +Static method in class org.hamcrest.core.IsSame +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
sameInstance(T) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
sameInstance(T) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
SamePropertyValuesAs<T> - Class in org.hamcrest.beans
 
SamePropertyValuesAs(T) - +Constructor for class org.hamcrest.beans.SamePropertyValuesAs +
  +
samePropertyValuesAs(T) - +Static method in class org.hamcrest.beans.SamePropertyValuesAs +
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. +
samePropertyValuesAs(T) - +Static method in class org.hamcrest.Matchers +
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. +
SamePropertyValuesAs.PropertyMatcher - Class in org.hamcrest.beans
 
SamePropertyValuesAs.PropertyMatcher(PropertyDescriptor, Object) - +Constructor for class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher +
  +
SelfDescribing - Interface in org.hamcrest
The ability of an object to describe itself.
SelfDescribingValue<T> - Class in org.hamcrest.internal
 
SelfDescribingValue(T) - +Constructor for class org.hamcrest.internal.SelfDescribingValue +
  +
SelfDescribingValueIterator<T> - Class in org.hamcrest.internal
 
SelfDescribingValueIterator(Iterator<T>) - +Constructor for class org.hamcrest.internal.SelfDescribingValueIterator +
  +
startsWith(String) - +Static method in class org.hamcrest.core.StringStartsWith +
Creates a matcher that matches if the examined String starts with the specified + String. +
startsWith(String) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches if the examined String starts with the specified + String. +
startsWith(String) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches if the examined String starts with the specified + String. +
StringContains - Class in org.hamcrest.core
Tests if the argument is a string that contains a substring.
StringContains(String) - +Constructor for class org.hamcrest.core.StringContains +
  +
stringContainsInOrder(Iterable<String>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, regardless of the order of their appearance. +
StringContainsInOrder - Class in org.hamcrest.text
 
StringContainsInOrder(Iterable<String>) - +Constructor for class org.hamcrest.text.StringContainsInOrder +
  +
stringContainsInOrder(Iterable<String>) - +Static method in class org.hamcrest.text.StringContainsInOrder +
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, regardless of the order of their appearance. +
StringDescription - Class in org.hamcrest
A Description that is stored as a string.
StringDescription() - +Constructor for class org.hamcrest.StringDescription +
  +
StringDescription(Appendable) - +Constructor for class org.hamcrest.StringDescription +
  +
StringEndsWith - Class in org.hamcrest.core
Tests if the argument is a string that contains a substring.
StringEndsWith(String) - +Constructor for class org.hamcrest.core.StringEndsWith +
  +
StringStartsWith - Class in org.hamcrest.core
Tests if the argument is a string that contains a substring.
StringStartsWith(String) - +Constructor for class org.hamcrest.core.StringStartsWith +
  +
stripSpace(String) - +Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace +
  +
substring - +Variable in class org.hamcrest.core.SubstringMatcher +
  +
SubstringMatcher - Class in org.hamcrest.core
 
SubstringMatcher(String) - +Constructor for class org.hamcrest.core.SubstringMatcher +
  +
+
+

+T

+
+
that(T, Matcher<? super T>) - +Static method in class org.hamcrest.JavaLangMatcherAssert +
  +
theInstance(T) - +Static method in class org.hamcrest.core.IsSame +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
theInstance(T) - +Static method in class org.hamcrest.CoreMatchers +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
theInstance(T) - +Static method in class org.hamcrest.Matchers +
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +
then(Condition.Step<? super T, U>) - +Method in class org.hamcrest.Condition +
  +
toString() - +Method in class org.hamcrest.BaseMatcher +
  +
toString() - +Method in class org.hamcrest.Description.NullDescription +
  +
toString(SelfDescribing) - +Static method in class org.hamcrest.StringDescription +
Return the description of a SelfDescribing object as a String. +
toString() - +Method in class org.hamcrest.StringDescription +
Returns the description as a string. +
typeCompatibleWith(Class<T>) - +Static method in class org.hamcrest.Matchers +
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. +
typeCompatibleWith(Class<T>) - +Static method in class org.hamcrest.object.IsCompatibleType +
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. +
TypeSafeDiagnosingMatcher<T> - Class in org.hamcrest
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeDiagnosingMatcher(Class<?>) - +Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher +
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder) - +Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher +
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +
TypeSafeDiagnosingMatcher() - +Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher +
The default constructor for simple sub types +
TypeSafeMatcher<T> - Class in org.hamcrest
Convenient base class for Matchers that require a non-null value of a specific type.
TypeSafeMatcher() - +Constructor for class org.hamcrest.TypeSafeMatcher +
The default constructor for simple sub types +
TypeSafeMatcher(Class<?>) - +Constructor for class org.hamcrest.TypeSafeMatcher +
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +
TypeSafeMatcher(ReflectiveTypeFinder) - +Constructor for class org.hamcrest.TypeSafeMatcher +
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +
+
+

+_

+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - +Method in class org.hamcrest.BaseMatcher +
Deprecated.  +
_dont_implement_Matcher___instead_extend_BaseMatcher_() - +Method in interface org.hamcrest.Matcher +
Deprecated. to make +
+
+A B C D E F G H I J L M N O P R S T _ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/index.html b/docs/javadoc/1.3/index.html new file mode 100644 index 000000000..ff0017d9d --- /dev/null +++ b/docs/javadoc/1.3/index.html @@ -0,0 +1,39 @@ + + + + + + +Hamcrest + + + + + + + + + + + +<H2> +Frame Alert</H2> + +<P> +This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. +<BR> +Link to<A HREF="overview-summary.html">Non-frame version.</A> + + + diff --git a/docs/javadoc/1.3/org/hamcrest/BaseDescription.html b/docs/javadoc/1.3/org/hamcrest/BaseDescription.html new file mode 100644 index 000000000..7e55aea14 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/BaseDescription.html @@ -0,0 +1,514 @@ + + + + + + +BaseDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class BaseDescription

+
+java.lang.Object
+  extended by org.hamcrest.BaseDescription
+
+
+
All Implemented Interfaces:
Description
+
+
+
Direct Known Subclasses:
StringDescription
+
+
+
+
public abstract class BaseDescription
extends java.lang.Object
implements Description
+ + +

+A Description that is stored as a string. +

+ +

+


+ +

+ + + + + + + +
+Nested Class Summary
+ + + + + + + +
Nested classes/interfaces inherited from interface org.hamcrest.Description
Description.NullDescription
+  + + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from interface org.hamcrest.Description
NONE
+  + + + + + + + + + + +
+Constructor Summary
BaseDescription() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected abstract  voidappend(char c) + +
+          Append the char c to the description.
+protected  voidappend(java.lang.String str) + +
+          Append the String str to the description.
+ DescriptionappendDescriptionOf(SelfDescribing value) + +
+          Appends the description of a SelfDescribing value to this description.
+ DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+          Appends a list of SelfDescribing objects + to the description.
+ DescriptionappendText(java.lang.String text) + +
+          Appends some plain text to the description.
+ DescriptionappendValue(java.lang.Object value) + +
+          Appends an arbitary value to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+          Appends a list of values to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+          Appends a list of values to the description.
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+BaseDescription

+
+public BaseDescription()
+
+
+ + + + + + + + +
+Method Detail
+ +

+appendText

+
+public Description appendText(java.lang.String text)
+
+
Description copied from interface: Description
+
Appends some plain text to the description. +

+

+
Specified by:
appendText in interface Description
+
+
+
+
+
+
+ +

+appendDescriptionOf

+
+public Description appendDescriptionOf(SelfDescribing value)
+
+
Description copied from interface: Description
+
Appends the description of a SelfDescribing value to this description. +

+

+
Specified by:
appendDescriptionOf in interface Description
+
+
+
+
+
+
+ +

+appendValue

+
+public Description appendValue(java.lang.Object value)
+
+
Description copied from interface: Description
+
Appends an arbitary value to the description. +

+

+
Specified by:
appendValue in interface Description
+
+
+
+
+
+
+ +

+appendValueList

+
+public <T> Description appendValueList(java.lang.String start,
+                                       java.lang.String separator,
+                                       java.lang.String end,
+                                       T... values)
+
+
Description copied from interface: Description
+
Appends a list of values to the description. +

+

+
Specified by:
appendValueList in interface Description
+
+
+
+
+
+
+ +

+appendValueList

+
+public <T> Description appendValueList(java.lang.String start,
+                                       java.lang.String separator,
+                                       java.lang.String end,
+                                       java.lang.Iterable<T> values)
+
+
Description copied from interface: Description
+
Appends a list of values to the description. +

+

+
Specified by:
appendValueList in interface Description
+
+
+
+
+
+
+ +

+appendList

+
+public Description appendList(java.lang.String start,
+                              java.lang.String separator,
+                              java.lang.String end,
+                              java.lang.Iterable<? extends SelfDescribing> values)
+
+
Description copied from interface: Description
+
Appends a list of SelfDescribing objects + to the description. +

+

+
Specified by:
appendList in interface Description
+
+
+
+
+
+
+ +

+append

+
+protected void append(java.lang.String str)
+
+
Append the String str to the description. + The default implementation passes every character to append(char). + Override in subclasses to provide an efficient implementation. +

+

+
+
+
+
+
+
+
+ +

+append

+
+protected abstract void append(char c)
+
+
Append the char c to the description. +

+

+
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/BaseMatcher.html b/docs/javadoc/1.3/org/hamcrest/BaseMatcher.html new file mode 100644 index 000000000..95500177c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/BaseMatcher.html @@ -0,0 +1,346 @@ + + + + + + +BaseMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class BaseMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
AnyOf, CustomMatcher, DescribedAs, DiagnosingMatcher, Is, IsAnything, IsEmptyString, IsEqual, IsIn, IsNot, IsNull, IsSame, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
+
public abstract class BaseMatcher<T>
extends java.lang.Object
implements Matcher<T>
+ + +

+BaseClass for all Matcher implementations. +

+ +

+

+
See Also:
Matcher
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
BaseMatcher() + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ void_dont_implement_Matcher___instead_extend_BaseMatcher_() + +
+          Deprecated. 
+ voiddescribeMismatch(java.lang.Object item, + Description description) + +
+          Generate a description of why the matcher has not accepted the item.
+ java.lang.StringtoString() + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+ + + + + + + +
Methods inherited from interface org.hamcrest.Matcher
matches
+ + + + + + + +
Methods inherited from interface org.hamcrest.SelfDescribing
describeTo
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+BaseMatcher

+
+public BaseMatcher()
+
+
+ + + + + + + + +
+Method Detail
+ +

+_dont_implement_Matcher___instead_extend_BaseMatcher_

+
+@Deprecated
+public final void _dont_implement_Matcher___instead_extend_BaseMatcher_()
+
+
Deprecated.  +

+

Description copied from interface: Matcher
+
This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors . +

+

+
Specified by:
_dont_implement_Matcher___instead_extend_BaseMatcher_ in interface Matcher<T>
+
+
+
See Also:
Matcher._dont_implement_Matcher___instead_extend_BaseMatcher_()
+
+
+
+ +

+describeMismatch

+
+public void describeMismatch(java.lang.Object item,
+                             Description description)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
description - The description to be built or appended to.
+
+
+
+ +

+toString

+
+public java.lang.String toString()
+
+
+
Overrides:
toString in class java.lang.Object
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Condition.Step.html b/docs/javadoc/1.3/org/hamcrest/Condition.Step.html new file mode 100644 index 000000000..c02ac9f5b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Condition.Step.html @@ -0,0 +1,211 @@ + + + + + + +Condition.Step (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Interface Condition.Step<I,O>

+
+
Enclosing class:
Condition<T>
+
+
+
+
public static interface Condition.Step<I,O>
+ + +

+


+ +

+ + + + + + + + + + + + +
+Method Summary
+ Condition<O>apply(I value, + Description mismatch) + +
+           
+  +

+ + + + + + + + +
+Method Detail
+ +

+apply

+
+Condition<O> apply(I value,
+                   Description mismatch)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Condition.html b/docs/javadoc/1.3/org/hamcrest/Condition.html new file mode 100644 index 000000000..768c41749 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Condition.html @@ -0,0 +1,412 @@ + + + + + + +Condition (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class Condition<T>

+
+java.lang.Object
+  extended by org.hamcrest.Condition<T>
+
+
+
+
public abstract class Condition<T>
extends java.lang.Object
+ + +

+A Condition implements part of a multi-step match. We sometimes need to write matchers + that have a sequence of steps, where each step depends on the result of the previous + step and we can stop processing as soon as a step fails. These classes provide + infrastructure for writing such a sequence. + + Based on https://github.com/npryce/maybe-java +

+ +

+

+
Author:
+
Steve Freeman 2012 http://www.hamcrest.com
+
+
+ +

+ + + + + + + + + + + +
+Nested Class Summary
+static interfaceCondition.Step<I,O> + +
+           
+ + + + + + + + + + +
+Field Summary
+static org.hamcrest.Condition.NotMatched<java.lang.Object>NOT_MATCHED + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+abstract + + + + +
+<U> Condition<U>
+
and(Condition.Step<? super T,U> mapping) + +
+           
+static + + + + +
+<T> Condition<T>
+
matched(T theValue, + Description mismatch) + +
+           
+ booleanmatching(Matcher<T> match) + +
+           
+abstract  booleanmatching(Matcher<T> match, + java.lang.String message) + +
+           
+static + + + + +
+<T> Condition<T>
+
notMatched() + +
+           
+ + + + + +
+<U> Condition<U>
+
then(Condition.Step<? super T,U> mapping) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+NOT_MATCHED

+
+public static final org.hamcrest.Condition.NotMatched<java.lang.Object> NOT_MATCHED
+
+
+
+
+ + + + + + + + +
+Method Detail
+ +

+matching

+
+public abstract boolean matching(Matcher<T> match,
+                                 java.lang.String message)
+
+
+
+
+
+
+ +

+and

+
+public abstract <U> Condition<U> and(Condition.Step<? super T,U> mapping)
+
+
+
+
+
+
+ +

+matching

+
+public final boolean matching(Matcher<T> match)
+
+
+
+
+
+
+ +

+then

+
+public final <U> Condition<U> then(Condition.Step<? super T,U> mapping)
+
+
+
+
+
+
+ +

+notMatched

+
+public static <T> Condition<T> notMatched()
+
+
+
+
+
+
+ +

+matched

+
+public static <T> Condition<T> matched(T theValue,
+                                       Description mismatch)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/CoreMatchers.html b/docs/javadoc/1.3/org/hamcrest/CoreMatchers.html new file mode 100644 index 000000000..88aa91665 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/CoreMatchers.html @@ -0,0 +1,1629 @@ + + + + + + +CoreMatchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class CoreMatchers

+
+java.lang.Object
+  extended by org.hamcrest.CoreMatchers
+
+
+
+
public class CoreMatchers
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
CoreMatchers() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<T>
+
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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
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(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(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(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(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>
+
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(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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
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(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(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(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(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>anything() + +
+          Creates a matcher that always matches, regardless of the examined object.
+static Matcher<java.lang.Object>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>
+
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>containsString(java.lang.String substring) + +
+          Creates a matcher that matches if the examined String contains the specified + String anywhere.
+static + + + + +
+<T> Matcher<T>
+
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>
+
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>endsWith(java.lang.String suffix) + +
+          Creates a matcher that matches if the examined String ends with the specified + String.
+static + + + + +
+<T> Matcher<T>
+
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>>
+
everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
hasItem(T item) + +
+          Creates a matcher for Iterables 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>>
+
hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
hasItems(T... items) + +
+          Creates a matcher for Iterables 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>
+
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(java.lang.Class<T> type) + +
+          Deprecated. use isA(Class type) instead.
+static + + + + +
+<T> Matcher<T>
+
is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
is(T value) + +
+          A shortcut to the frequently used is(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
isA(java.lang.Class<T> type) + +
+          A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+static + + + + +
+<T> Matcher<T>
+
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>
+
not(T value) + +
+          A shortcut to the frequently used not(equalTo(x)).
+static Matcher<java.lang.Object>notNullValue() + +
+          A shortcut to the frequently used not(nullValue()).
+static + + + + +
+<T> Matcher<T>
+
notNullValue(java.lang.Class<T> type) + +
+          A shortcut to the frequently used not(nullValue(X.class)).
+static Matcher<java.lang.Object>nullValue() + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
nullValue(java.lang.Class<T> type) + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
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>startsWith(java.lang.String prefix) + +
+          Creates a matcher that matches if the examined String starts with the specified + String.
+static + + + + +
+<T> Matcher<T>
+
theInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CoreMatchers

+
+public CoreMatchers()
+
+
+ + + + + + + + +
+Method Detail
+ +

+allOf

+
+public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T> first,
+                                   Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<T> first,
+                                 Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+both

+
+public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when both of the specified matchers match the examined object. +

+ For example: +

assertThat("fab", both(containsString("a")).and(containsString("b")))
+

+

+
+
+
+
+ +

+either

+
+public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when either of the specified matchers match the examined object. +

+ For example: +

assertThat("fan", either(containsString("a")).and(containsString("b")))
+

+

+
+
+
+
+ +

+describedAs

+
+public static <T> Matcher<T> describedAs(java.lang.String description,
+                                         Matcher<T> matcher,
+                                         java.lang.Object... values)
+
+
Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. +

+ For example: +

describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
+

+

+
Parameters:
description - the new description for the wrapped matcher
matcher - the matcher to wrap
values - optional values to insert into the tokenised description
+
+
+
+ +

+everyItem

+
+public static <U> Matcher<java.lang.Iterable<U>> everyItem(Matcher<U> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +

+ For example: +

assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to every item provided by the examined Iterable
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(T value)
+
+
A shortcut to the frequently used is(equalTo(x)). +

+ For example: +

assertThat(cheese, is(smelly))
+ instead of: +
assertThat(cheese, is(equalTo(smelly)))
+

+

+
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(Matcher<T> matcher)
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +

+ For example: +

assertThat(cheese, is(equalTo(smelly)))
+ instead of: +
assertThat(cheese, equalTo(smelly))
+

+

+
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(java.lang.Class<T> type)
+
+
Deprecated. use isA(Class type) instead. +

+

A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, is(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+
+ +

+isA

+
+public static <T> Matcher<T> isA(java.lang.Class<T> type)
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, isA(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything()
+
+
Creates a matcher that always matches, regardless of the examined object. +

+

+
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything(java.lang.String description)
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +

+

+
Parameters:
description - a meaningful String used when describing itself
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
+

+

+
Parameters:
item - the item to compare against the items provided by the examined Iterable
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
+

+

+
Parameters:
items - the items to compare against the items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
+

+

+
Parameters:
itemMatchers - the matchers to apply to items provided by the examined Iterable
+
+
+
+ +

+equalTo

+
+public static <T> Matcher<T> 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. + +

If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

+ +

The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

+

+ For example: +

+ assertThat("foo", equalTo("foo"));
+ assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
+ 
+

+

+
+
+
+
+ +

+any

+
+public static <T> Matcher<T> 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. + +

The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

+

+ For example: +

assertThat(new Canoe(), instanceOf(Canoe.class));
+

+

+
+
+
+
+ +

+instanceOf

+
+public static <T> Matcher<T> 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. + +

The created matcher assumes no relationship between specified type and the examined object.

+

+ For example: +

assertThat(new Canoe(), instanceOf(Paddlable.class));
+

+

+
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(Matcher<T> matcher)
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +

+ For example: +

assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
matcher - the matcher whose sense should be inverted
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(T value)
+
+
A shortcut to the frequently used not(equalTo(x)). +

+ For example: +

assertThat(cheese, is(not(smelly)))
+ instead of: +
assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
value - the value that any examined object should not equal
+
+
+
+ +

+nullValue

+
+public static Matcher<java.lang.Object> nullValue()
+
+
Creates a matcher that matches if examined object is null. +

+ For example: +

assertThat(cheese, is(nullValue())
+

+

+
+
+
+
+ +

+nullValue

+
+public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
+
+
Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. +

+ For example: +

assertThat(cheese, is(nullValue(Cheese.class))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+
+ +

+notNullValue

+
+public static Matcher<java.lang.Object> notNullValue()
+
+
A shortcut to the frequently used not(nullValue()). +

+ For example: +

assertThat(cheese, is(notNullValue()))
+ instead of: +
assertThat(cheese, is(not(nullValue())))
+

+

+
+
+
+
+ +

+notNullValue

+
+public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
+
+
A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. +

+ For example: +

assertThat(cheese, is(notNullValue(X.class)))
+ instead of: +
assertThat(cheese, is(not(nullValue(X.class))))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+
+ +

+sameInstance

+
+public static <T> Matcher<T> sameInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+
+ +

+theInstance

+
+public static <T> Matcher<T> theInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+
+ +

+containsString

+
+public static Matcher<java.lang.String> containsString(java.lang.String substring)
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere. +

+ For example: +

assertThat("myStringOfNote", containsString("ring"))
+

+

+
Parameters:
substring - the substring that the returned matcher will expect to find within any examined string
+
+
+
+ +

+startsWith

+
+public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
+
+
Creates a matcher that matches if the examined String starts with the specified + String. +

+ For example: +

assertThat("myStringOfNote", startsWith("my"))
+

+

+
Parameters:
prefix - the substring that the returned matcher will expect at the start of any examined string
+
+
+
+ +

+endsWith

+
+public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
+
+
Creates a matcher that matches if the examined String ends with the specified + String. +

+ For example: +

assertThat("myStringOfNote", endsWith("Note"))
+

+

+
Parameters:
suffix - the substring that the returned matcher will expect at the end of any examined string
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/CustomMatcher.html b/docs/javadoc/1.3/org/hamcrest/CustomMatcher.html new file mode 100644 index 000000000..8ddd0c68b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/CustomMatcher.html @@ -0,0 +1,302 @@ + + + + + + +CustomMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class CustomMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.CustomMatcher<T>
+
+
+
Type Parameters:
T - The type of object being matched.
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public abstract class CustomMatcher<T>
extends BaseMatcher<T>
+ + +

+Utility class for writing one off matchers. + For example: +

+ Matcher<String> aNonEmptyString = new CustomMatcher<String>("a non empty string") {
+   public boolean matches(Object object) {
+     return ((object instanceof String) && !((String) object).isEmpty();
+   }
+ };
+ 
+

+ This class is designed for scenarios where an anonymous inner class + matcher makes sense. It should not be used by API designers implementing + matchers. +

+ +

+

+
Author:
+
Neil Dunn
+
See Also:
for a type safe variant of this class that you probably + want to use.
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
CustomMatcher(java.lang.String description) + +
+           
+  + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+ + + + + + + +
Methods inherited from interface org.hamcrest.Matcher
matches
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CustomMatcher

+
+public CustomMatcher(java.lang.String description)
+
+
+ + + + + + + + +
+Method Detail
+ +

+describeTo

+
+public final void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/CustomTypeSafeMatcher.html b/docs/javadoc/1.3/org/hamcrest/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..d9d00a48d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/CustomTypeSafeMatcher.html @@ -0,0 +1,305 @@ + + + + + + +CustomTypeSafeMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class CustomTypeSafeMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T>
+          extended by org.hamcrest.CustomTypeSafeMatcher<T>
+
+
+
Type Parameters:
T - The type of object being matched
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public abstract class CustomTypeSafeMatcher<T>
extends TypeSafeMatcher<T>
+ + +

+Utility class for writing one off matchers. + For example: +

+ Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
+   public boolean matchesSafely(String string) {
+     return !string.isEmpty();
+   }
+   public void describeMismatchSafely(String string, Description mismatchDescription) {
+     mismatchDescription.appendText("was empty");
+   }
+ };
+ 
+ This is a variant of CustomMatcher that first type checks + the argument being matched. By the time TypeSafeMatcher.matchesSafely(T) is + is called the argument is guaranteed to be non-null and of the correct + type. +

+ +

+

+
Author:
+
Neil Dunn
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
CustomTypeSafeMatcher(java.lang.String description) + +
+           
+  + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, describeMismatchSafely, matches, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CustomTypeSafeMatcher

+
+public CustomTypeSafeMatcher(java.lang.String description)
+
+
+ + + + + + + + +
+Method Detail
+ +

+describeTo

+
+public final void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Description.NullDescription.html b/docs/javadoc/1.3/org/hamcrest/Description.NullDescription.html new file mode 100644 index 000000000..d9e46f4b8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Description.NullDescription.html @@ -0,0 +1,482 @@ + + + + + + +Description.NullDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class Description.NullDescription

+
+java.lang.Object
+  extended by org.hamcrest.Description.NullDescription
+
+
+
All Implemented Interfaces:
Description
+
+
+
Enclosing interface:
Description
+
+
+
+
public static final class Description.NullDescription
extends java.lang.Object
implements Description
+ + +

+


+ +

+ + + + + + + +
+Nested Class Summary
+ + + + + + + +
Nested classes/interfaces inherited from interface org.hamcrest.Description
Description.NullDescription
+  + + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from interface org.hamcrest.Description
NONE
+  + + + + + + + + + + +
+Constructor Summary
Description.NullDescription() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ DescriptionappendDescriptionOf(SelfDescribing value) + +
+          Appends the description of a SelfDescribing value to this description.
+ DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+          Appends a list of SelfDescribing objects + to the description.
+ DescriptionappendText(java.lang.String text) + +
+          Appends some plain text to the description.
+ DescriptionappendValue(java.lang.Object value) + +
+          Appends an arbitary value to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+          Appends a list of values to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+          Appends a list of values to the description.
+ java.lang.StringtoString() + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Description.NullDescription

+
+public Description.NullDescription()
+
+
+ + + + + + + + +
+Method Detail
+ +

+appendDescriptionOf

+
+public Description appendDescriptionOf(SelfDescribing value)
+
+
Description copied from interface: Description
+
Appends the description of a SelfDescribing value to this description. +

+

+
Specified by:
appendDescriptionOf in interface Description
+
+
+
+
+
+
+ +

+appendList

+
+public Description appendList(java.lang.String start,
+                              java.lang.String separator,
+                              java.lang.String end,
+                              java.lang.Iterable<? extends SelfDescribing> values)
+
+
Description copied from interface: Description
+
Appends a list of SelfDescribing objects + to the description. +

+

+
Specified by:
appendList in interface Description
+
+
+
+
+
+
+ +

+appendText

+
+public Description appendText(java.lang.String text)
+
+
Description copied from interface: Description
+
Appends some plain text to the description. +

+

+
Specified by:
appendText in interface Description
+
+
+
+
+
+
+ +

+appendValue

+
+public Description appendValue(java.lang.Object value)
+
+
Description copied from interface: Description
+
Appends an arbitary value to the description. +

+

+
Specified by:
appendValue in interface Description
+
+
+
+
+
+
+ +

+appendValueList

+
+public <T> Description appendValueList(java.lang.String start,
+                                       java.lang.String separator,
+                                       java.lang.String end,
+                                       T... values)
+
+
Description copied from interface: Description
+
Appends a list of values to the description. +

+

+
Specified by:
appendValueList in interface Description
+
+
+
+
+
+
+ +

+appendValueList

+
+public <T> Description appendValueList(java.lang.String start,
+                                       java.lang.String separator,
+                                       java.lang.String end,
+                                       java.lang.Iterable<T> values)
+
+
Description copied from interface: Description
+
Appends a list of values to the description. +

+

+
Specified by:
appendValueList in interface Description
+
+
+
+
+
+
+ +

+toString

+
+public java.lang.String toString()
+
+
+
Overrides:
toString in class java.lang.Object
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Description.html b/docs/javadoc/1.3/org/hamcrest/Description.html new file mode 100644 index 000000000..a261a899e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Description.html @@ -0,0 +1,412 @@ + + + + + + +Description (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Interface Description

+
+
All Known Implementing Classes:
BaseDescription, Description.NullDescription, StringDescription
+
+
+
+
public interface Description
+ + +

+A description of a Matcher. A Matcher will describe itself to a description + which can later be used for reporting. +

+ +

+

+
See Also:
SelfDescribing.describeTo(Description)
+
+ +

+ + + + + + + + + + + +
+Nested Class Summary
+static classDescription.NullDescription + +
+           
+ + + + + + + + + + +
+Field Summary
+static DescriptionNONE + +
+          A description that consumes input but does nothing.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ DescriptionappendDescriptionOf(SelfDescribing value) + +
+          Appends the description of a SelfDescribing value to this description.
+ DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+          Appends a list of SelfDescribing objects + to the description.
+ DescriptionappendText(java.lang.String text) + +
+          Appends some plain text to the description.
+ DescriptionappendValue(java.lang.Object value) + +
+          Appends an arbitary value to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+          Appends a list of values to the description.
+ + + + + +
+<T> Description
+
appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+          Appends a list of values to the description.
+  +

+ + + + + + + + +
+Field Detail
+ +

+NONE

+
+static final Description NONE
+
+
A description that consumes input but does nothing. +

+

+
+
+ + + + + + + + +
+Method Detail
+ +

+appendText

+
+Description appendText(java.lang.String text)
+
+
Appends some plain text to the description. +

+

+
+
+
+
+ +

+appendDescriptionOf

+
+Description appendDescriptionOf(SelfDescribing value)
+
+
Appends the description of a SelfDescribing value to this description. +

+

+
+
+
+
+ +

+appendValue

+
+Description appendValue(java.lang.Object value)
+
+
Appends an arbitary value to the description. +

+

+
+
+
+
+ +

+appendValueList

+
+<T> Description appendValueList(java.lang.String start,
+                                java.lang.String separator,
+                                java.lang.String end,
+                                T... values)
+
+
Appends a list of values to the description. +

+

+
+
+
+
+ +

+appendValueList

+
+<T> Description appendValueList(java.lang.String start,
+                                java.lang.String separator,
+                                java.lang.String end,
+                                java.lang.Iterable<T> values)
+
+
Appends a list of values to the description. +

+

+
+
+
+
+ +

+appendList

+
+Description appendList(java.lang.String start,
+                       java.lang.String separator,
+                       java.lang.String end,
+                       java.lang.Iterable<? extends SelfDescribing> values)
+
+
Appends a list of SelfDescribing objects + to the description. +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/DiagnosingMatcher.html b/docs/javadoc/1.3/org/hamcrest/DiagnosingMatcher.html new file mode 100644 index 000000000..a3e89ebe0 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/DiagnosingMatcher.html @@ -0,0 +1,344 @@ + + + + + + +DiagnosingMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class DiagnosingMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.DiagnosingMatcher<T>
+
+
+
Type Parameters:
T -
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
AllOf, IsInstanceOf, SamePropertyValuesAs.PropertyMatcher
+
+
+
+
public abstract class DiagnosingMatcher<T>
extends BaseMatcher<T>
+ + +

+TODO(ngd): Document. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
DiagnosingMatcher() + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+          Generate a description of why the matcher has not accepted the item.
+ booleanmatches(java.lang.Object item) + +
+          Evaluates the matcher for argument item.
+protected abstract  booleanmatches(java.lang.Object item, + Description mismatchDescription) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+ + + + + + + +
Methods inherited from interface org.hamcrest.SelfDescribing
describeTo
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+DiagnosingMatcher

+
+public DiagnosingMatcher()
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public final boolean matches(java.lang.Object item)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
item - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeMismatch

+
+public final void describeMismatch(java.lang.Object item,
+                                   Description mismatchDescription)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
Overrides:
describeMismatch in class BaseMatcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
mismatchDescription - The description to be built or appended to.
+
+
+
+ +

+matches

+
+protected abstract boolean matches(java.lang.Object item,
+                                   Description mismatchDescription)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/EasyMock2Matchers.html b/docs/javadoc/1.3/org/hamcrest/EasyMock2Matchers.html new file mode 100644 index 000000000..6c02f5d5c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/EasyMock2Matchers.html @@ -0,0 +1,256 @@ + + + + + + +EasyMock2Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class EasyMock2Matchers

+
+java.lang.Object
+  extended by org.hamcrest.EasyMock2Matchers
+
+
+
+
public class EasyMock2Matchers
extends java.lang.Object
+ + +

+

+
Author:
+
Joe Walnes
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
EasyMock2Matchers() + +
+           
+  + + + + + + + + + + + +
+Method Summary
+static java.lang.StringequalTo(java.lang.String string) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+EasyMock2Matchers

+
+public EasyMock2Matchers()
+
+
+ + + + + + + + +
+Method Detail
+ +

+equalTo

+
+public static java.lang.String equalTo(java.lang.String string)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Factory.html b/docs/javadoc/1.3/org/hamcrest/Factory.html new file mode 100644 index 000000000..5fb6900f8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Factory.html @@ -0,0 +1,178 @@ + + + + + + +Factory (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Annotation Type Factory

+
+
+
@Retention(value=RUNTIME)
+@Target(value=METHOD)
+public @interface Factory
+ + +

+Marks a Hamcrest static factory method so tools recognise them. + A factory method is an equivalent to a named constructor. +

+ +

+

+
Author:
+
Joe Walnes
+
+ +

+ +

+ +


+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/FeatureMatcher.html b/docs/javadoc/1.3/org/hamcrest/FeatureMatcher.html new file mode 100644 index 000000000..20078aac8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/FeatureMatcher.html @@ -0,0 +1,348 @@ + + + + + + +FeatureMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class FeatureMatcher<T,U>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.FeatureMatcher<T,U>
+
+
+
Type Parameters:
T - The type of the object to be matched
U - The type of the feature to be matched
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
HasToString, IsArrayWithSize, IsCollectionWithSize, IsIterableWithSize
+
+
+
+
public abstract class FeatureMatcher<T,U>
extends TypeSafeDiagnosingMatcher<T>
+ + +

+Supporting class for matching a feature of an object. Implement featureValueOf() + in a subclass to pull out the feature to be matched against. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
FeatureMatcher(Matcher<? super U> subMatcher, + java.lang.String featureDescription, + java.lang.String featureName) + +
+          Constructor
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+protected abstract  UfeatureValueOf(T actual) + +
+          Implement this to extract the interesting feature.
+protected  booleanmatchesSafely(T actual, + Description mismatch) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+FeatureMatcher

+
+public FeatureMatcher(Matcher<? super U> subMatcher,
+                      java.lang.String featureDescription,
+                      java.lang.String featureName)
+
+
Constructor +

+

+
Parameters:
subMatcher - The matcher to apply to the feature
featureDescription - Descriptive text to use in describeTo
featureName - Identifying text for mismatch message
+
+ + + + + + + + +
+Method Detail
+ +

+featureValueOf

+
+protected abstract U featureValueOf(T actual)
+
+
Implement this to extract the interesting feature. +

+

+
Parameters:
actual - the target object +
Returns:
the feature to be matched
+
+
+
+ +

+matchesSafely

+
+protected boolean matchesSafely(T actual,
+                                Description mismatch)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public final void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/JMock1Matchers.html b/docs/javadoc/1.3/org/hamcrest/JMock1Matchers.html new file mode 100644 index 000000000..5ede24f20 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/JMock1Matchers.html @@ -0,0 +1,252 @@ + + + + + + +JMock1Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class JMock1Matchers

+
+java.lang.Object
+  extended by org.hamcrest.JMock1Matchers
+
+
+
+
public class JMock1Matchers
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
JMock1Matchers() + +
+           
+  + + + + + + + + + + + +
+Method Summary
+static org.jmock.core.ConstraintequalTo(java.lang.String string) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+JMock1Matchers

+
+public JMock1Matchers()
+
+
+ + + + + + + + +
+Method Detail
+ +

+equalTo

+
+public static org.jmock.core.Constraint equalTo(java.lang.String string)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/JavaLangMatcherAssert.html b/docs/javadoc/1.3/org/hamcrest/JavaLangMatcherAssert.html new file mode 100644 index 000000000..1e418dd8c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/JavaLangMatcherAssert.html @@ -0,0 +1,240 @@ + + + + + + +JavaLangMatcherAssert (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class JavaLangMatcherAssert

+
+java.lang.Object
+  extended by org.hamcrest.JavaLangMatcherAssert
+
+
+
+
public class JavaLangMatcherAssert
extends java.lang.Object
+ + +

+Integration method for use with Java's assert keyword. + Example: +

+ assert that("Foo", startsWith("f"));
+ 
+

+ +

+

+
Author:
+
Neil Dunn
+
+
+ +

+ + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> boolean
+
that(T argument, + Matcher<? super T> matcher) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+that

+
+public static <T> boolean that(T argument,
+                               Matcher<? super T> matcher)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Matcher.html b/docs/javadoc/1.3/org/hamcrest/Matcher.html new file mode 100644 index 000000000..c8c6d8d9d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Matcher.html @@ -0,0 +1,310 @@ + + + + + + +Matcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Interface Matcher<T>

+
+
All Superinterfaces:
SelfDescribing
+
+
+
All Known Implementing Classes:
AllOf, AnyOf, BaseMatcher, BigDecimalCloseTo, CombinableMatcher, CustomMatcher, CustomTypeSafeMatcher, DescribedAs, DiagnosingMatcher, Every, FeatureMatcher, HasProperty, HasPropertyWithValue, HasToString, HasXPath, Is, IsAnything, IsArray, IsArrayContaining, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsArrayWithSize, IsCloseTo, IsCollectionContaining, IsCollectionWithSize, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEmptyString, IsEqual, IsEqualIgnoringCase, IsEqualIgnoringWhiteSpace, IsEventFrom, IsIn, IsInstanceOf, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, IsIterableWithSize, IsMapContaining, IsNot, IsNull, IsSame, OrderingComparison, SamePropertyValuesAs, SamePropertyValuesAs.PropertyMatcher, StringContains, StringContainsInOrder, StringEndsWith, StringStartsWith, SubstringMatcher, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
+
public interface Matcher<T>
extends SelfDescribing
+ + +

+A matcher over acceptable values. + A matcher is able to describe itself to give feedback when it fails. +

+ Matcher implementations should NOT directly implement this interface. + Instead, extend the BaseMatcher abstract class, + which will ensure that the Matcher API can grow to support + new features and remain compatible with all Matcher implementations. +

+ For easy access to common Matcher implementations, use the static factory + methods in CoreMatchers. +

+ N.B. Well designed matchers should be immutable. +

+ +

+

+
See Also:
CoreMatchers, +BaseMatcher
+
+ +

+ + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ void_dont_implement_Matcher___instead_extend_BaseMatcher_() + +
+          Deprecated. to make
+ voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+          Generate a description of why the matcher has not accepted the item.
+ booleanmatches(java.lang.Object item) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from interface org.hamcrest.SelfDescribing
describeTo
+  +

+ + + + + + + + +
+Method Detail
+ +

+matches

+
+boolean matches(java.lang.Object item)
+
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
+
+
+
Parameters:
item - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeMismatch

+
+void describeMismatch(java.lang.Object item,
+                      Description mismatchDescription)
+
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
+
+
+
Parameters:
item - The item that the Matcher has rejected.
mismatchDescription - The description to be built or appended to.
+
+
+
+ +

+_dont_implement_Matcher___instead_extend_BaseMatcher_

+
+@Deprecated
+void _dont_implement_Matcher___instead_extend_BaseMatcher_()
+
+
Deprecated. to make +

+

This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors . +

+

+
+
+
+
See Also:
for reasons why., +BaseMatcher
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/MatcherAssert.html b/docs/javadoc/1.3/org/hamcrest/MatcherAssert.html new file mode 100644 index 000000000..0f0874d85 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/MatcherAssert.html @@ -0,0 +1,312 @@ + + + + + + +MatcherAssert (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class MatcherAssert

+
+java.lang.Object
+  extended by org.hamcrest.MatcherAssert
+
+
+
+
public class MatcherAssert
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
MatcherAssert() + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static voidassertThat(java.lang.String reason, + boolean assertion) + +
+           
+static + + + + +
+<T> void
+
assertThat(java.lang.String reason, + T actual, + Matcher<? super T> matcher) + +
+           
+static + + + + +
+<T> void
+
assertThat(T actual, + Matcher<? super T> matcher) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+MatcherAssert

+
+public MatcherAssert()
+
+
+ + + + + + + + +
+Method Detail
+ +

+assertThat

+
+public static <T> void assertThat(T actual,
+                                  Matcher<? super T> matcher)
+
+
+
+
+
+
+ +

+assertThat

+
+public static <T> void assertThat(java.lang.String reason,
+                                  T actual,
+                                  Matcher<? super T> matcher)
+
+
+
+
+
+
+ +

+assertThat

+
+public static void assertThat(java.lang.String reason,
+                              boolean assertion)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/Matchers.html b/docs/javadoc/1.3/org/hamcrest/Matchers.html new file mode 100644 index 000000000..23072ad2d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/Matchers.html @@ -0,0 +1,3658 @@ + + + + + + +Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class Matchers

+
+java.lang.Object
+  extended by org.hamcrest.Matchers
+
+
+
+
public class Matchers
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
Matchers() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<T>
+
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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
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(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(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(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(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>
+
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(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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
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(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(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(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(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>anything() + +
+          Creates a matcher that always matches, regardless of the examined object.
+static Matcher<java.lang.Object>anything(java.lang.String description) + +
+          Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+static + + + + +
+<T> IsArray<T>
+
array(Matcher<? super T>... elementMatchers) + +
+          Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+static + + + + +
+<E> Matcher<E[]>
+
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[]>
+
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[]>
+
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[]>
+
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[]>
+
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[]>
+
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[]>
+
arrayWithSize(int size) + +
+          Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+static + + + + +
+<E> Matcher<E[]>
+
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 + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+static Matcher<java.math.BigDecimal>closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) + +
+          Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+static Matcher<java.lang.Double>closeTo(double operand, + double error) + +
+          Creates a matcher of Doubles 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>
+
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 + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
contains(E... items) + +
+          Creates a matcher for Iterables 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>>
+
contains(java.util.List<Matcher<? super E>> itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
contains(Matcher<? super E>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
contains(Matcher<? super E> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
containsInAnyOrder(Matcher<? super E> itemMatcher) + +
+          Deprecated. use contains(Matcher itemMatcher) instead
+static + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
containsInAnyOrder(Matcher<? super T>... itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
containsInAnyOrder(T... items) + +
+          Creates an order agnostic matcher for Iterables 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 Matcher<java.lang.String>containsString(java.lang.String substring) + +
+          Creates a matcher that matches if the examined String contains the specified + String anywhere.
+static + + + + +
+<T> Matcher<T>
+
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>
+
either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
empty() + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<E[]>
+
emptyArray() + +
+          Creates a matcher for arrays that matches when the length of the array + is zero.
+static + + + + +
+<E> Matcher<java.util.Collection<E>>
+
emptyCollectionOf(java.lang.Class<E> type) + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
emptyIterable() + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
emptyIterableOf(java.lang.Class<E> type) + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+static Matcher<java.lang.String>endsWith(java.lang.String suffix) + +
+          Creates a matcher that matches if the examined String ends with the specified + String.
+static + + + + +
+<T> Matcher<T>
+
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 Matcher<java.lang.String>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>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.util.EventObject>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>eventFrom(java.lang.Object source) + +
+          Creates a matcher of EventObject that matches any EventObject + announced by source.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
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>
+
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 + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
hasEntry(K key, + V value) + +
+          Creates a matcher for Maps 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>>
+
hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps 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<java.lang.Iterable<? super T>>
+
hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
hasItem(T item) + +
+          Creates a matcher for Iterables 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<T[]>
+
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[]>
+
hasItemInArray(T element) + +
+          A shortcut to the frequently used hasItemInArray(equalTo(x)).
+static + + + + +
+<T> Matcher<java.lang.Iterable<T>>
+
hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
hasItems(T... items) + +
+          Creates a matcher for Iterables 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 + + + + +
+<K> Matcher<java.util.Map<? extends K,?>>
+
hasKey(K key) + +
+          Creates a matcher for Maps 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,?>>
+
hasKey(Matcher<? super K> keyMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
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>
+
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 + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
hasSize(int size) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
hasSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
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(java.lang.String expectedToString) + +
+          Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
hasValue(Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
hasValue(V value) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) + +
+          Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) + +
+          Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+static + + + + +
+<T> Matcher<T>
+
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(java.lang.Class<T> type) + +
+          Deprecated. use isA(Class type) instead.
+static + + + + +
+<T> Matcher<T>
+
is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
is(T value) + +
+          A shortcut to the frequently used is(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
isA(java.lang.Class<T> type) + +
+          A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+static Matcher<java.lang.String>isEmptyOrNullString() + +
+          Creates a matcher of String that matches when the examined string is null, or + has zero length.
+static Matcher<java.lang.String>isEmptyString() + +
+          Creates a matcher of String that matches when the examined string has zero length.
+static + + + + +
+<T> Matcher<T>
+
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(T[] param1) + +
+           
+static + + + + +
+<T> Matcher<T>
+
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>>
+
iterableWithSize(int size) + +
+          Creates a matcher for Iterables 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>>
+
iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
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>
+
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.
+static + + + + +
+<T> Matcher<T>
+
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>
+
not(T value) + +
+          A shortcut to the frequently used not(equalTo(x)).
+static Matcher<java.lang.Object>notNullValue() + +
+          A shortcut to the frequently used not(nullValue()).
+static + + + + +
+<T> Matcher<T>
+
notNullValue(java.lang.Class<T> type) + +
+          A shortcut to the frequently used not(nullValue(X.class)).
+static Matcher<java.lang.Object>nullValue() + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
nullValue(java.lang.Class<T> type) + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
sameInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<T>
+
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.
+static Matcher<java.lang.String>startsWith(java.lang.String prefix) + +
+          Creates a matcher that matches if the examined String starts with the specified + String.
+static Matcher<java.lang.String>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.
+static + + + + +
+<T> Matcher<T>
+
theInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<java.lang.Class<?>>
+
typeCompatibleWith(java.lang.Class<T> baseType) + +
+          Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Matchers

+
+public Matchers()
+
+
+ + + + + + + + +
+Method Detail
+ +

+allOf

+
+public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T> first,
+                                   Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<T> first,
+                                 Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+both

+
+public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when both of the specified matchers match the examined object. +

+ For example: +

assertThat("fab", both(containsString("a")).and(containsString("b")))
+

+

+
+
+
+
+ +

+either

+
+public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when either of the specified matchers match the examined object. +

+ For example: +

assertThat("fan", either(containsString("a")).and(containsString("b")))
+

+

+
+
+
+
+ +

+describedAs

+
+public static <T> Matcher<T> describedAs(java.lang.String description,
+                                         Matcher<T> matcher,
+                                         java.lang.Object... values)
+
+
Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. +

+ For example: +

describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
+

+

+
Parameters:
description - the new description for the wrapped matcher
matcher - the matcher to wrap
values - optional values to insert into the tokenised description
+
+
+
+ +

+everyItem

+
+public static <U> Matcher<java.lang.Iterable<U>> everyItem(Matcher<U> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +

+ For example: +

assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to every item provided by the examined Iterable
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(T value)
+
+
A shortcut to the frequently used is(equalTo(x)). +

+ For example: +

assertThat(cheese, is(smelly))
+ instead of: +
assertThat(cheese, is(equalTo(smelly)))
+

+

+
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(Matcher<T> matcher)
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +

+ For example: +

assertThat(cheese, is(equalTo(smelly)))
+ instead of: +
assertThat(cheese, equalTo(smelly))
+

+

+
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(java.lang.Class<T> type)
+
+
Deprecated. use isA(Class type) instead. +

+

A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, is(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+
+ +

+isA

+
+public static <T> Matcher<T> isA(java.lang.Class<T> type)
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, isA(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything()
+
+
Creates a matcher that always matches, regardless of the examined object. +

+

+
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything(java.lang.String description)
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +

+

+
Parameters:
description - a meaningful String used when describing itself
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
+

+

+
Parameters:
item - the item to compare against the items provided by the examined Iterable
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
+

+

+
Parameters:
items - the items to compare against the items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
+

+

+
Parameters:
itemMatchers - the matchers to apply to items provided by the examined Iterable
+
+
+
+ +

+equalTo

+
+public static <T> Matcher<T> 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. + +

If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

+ +

The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

+

+ For example: +

+ assertThat("foo", equalTo("foo"));
+ assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
+ 
+

+

+
+
+
+
+ +

+any

+
+public static <T> Matcher<T> 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. + +

The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

+

+ For example: +

assertThat(new Canoe(), instanceOf(Canoe.class));
+

+

+
+
+
+
+ +

+instanceOf

+
+public static <T> Matcher<T> 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. + +

The created matcher assumes no relationship between specified type and the examined object.

+

+ For example: +

assertThat(new Canoe(), instanceOf(Paddlable.class));
+

+

+
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(Matcher<T> matcher)
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +

+ For example: +

assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
matcher - the matcher whose sense should be inverted
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(T value)
+
+
A shortcut to the frequently used not(equalTo(x)). +

+ For example: +

assertThat(cheese, is(not(smelly)))
+ instead of: +
assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
value - the value that any examined object should not equal
+
+
+
+ +

+nullValue

+
+public static Matcher<java.lang.Object> nullValue()
+
+
Creates a matcher that matches if examined object is null. +

+ For example: +

assertThat(cheese, is(nullValue())
+

+

+
+
+
+
+ +

+nullValue

+
+public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
+
+
Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. +

+ For example: +

assertThat(cheese, is(nullValue(Cheese.class))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+
+ +

+notNullValue

+
+public static Matcher<java.lang.Object> notNullValue()
+
+
A shortcut to the frequently used not(nullValue()). +

+ For example: +

assertThat(cheese, is(notNullValue()))
+ instead of: +
assertThat(cheese, is(not(nullValue())))
+

+

+
+
+
+
+ +

+notNullValue

+
+public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
+
+
A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. +

+ For example: +

assertThat(cheese, is(notNullValue(X.class)))
+ instead of: +
assertThat(cheese, is(not(nullValue(X.class))))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+
+ +

+sameInstance

+
+public static <T> Matcher<T> sameInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+
+ +

+theInstance

+
+public static <T> Matcher<T> theInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+
+ +

+containsString

+
+public static Matcher<java.lang.String> containsString(java.lang.String substring)
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere. +

+ For example: +

assertThat("myStringOfNote", containsString("ring"))
+

+

+
Parameters:
substring - the substring that the returned matcher will expect to find within any examined string
+
+
+
+ +

+startsWith

+
+public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
+
+
Creates a matcher that matches if the examined String starts with the specified + String. +

+ For example: +

assertThat("myStringOfNote", startsWith("my"))
+

+

+
Parameters:
prefix - the substring that the returned matcher will expect at the start of any examined string
+
+
+
+ +

+endsWith

+
+public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
+
+
Creates a matcher that matches if the examined String ends with the specified + String. +

+ For example: +

assertThat("myStringOfNote", endsWith("Note"))
+

+

+
Parameters:
suffix - the substring that the returned matcher will expect at the end of any examined string
+
+
+
+ +

+array

+
+public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. +

+ For example: +

assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
+

+

+
Parameters:
elementMatchers - the matchers that the elements of examined arrays should satisfy
+
+
+
+ +

+hasItemInArray

+
+public static <T> Matcher<T[]> hasItemInArray(T element)
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)). +

+ For example: +

assertThat(hasItemInArray(x))
+ instead of: +
assertThat(hasItemInArray(equalTo(x)))
+

+

+
Parameters:
element - the element that should be present in examined arrays
+
+
+
+ +

+hasItemInArray

+
+public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. +

+ For example: +

assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
+

+

+
Parameters:
elementMatcher - the matcher to apply to elements in examined arrays
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, + the examined array must be of the same length as the number of specified items. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
+

+

+
Parameters:
items - the items that must equal the items within an examined array
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
+

+

+
Parameters:
itemMatchers - the matchers that must be satisfied by the items in the examined array
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

+ N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
+

+

+
Parameters:
items - the items that must equal the entries of an examined array, in any order
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

+ N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

+ N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
+
+
+
+ +

+arrayWithSize

+
+public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the length of an examined array
+
+
+
+ +

+arrayWithSize

+
+public static <E> Matcher<E[]> arrayWithSize(int size)
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
+

+

+
Parameters:
size - the length that an examined array must have for a positive match
+
+
+
+ +

+emptyArray

+
+public static <E> Matcher<E[]> emptyArray()
+
+
Creates a matcher for arrays that matches when the length of the array + is zero. +

+ For example: +

assertThat(new String[0], emptyArray())
+

+

+
+
+
+
+ +

+hasSize

+
+public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the size of an examined Collection
+
+
+
+ +

+hasSize

+
+public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasSize(2))
+

+

+
Parameters:
size - the expected size of an examined Collection
+
+
+
+ +

+empty

+
+public static <E> Matcher<java.util.Collection<? extends E>> empty()
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +

+ For example: +

assertThat(new ArrayList<String>(), is(empty()))
+

+

+
+
+
+
+ +

+emptyCollectionOf

+
+public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> type)
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
+

+

+
Parameters:
type - the type of the collection's content
+
+
+
+ +

+emptyIterable

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
+
+
Creates a matcher for Iterables matching examined iterables that yield no items. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyIterable()))
+

+

+
+
+
+
+ +

+emptyIterableOf

+
+public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> type)
+
+
Creates a matcher for Iterables matching examined iterables that yield no items. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
+

+

+
Parameters:
type - the type of the iterable's content
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
+

+

+
Parameters:
itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
+
+
Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
+

+

+
Parameters:
items - the items that must equal the items provided by an examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. +

+ For example: +

assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
+

+

+
Parameters:
itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
+
+
Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
+
+
Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

+ N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
+

+

+
Parameters:
items - the items that must equal the items provided by an examined Iterable in any order
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
+
+
Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

+ N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
+
+
Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

+ N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
+
+
+
+ +

+containsInAnyOrder

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> containsInAnyOrder(Matcher<? super E> itemMatcher)
+
+
Deprecated. use contains(Matcher itemMatcher) instead +

+

Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. +

+ For example: +

assertThat(Arrays.asList("foo"), containsInAnyOrder(equalTo("foo")))
+

+

+
Parameters:
itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
+
+
+
+ +

+iterableWithSize

+
+public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
+
+
+
+ +

+iterableWithSize

+
+public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
+

+

+
Parameters:
size - the number of items that should be yielded by an examined Iterable
+
+
+
+ +

+hasEntry

+
+public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
+                                                                             V value)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. +

+ For example: +

assertThat(myMap, hasEntry("bar", "foo"))
+

+

+
Parameters:
key - the key that, in combination with the value, must be describe at least one entry
value - the value that, in combination with the key, must be describe at least one entry
+
+
+
+ +

+hasEntry

+
+public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
+                                                                             Matcher<? super V> valueMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. +

+ For example: +

assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
+
+
+
+ +

+hasKey

+
+public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. +

+ For example: +

assertThat(myMap, hasKey(equalTo("bar")))
+

+

+
Parameters:
keyMatcher - the matcher that must be satisfied by at least one key
+
+
+
+ +

+hasKey

+
+public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. +

+ For example: +

assertThat(myMap, hasKey("bar"))
+

+

+
Parameters:
key - the key that satisfying maps must contain
+
+
+
+ +

+hasValue

+
+public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. +

+ For example: +

assertThat(myMap, hasValue("foo"))
+

+

+
Parameters:
value - the value that satisfying maps must contain
+
+
+
+ +

+hasValue

+
+public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. +

+ For example: +

assertThat(myMap, hasValue(equalTo("foo")))
+

+

+
Parameters:
valueMatcher - the matcher that must be satisfied by at least one value
+
+
+
+ +

+isIn

+
+public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
+
+
Creates a matcher that matches when the examined object is found within the + specified collection. +

+ For example: +

assertThat("foo", isIn(Arrays.asList("bar", "foo")))
+

+

+
Parameters:
collection - the collection in which matching items must be found
+
+
+
+ +

+isIn

+
+public static <T> Matcher<T> isIn(T[] param1)
+
+
+
+
+
+
+ +

+isOneOf

+
+public static <T> Matcher<T> isOneOf(T... elements)
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements. +

+ For example: +

assertThat("foo", isIn("bar", "foo"))
+

+

+
Parameters:
elements - the elements amongst which matching items will be found
+
+
+
+ +

+closeTo

+
+public static Matcher<java.lang.Double> closeTo(double operand,
+                                                double error)
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. +

+ For example: +

assertThat(1.03, is(closeTo(1.0, 0.03)))
+

+

+
Parameters:
operand - the expected value of matching doubles
error - the delta (+/-) within which matches will be allowed
+
+
+
+ +

+closeTo

+
+public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
+                                                    java.math.BigDecimal error)
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. +

+ For example: +

assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
+

+

+
Parameters:
operand - the expected value of matching BigDecimals
error - the delta (+/-) within which matches will be allowed
+
+
+
+ +

+comparesEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, comparesEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return zero
+
+
+
+ +

+greaterThan

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(2, greaterThan(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
+
+
+
+ +

+greaterThanOrEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, greaterThanOrEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
+
+
+
+ +

+lessThan

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, lessThan(2))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
+
+
+
+ +

+lessThanOrEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, lessThanOrEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
+
+
+
+ +

+equalToIgnoringCase

+
+public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. +

+ For example: +

assertThat("Foo", equalToIgnoringCase("FOO"))
+

+

+
Parameters:
expectedString - the expected value of matched strings
+
+
+
+ +

+equalToIgnoringWhiteSpace

+
+public static Matcher<java.lang.String> 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. To be + exact, the following whitespace rules are applied: +
    +
  • all leading and trailing whitespace of both the expectedString and the examined string are ignored
  • +
  • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
  • +
+

+ For example: +

assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
+

+

+
Parameters:
expectedString - the expected value of matched strings
+
+
+
+ +

+isEmptyString

+
+public static Matcher<java.lang.String> isEmptyString()
+
+
Creates a matcher of String that matches when the examined string has zero length. +

+ For example: +

assertThat("", isEmptyString())
+

+

+
+
+
+
+ +

+isEmptyOrNullString

+
+public static Matcher<java.lang.String> isEmptyOrNullString()
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length. +

+ For example: +

assertThat(((String)null), isEmptyString())
+

+

+
+
+
+
+ +

+stringContainsInOrder

+
+public static Matcher<java.lang.String> 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. +

+ For example: +

assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
+

+

+
Parameters:
substrings - the substrings that must be contained within matching strings
+
+
+
+ +

+hasToString

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(true, hasToString(equalTo("TRUE")))
+

+

+
Parameters:
toStringMatcher - the matcher used to verify the toString result
+
+
+
+ +

+hasToString

+
+public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. +

+ For example: +

assertThat(true, hasToString("TRUE"))
+

+

+
Parameters:
expectedToString - the expected toString result
+
+
+
+ +

+typeCompatibleWith

+
+public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. +

+ For example: +

assertThat(Integer.class, typeCompatibleWith(Number.class))
+

+

+
Parameters:
baseType - the base class to examine classes against
+
+
+
+ +

+eventFrom

+
+public static Matcher<java.util.EventObject> 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. +

+ For example: +
assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
+

+

+
Parameters:
eventClass - the class of the event to match on
source - the source of the event
+
+
+
+ +

+eventFrom

+
+public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source. +

+ For example: +
assertThat(myEvent, is(eventFrom(myBean)))
+

+

+
Parameters:
source - the source of the event
+
+
+
+ +

+hasProperty

+
+public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. +

+ For example: +

assertThat(myBean, hasProperty("foo"))
+

+

+
Parameters:
propertyName - the name of the JavaBean property that examined beans should possess
+
+
+
+ +

+hasProperty

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(myBean, hasProperty("foo", equalTo("bar"))
+

+

+
Parameters:
propertyName - the name of the JavaBean property that examined beans should possess
valueMatcher - a matcher for the value of the specified property of the examined bean
+
+
+
+ +

+samePropertyValuesAs

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(myBean, samePropertyValuesAs(myExpectedBean))
+

+

+
Parameters:
expectedBean - the bean against which examined beans are compared
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 javax.xml.namespace.NamespaceContext namespaceContext)
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
+

+

+
Parameters:
xPath - the target xpath
namespaceContext - the namespace for matching nodes
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese"))
+

+

+
Parameters:
xPath - the target xpath
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 javax.xml.namespace.NamespaceContext namespaceContext,
+                                                 Matcher<java.lang.String> valueMatcher)
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
+

+

+
Parameters:
xPath - the target xpath
namespaceContext - the namespace for matching nodes
valueMatcher - matcher for the value at the specified xpath
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 Matcher<java.lang.String> valueMatcher)
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
+

+

+
Parameters:
xPath - the target xpath
valueMatcher - matcher for the value at the specified xpath
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/SelfDescribing.html b/docs/javadoc/1.3/org/hamcrest/SelfDescribing.html new file mode 100644 index 000000000..2f8e59099 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/SelfDescribing.html @@ -0,0 +1,220 @@ + + + + + + +SelfDescribing (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Interface SelfDescribing

+
+
All Known Subinterfaces:
Matcher<T>
+
+
+
All Known Implementing Classes:
AllOf, AnyOf, BaseMatcher, BigDecimalCloseTo, CombinableMatcher, CustomMatcher, CustomTypeSafeMatcher, DescribedAs, DiagnosingMatcher, Every, FeatureMatcher, HasProperty, HasPropertyWithValue, HasToString, HasXPath, Is, IsAnything, IsArray, IsArrayContaining, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsArrayWithSize, IsCloseTo, IsCollectionContaining, IsCollectionWithSize, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEmptyString, IsEqual, IsEqualIgnoringCase, IsEqualIgnoringWhiteSpace, IsEventFrom, IsIn, IsInstanceOf, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, IsIterableWithSize, IsMapContaining, IsNot, IsNull, IsSame, OrderingComparison, SamePropertyValuesAs, SamePropertyValuesAs.PropertyMatcher, SelfDescribingValue, StringContains, StringContainsInOrder, StringEndsWith, StringStartsWith, SubstringMatcher, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
+
public interface SelfDescribing
+ + +

+The ability of an object to describe itself. +

+ +

+


+ +

+ + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+  +

+ + + + + + + + +
+Method Detail
+ +

+describeTo

+
+void describeTo(Description description)
+
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/StringDescription.html b/docs/javadoc/1.3/org/hamcrest/StringDescription.html new file mode 100644 index 000000000..ce87692d7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/StringDescription.html @@ -0,0 +1,420 @@ + + + + + + +StringDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class StringDescription

+
+java.lang.Object
+  extended by org.hamcrest.BaseDescription
+      extended by org.hamcrest.StringDescription
+
+
+
All Implemented Interfaces:
Description
+
+
+
+
public class StringDescription
extends BaseDescription
+ + +

+A Description that is stored as a string. +

+ +

+


+ +

+ + + + + + + +
+Nested Class Summary
+ + + + + + + +
Nested classes/interfaces inherited from interface org.hamcrest.Description
Description.NullDescription
+  + + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from interface org.hamcrest.Description
NONE
+  + + + + + + + + + + + + + +
+Constructor Summary
StringDescription() + +
+           
StringDescription(java.lang.Appendable out) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  voidappend(char c) + +
+          Append the char c to the description.
+protected  voidappend(java.lang.String str) + +
+          Append the String str to the description.
+static java.lang.StringasString(SelfDescribing selfDescribing) + +
+          Alias for toString(SelfDescribing).
+ java.lang.StringtoString() + +
+          Returns the description as a string.
+static java.lang.StringtoString(SelfDescribing selfDescribing) + +
+          Return the description of a SelfDescribing object as a String.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseDescription
appendDescriptionOf, appendList, appendText, appendValue, appendValueList, appendValueList
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+StringDescription

+
+public StringDescription()
+
+
+
+ +

+StringDescription

+
+public StringDescription(java.lang.Appendable out)
+
+
+ + + + + + + + +
+Method Detail
+ +

+toString

+
+public static java.lang.String toString(SelfDescribing selfDescribing)
+
+
Return the description of a SelfDescribing object as a String. +

+

+
Parameters:
selfDescribing - The object to be described. +
Returns:
The description of the object.
+
+
+
+ +

+asString

+
+public static java.lang.String asString(SelfDescribing selfDescribing)
+
+
Alias for toString(SelfDescribing). +

+

+
+
+
+
+ +

+append

+
+protected void append(java.lang.String str)
+
+
Description copied from class: BaseDescription
+
Append the String str to the description. + The default implementation passes every character to BaseDescription.append(char). + Override in subclasses to provide an efficient implementation. +

+

+
Overrides:
append in class BaseDescription
+
+
+
+
+
+
+ +

+append

+
+protected void append(char c)
+
+
Description copied from class: BaseDescription
+
Append the char c to the description. +

+

+
Specified by:
append in class BaseDescription
+
+
+
+
+
+
+ +

+toString

+
+public java.lang.String toString()
+
+
Returns the description as a string. +

+

+
Overrides:
toString in class java.lang.Object
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/TypeSafeDiagnosingMatcher.html b/docs/javadoc/1.3/org/hamcrest/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..7c0e9e8eb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,402 @@ + + + + + + +TypeSafeDiagnosingMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class TypeSafeDiagnosingMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+
+
+
Type Parameters:
T -
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
CombinableMatcher, Every, FeatureMatcher, HasPropertyWithValue, HasXPath, IsCollectionContaining, IsEventFrom, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, SamePropertyValuesAs
+
+
+
+
public abstract class TypeSafeDiagnosingMatcher<T>
extends BaseMatcher<T>
+ + +

+Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected. + This implements the null check, checks the type and then casts. + To use, implement

matchesSafely()
. +

+ +

+

+
Author:
+
Neil Dunn, Nat Pryce, Steve Freeman
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + +
+Constructor Summary
+protected TypeSafeDiagnosingMatcher() + +
+          The default constructor for simple sub types
+protected TypeSafeDiagnosingMatcher(java.lang.Class<?> expectedType) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+          Generate a description of why the matcher has not accepted the item.
+ booleanmatches(java.lang.Object item) + +
+          Evaluates the matcher for argument item.
+protected abstract  booleanmatchesSafely(T item, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+ + + + + + + +
Methods inherited from interface org.hamcrest.SelfDescribing
describeTo
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+TypeSafeDiagnosingMatcher

+
+protected TypeSafeDiagnosingMatcher(java.lang.Class<?> expectedType)
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +

+

+
Parameters:
expectedType - The expectedType of the actual value.
+
+
+ +

+TypeSafeDiagnosingMatcher

+
+protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder)
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +

+

+
Parameters:
typeFinder - A type finder to extract the type
+
+
+ +

+TypeSafeDiagnosingMatcher

+
+protected TypeSafeDiagnosingMatcher()
+
+
The default constructor for simple sub types +

+

+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected abstract boolean matchesSafely(T item,
+                                         Description mismatchDescription)
+
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
+
+
+
+ +

+matches

+
+public final boolean matches(java.lang.Object item)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
item - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeMismatch

+
+public final void describeMismatch(java.lang.Object item,
+                                   Description mismatchDescription)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
Overrides:
describeMismatch in class BaseMatcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
mismatchDescription - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/TypeSafeMatcher.html b/docs/javadoc/1.3/org/hamcrest/TypeSafeMatcher.html new file mode 100644 index 000000000..424994ffb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/TypeSafeMatcher.html @@ -0,0 +1,416 @@ + + + + + + +TypeSafeMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest +
+Class TypeSafeMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
BigDecimalCloseTo, CustomTypeSafeMatcher, HasProperty, IsArray, IsArrayContaining, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsCloseTo, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEqualIgnoringCase, IsEqualIgnoringWhiteSpace, IsMapContaining, OrderingComparison, StringContainsInOrder, SubstringMatcher
+
+
+
+
public abstract class TypeSafeMatcher<T>
extends BaseMatcher<T>
+ + +

+Convenient base class for Matchers that require a non-null value of a specific type. + This simply implements the null check, checks the type and then casts. +

+ +

+

+
Author:
+
Joe Walnes, Steve Freeman, Nat Pryce
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + +
+Constructor Summary
+protected TypeSafeMatcher() + +
+          The default constructor for simple sub types
+protected TypeSafeMatcher(java.lang.Class<?> expectedType) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatch(java.lang.Object item, + Description description) + +
+          Generate a description of why the matcher has not accepted the item.
+protected  voiddescribeMismatchSafely(T item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ booleanmatches(java.lang.Object item) + +
+          Methods made final to prevent accidental override.
+protected abstract  booleanmatchesSafely(T item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+ + + + + + + +
Methods inherited from interface org.hamcrest.SelfDescribing
describeTo
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+TypeSafeMatcher

+
+protected TypeSafeMatcher()
+
+
The default constructor for simple sub types +

+

+
+ +

+TypeSafeMatcher

+
+protected TypeSafeMatcher(java.lang.Class<?> expectedType)
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +

+

+
Parameters:
expectedType - The expectedType of the actual value.
+
+
+ +

+TypeSafeMatcher

+
+protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder)
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type. +

+

+
Parameters:
typeFinder - A type finder to extract the type
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected abstract boolean matchesSafely(T item)
+
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
+
+
+
+ +

+describeMismatchSafely

+
+protected void describeMismatchSafely(T item,
+                                      Description mismatchDescription)
+
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
+
+
+
+ +

+matches

+
+public final boolean matches(java.lang.Object item)
+
+
Methods made final to prevent accidental override. + If you need to override this, there's no point on extending TypeSafeMatcher. + Instead, extend the BaseMatcher. +

+

+
Parameters:
item - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeMismatch

+
+public final void describeMismatch(java.lang.Object item,
+                                   Description description)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
Overrides:
describeMismatch in class BaseMatcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/HasProperty.html b/docs/javadoc/1.3/org/hamcrest/beans/HasProperty.html new file mode 100644 index 000000000..78503763a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/HasProperty.html @@ -0,0 +1,377 @@ + + + + + + +HasProperty (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.beans +
+Class HasProperty<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T>
+          extended by org.hamcrest.beans.HasProperty<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class HasProperty<T>
extends TypeSafeMatcher<T>
+ + +

+A Matcher that checks that an object has a JavaBean property + with the specified name. If an error occurs during introspection + of the object then this is treated as a mismatch. +

+ +

+

+
Author:
+
Iain McGinniss, Nat Pryce, Steve Freeman
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
HasProperty(java.lang.String propertyName) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(T item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
hasProperty(java.lang.String propertyName) + +
+          Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+ booleanmatchesSafely(T obj) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+HasProperty

+
+public HasProperty(java.lang.String propertyName)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T obj)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<T>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(T item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasProperty

+
+public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. +

+ For example: +

assertThat(myBean, hasProperty("foo"))
+

+

+
Parameters:
propertyName - the name of the JavaBean property that examined beans should possess
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/HasPropertyWithValue.html b/docs/javadoc/1.3/org/hamcrest/beans/HasPropertyWithValue.html new file mode 100644 index 000000000..d98948cfb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/HasPropertyWithValue.html @@ -0,0 +1,397 @@ + + + + + + +HasPropertyWithValue (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.beans +
+Class HasPropertyWithValue<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.beans.HasPropertyWithValue<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class HasPropertyWithValue<T>
extends TypeSafeDiagnosingMatcher<T>
+ + +

+Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher. This is useful for when objects + are created within code under test and passed to a mock object, and you wish + to assert that the created object has certain properties. +

+

Example Usage

+ Consider the situation where we have a class representing a person, which + follows the basic JavaBean convention of having get() and possibly set() + methods for it's properties: +
+ public class Person {
+   private String name;
+   public Person(String person) {
+     this.person = person;
+   }
+   public String getName() {
+     return name;
+   }
+ }
+ + And that these person objects are generated within a piece of code under test + (a class named PersonGenerator). This object is sent to one of our mock objects + which overrides the PersonGenerationListener interface: +
+ public interface PersonGenerationListener {
+   public void personGenerated(Person person);
+ }
+ + In order to check that the code under test generates a person with name + "Iain" we would do the following: +
+ Mock personGenListenerMock = mock(PersonGenerationListener.class);
+ personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
+ PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy();
+ + If an exception is thrown by the getter method for a property, the property + does not exist, is not readable, or a reflection related exception is thrown + when trying to invoke it then this is treated as an evaluation failure and + the matches method will return false. +

+ This matcher class will also work with JavaBean objects that have explicit + bean descriptions via an associated BeanInfo description class. See the + JavaBeans specification for more information: +

+ http://java.sun.com/products/javabeans/docs/index.html +

+ +

+

+
Author:
+
Iain McGinniss, Nat Pryce, Steve Freeman
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
HasPropertyWithValue(java.lang.String propertyName, + Matcher<?> valueMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
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.
+ booleanmatchesSafely(T bean, + Description mismatch) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+HasPropertyWithValue

+
+public HasPropertyWithValue(java.lang.String propertyName,
+                            Matcher<?> valueMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T bean,
+                             Description mismatch)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasProperty

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(myBean, hasProperty("foo", equalTo("bar"))
+

+

+
Parameters:
propertyName - the name of the JavaBean property that examined beans should possess
valueMatcher - a matcher for the value of the specified property of the examined bean
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/PropertyUtil.html b/docs/javadoc/1.3/org/hamcrest/beans/PropertyUtil.html new file mode 100644 index 000000000..f59fba1c0 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/PropertyUtil.html @@ -0,0 +1,338 @@ + + + + + + +PropertyUtil (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.beans +
+Class PropertyUtil

+
+java.lang.Object
+  extended by org.hamcrest.beans.PropertyUtil
+
+
+
+
public class PropertyUtil
extends java.lang.Object
+ + +

+Utility class for accessing properties on JavaBean objects. +

+ See http://java.sun.com/products/javabeans/docs/index.html for + more information on JavaBeans. +

+ +

+

+
Since:
+
1.1.0
+
Author:
+
Iain McGinniss, Steve Freeman
+
+
+ +

+ + + + + + + + + + + +
+Field Summary
+static java.lang.Object[]NO_ARGUMENTS + +
+           
+  + + + + + + + + + + +
+Constructor Summary
PropertyUtil() + +
+           
+  + + + + + + + + + + + + + + + +
+Method Summary
+static java.beans.PropertyDescriptorgetPropertyDescriptor(java.lang.String propertyName, + java.lang.Object fromObj) + +
+          Returns the description of the property with the provided + name on the provided object's interface.
+static java.beans.PropertyDescriptor[]propertyDescriptorsFor(java.lang.Object fromObj, + java.lang.Class<java.lang.Object> stopClass) + +
+          Returns all the property descriptors for the class associated with the given object
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+NO_ARGUMENTS

+
+public static final java.lang.Object[] NO_ARGUMENTS
+
+
+
+
+ + + + + + + + +
+Constructor Detail
+ +

+PropertyUtil

+
+public PropertyUtil()
+
+
+ + + + + + + + +
+Method Detail
+ +

+getPropertyDescriptor

+
+public static java.beans.PropertyDescriptor getPropertyDescriptor(java.lang.String propertyName,
+                                                                  java.lang.Object fromObj)
+                                                           throws java.lang.IllegalArgumentException
+
+
Returns the description of the property with the provided + name on the provided object's interface. +

+

+ +
Returns:
the descriptor of the property, or null if the property does not exist. +
Throws: +
java.lang.IllegalArgumentException - if there's a introspection failure
+
+
+
+ +

+propertyDescriptorsFor

+
+public static java.beans.PropertyDescriptor[] propertyDescriptorsFor(java.lang.Object fromObj,
+                                                                     java.lang.Class<java.lang.Object> stopClass)
+                                                              throws java.lang.IllegalArgumentException
+
+
Returns all the property descriptors for the class associated with the given object +

+

+
Parameters:
fromObj - Use the class of this object
stopClass - Don't include any properties from this ancestor class upwards. +
Returns:
Property descriptors +
Throws: +
java.lang.IllegalArgumentException - if there's a introspection failure
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html b/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html new file mode 100644 index 000000000..231633961 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html @@ -0,0 +1,309 @@ + + + + + + +SamePropertyValuesAs.PropertyMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.beans +
+Class SamePropertyValuesAs.PropertyMatcher

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.DiagnosingMatcher<java.lang.Object>
+          extended by org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Object>, SelfDescribing
+
+
+
Enclosing class:
SamePropertyValuesAs<T>
+
+
+
+
public static class SamePropertyValuesAs.PropertyMatcher
extends DiagnosingMatcher<java.lang.Object>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
SamePropertyValuesAs.PropertyMatcher(java.beans.PropertyDescriptor descriptor, + java.lang.Object expectedObject) + +
+           
+  + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object actual, + Description mismatch) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.DiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+SamePropertyValuesAs.PropertyMatcher

+
+public SamePropertyValuesAs.PropertyMatcher(java.beans.PropertyDescriptor descriptor,
+                                            java.lang.Object expectedObject)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object actual,
+                       Description mismatch)
+
+
+
Specified by:
matches in class DiagnosingMatcher<java.lang.Object>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.html b/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.html new file mode 100644 index 000000000..616aa082a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/SamePropertyValuesAs.html @@ -0,0 +1,360 @@ + + + + + + +SamePropertyValuesAs (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.beans +
+Class SamePropertyValuesAs<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.beans.SamePropertyValuesAs<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class SamePropertyValuesAs<T>
extends TypeSafeDiagnosingMatcher<T>
+ + +

+


+ +

+ + + + + + + + + + + +
+Nested Class Summary
+static classSamePropertyValuesAs.PropertyMatcher + +
+           
+  + + + + + + + + + + +
+Constructor Summary
SamePropertyValuesAs(T expectedBean) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(T bean, + Description mismatch) + +
+          Subclasses should implement this.
+static + + + + +
+<T> Matcher<T>
+
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.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+SamePropertyValuesAs

+
+public SamePropertyValuesAs(T expectedBean)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T bean,
+                             Description mismatch)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+samePropertyValuesAs

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(myBean, samePropertyValuesAs(myExpectedBean))
+

+

+
Parameters:
expectedBean - the bean against which examined beans are compared
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasProperty.html b/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasProperty.html new file mode 100644 index 000000000..0af2be894 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasProperty.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.beans.HasProperty (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.beans.HasProperty

+
+No usage of org.hamcrest.beans.HasProperty +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasPropertyWithValue.html b/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasPropertyWithValue.html new file mode 100644 index 000000000..1e7b6283e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/class-use/HasPropertyWithValue.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.beans.HasPropertyWithValue (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.beans.HasPropertyWithValue

+
+No usage of org.hamcrest.beans.HasPropertyWithValue +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/class-use/PropertyUtil.html b/docs/javadoc/1.3/org/hamcrest/beans/class-use/PropertyUtil.html new file mode 100644 index 000000000..91aa26185 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/class-use/PropertyUtil.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.beans.PropertyUtil (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.beans.PropertyUtil

+
+No usage of org.hamcrest.beans.PropertyUtil +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.PropertyMatcher.html b/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.PropertyMatcher.html new file mode 100644 index 000000000..d1dbe44fb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.PropertyMatcher.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher

+
+No usage of org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.html b/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.html new file mode 100644 index 000000000..7e7024f4a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/class-use/SamePropertyValuesAs.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.beans.SamePropertyValuesAs (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.beans.SamePropertyValuesAs

+
+No usage of org.hamcrest.beans.SamePropertyValuesAs +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/package-frame.html b/docs/javadoc/1.3/org/hamcrest/beans/package-frame.html new file mode 100644 index 000000000..46a7f3017 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/package-frame.html @@ -0,0 +1,40 @@ + + + + + + +org.hamcrest.beans (Hamcrest) + + + + + + + + + + + +org.hamcrest.beans + + + + +
+Classes  + +
+HasProperty +
+HasPropertyWithValue +
+PropertyUtil +
+SamePropertyValuesAs +
+SamePropertyValuesAs.PropertyMatcher
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/package-summary.html b/docs/javadoc/1.3/org/hamcrest/beans/package-summary.html new file mode 100644 index 000000000..acee4529a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/package-summary.html @@ -0,0 +1,190 @@ + + + + + + +org.hamcrest.beans (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.beans +

+Matchers of Java Bean properties and their values. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+Class Summary
HasProperty<T>A Matcher that checks that an object has a JavaBean property + with the specified name.
HasPropertyWithValue<T>Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
PropertyUtilUtility class for accessing properties on JavaBean objects.
SamePropertyValuesAs<T> 
SamePropertyValuesAs.PropertyMatcher 
+  + +

+

+Package org.hamcrest.beans Description +

+ +

+

Matchers of Java Bean properties and their values.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/package-tree.html b/docs/javadoc/1.3/org/hamcrest/beans/package-tree.html new file mode 100644 index 000000000..b8cc49268 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/package-tree.html @@ -0,0 +1,162 @@ + + + + + + +org.hamcrest.beans Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.beans +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/beans/package-use.html b/docs/javadoc/1.3/org/hamcrest/beans/package-use.html new file mode 100644 index 000000000..31c98554a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/beans/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.beans (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.beans

+
+No usage of org.hamcrest.beans +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/BaseDescription.html b/docs/javadoc/1.3/org/hamcrest/class-use/BaseDescription.html new file mode 100644 index 000000000..1d5ebded6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/BaseDescription.html @@ -0,0 +1,180 @@ + + + + + + +Uses of Class org.hamcrest.BaseDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.BaseDescription

+
+ + + + + + + + + +
+Packages that use BaseDescription
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
+  +

+ + + + + +
+Uses of BaseDescription in org.hamcrest
+  +

+ + + + + + + + + +
Subclasses of BaseDescription in org.hamcrest
+ classStringDescription + +
+          A Description that is stored as a string.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/BaseMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/BaseMatcher.html new file mode 100644 index 000000000..b1a92bad5 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/BaseMatcher.html @@ -0,0 +1,733 @@ + + + + + + +Uses of Class org.hamcrest.BaseMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.BaseMatcher

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use BaseMatcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest
+ classCustomMatcher<T> + +
+          Utility class for writing one off matchers.
+ classCustomTypeSafeMatcher<T> + +
+          Utility class for writing one off matchers.
+ classDiagnosingMatcher<T> + +
+          TODO(ngd): Document.
+ classFeatureMatcher<T,U> + +
+          Supporting class for matching a feature of an object.
+ classTypeSafeDiagnosingMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+ classTypeSafeMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.beans
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.beans
+ classHasProperty<T> + +
+          A Matcher that checks that an object has a JavaBean property + with the specified name.
+ classHasPropertyWithValue<T> + +
+          Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+ classSamePropertyValuesAs<T> + +
+           
+static classSamePropertyValuesAs.PropertyMatcher + +
+           
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.collection
+ classIsArray<T> + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+ classIsArrayContaining<T> + +
+          Matches if an array contains an item satisfying a nested matcher.
+ classIsArrayContainingInAnyOrder<E> + +
+           
+ classIsArrayContainingInOrder<E> + +
+           
+ classIsArrayWithSize<E> + +
+          Matches if array size satisfies a nested matcher.
+ classIsCollectionWithSize<E> + +
+          Matches if collection size satisfies a nested matcher.
+ classIsEmptyCollection<E> + +
+          Tests if collection is empty.
+ classIsEmptyIterable<E> + +
+          Tests if collection is empty.
+ classIsIn<T> + +
+           
+ classIsIterableContainingInAnyOrder<T> + +
+           
+ classIsIterableContainingInOrder<E> + +
+           
+ classIsIterableWithSize<E> + +
+           
+ classIsMapContaining<K,V> + +
+           
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.core
+ classAllOf<T> + +
+          Calculates the logical conjunction of multiple matchers.
+ classAnyOf<T> + +
+          Calculates the logical disjunction of multiple matchers.
+ classCombinableMatcher<T> + +
+           
+ classDescribedAs<T> + +
+          Provides a custom description to another matcher.
+ classEvery<T> + +
+           
+ classIs<T> + +
+          Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+ classIsAnything<T> + +
+          A matcher that always returns true.
+ classIsCollectionContaining<T> + +
+           
+ classIsEqual<T> + +
+          Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+ classIsInstanceOf + +
+          Tests whether the value is an instance of a class.
+ classIsNot<T> + +
+          Calculates the logical negation of a matcher.
+ classIsNull<T> + +
+          Is the value null?
+ classIsSame<T> + +
+          Is the value the same object as another value?
+ classStringContains + +
+          Tests if the argument is a string that contains a substring.
+ classStringEndsWith + +
+          Tests if the argument is a string that contains a substring.
+ classStringStartsWith + +
+          Tests if the argument is a string that contains a substring.
+ classSubstringMatcher + +
+           
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.number
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.number
+ classBigDecimalCloseTo + +
+           
+ classIsCloseTo + +
+          Is the value a number equal to a value within some range of + acceptable error?
+ classOrderingComparison<T extends Comparable<T>> + +
+           
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.object
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.object
+ classHasToString<T> + +
+           
+ classIsCompatibleType<T> + +
+           
+ classIsEventFrom + +
+          Tests if the value is an event announced by a specific object.
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.text
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.text
+ classIsEmptyString + +
+          Matches empty Strings (and null).
+ classIsEqualIgnoringCase + +
+          Tests if a string is equal to another string, regardless of the case.
+ classIsEqualIgnoringWhiteSpace + +
+          Tests if a string is equal to another string, ignoring any changes in whitespace.
+ classStringContainsInOrder + +
+           
+  +

+ + + + + +
+Uses of BaseMatcher in org.hamcrest.xml
+  +

+ + + + + + + + + +
Subclasses of BaseMatcher in org.hamcrest.xml
+ classHasXPath + +
+          Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Condition.Step.html b/docs/javadoc/1.3/org/hamcrest/class-use/Condition.Step.html new file mode 100644 index 000000000..ae10e7b03 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Condition.Step.html @@ -0,0 +1,202 @@ + + + + + + +Uses of Interface org.hamcrest.Condition.Step (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Interface
org.hamcrest.Condition.Step

+
+ + + + + + + + + +
+Packages that use Condition.Step
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
+  +

+ + + + + +
+Uses of Condition.Step in org.hamcrest
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest with parameters of type Condition.Step
+abstract + + + + +
+<U> Condition<U>
+
Condition.and(Condition.Step<? super T,U> mapping) + +
+           
+ + + + + +
+<U> Condition<U>
+
Condition.then(Condition.Step<? super T,U> mapping) + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Condition.html b/docs/javadoc/1.3/org/hamcrest/class-use/Condition.html new file mode 100644 index 000000000..9b35546c8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Condition.html @@ -0,0 +1,242 @@ + + + + + + +Uses of Class org.hamcrest.Condition (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.Condition

+
+ + + + + + + + + +
+Packages that use Condition
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
+  +

+ + + + + +
+Uses of Condition in org.hamcrest
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest that return Condition
+abstract + + + + +
+<U> Condition<U>
+
Condition.and(Condition.Step<? super T,U> mapping) + +
+           
+ Condition<O>Condition.Step.apply(I value, + Description mismatch) + +
+           
+static + + + + +
+<T> Condition<T>
+
Condition.matched(T theValue, + Description mismatch) + +
+           
+static + + + + +
+<T> Condition<T>
+
Condition.notMatched() + +
+           
+ + + + + +
+<U> Condition<U>
+
Condition.then(Condition.Step<? super T,U> mapping) + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/CoreMatchers.html b/docs/javadoc/1.3/org/hamcrest/class-use/CoreMatchers.html new file mode 100644 index 000000000..4c3d84f9f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/CoreMatchers.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.CoreMatchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.CoreMatchers

+
+No usage of org.hamcrest.CoreMatchers +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/CustomMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/CustomMatcher.html new file mode 100644 index 000000000..905c7cb43 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/CustomMatcher.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.CustomMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.CustomMatcher

+
+No usage of org.hamcrest.CustomMatcher +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/CustomTypeSafeMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..a854d9b50 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/CustomTypeSafeMatcher.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.CustomTypeSafeMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.CustomTypeSafeMatcher

+
+No usage of org.hamcrest.CustomTypeSafeMatcher +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Description.NullDescription.html b/docs/javadoc/1.3/org/hamcrest/class-use/Description.NullDescription.html new file mode 100644 index 000000000..b67d1debf --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Description.NullDescription.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.Description.NullDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.Description.NullDescription

+
+No usage of org.hamcrest.Description.NullDescription +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Description.html b/docs/javadoc/1.3/org/hamcrest/class-use/Description.html new file mode 100644 index 000000000..c405c28a0 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Description.html @@ -0,0 +1,1330 @@ + + + + + + +Uses of Interface org.hamcrest.Description (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Interface
org.hamcrest.Description

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use Description
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.internal  
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + +
+Uses of Description in org.hamcrest
+  +

+ + + + + + + + + + + + + + + + + +
Classes in org.hamcrest that implement Description
+ classBaseDescription + +
+          A Description that is stored as a string.
+static classDescription.NullDescription + +
+           
+ classStringDescription + +
+          A Description that is stored as a string.
+  +

+ + + + + + + + + +
Fields in org.hamcrest declared as Description
+static DescriptionDescription.NONE + +
+          A description that consumes input but does nothing.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest that return Description
+ DescriptionDescription.appendDescriptionOf(SelfDescribing value) + +
+          Appends the description of a SelfDescribing value to this description.
+ DescriptionDescription.NullDescription.appendDescriptionOf(SelfDescribing value) + +
+           
+ DescriptionBaseDescription.appendDescriptionOf(SelfDescribing value) + +
+           
+ DescriptionDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+          Appends a list of SelfDescribing objects + to the description.
+ DescriptionDescription.NullDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+           
+ DescriptionBaseDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+           
+ DescriptionDescription.appendText(java.lang.String text) + +
+          Appends some plain text to the description.
+ DescriptionDescription.NullDescription.appendText(java.lang.String text) + +
+           
+ DescriptionBaseDescription.appendText(java.lang.String text) + +
+           
+ DescriptionDescription.appendValue(java.lang.Object value) + +
+          Appends an arbitary value to the description.
+ DescriptionDescription.NullDescription.appendValue(java.lang.Object value) + +
+           
+ DescriptionBaseDescription.appendValue(java.lang.Object value) + +
+           
+ + + + + +
+<T> Description
+
Description.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+          Appends a list of values to the description.
+ + + + + +
+<T> Description
+
Description.NullDescription.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+           
+ + + + + +
+<T> Description
+
BaseDescription.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) + +
+           
+ + + + + +
+<T> Description
+
Description.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+          Appends a list of values to the description.
+ + + + + +
+<T> Description
+
Description.NullDescription.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+           
+ + + + + +
+<T> Description
+
BaseDescription.appendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest with parameters of type Description
+ Condition<O>Condition.Step.apply(I value, + Description mismatch) + +
+           
+ voidTypeSafeMatcher.describeMismatch(java.lang.Object item, + Description description) + +
+           
+ voidTypeSafeDiagnosingMatcher.describeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+           
+ voidMatcher.describeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+          Generate a description of why the matcher has not accepted the item.
+ voidDiagnosingMatcher.describeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+           
+ voidBaseMatcher.describeMismatch(java.lang.Object item, + Description description) + +
+           
+protected  voidTypeSafeMatcher.describeMismatchSafely(T item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voidSelfDescribing.describeTo(Description description) + +
+          Generates a description of the object.
+ voidFeatureMatcher.describeTo(Description description) + +
+           
+ voidCustomTypeSafeMatcher.describeTo(Description description) + +
+           
+ voidCustomMatcher.describeTo(Description description) + +
+           
+static + + + + +
+<T> Condition<T>
+
Condition.matched(T theValue, + Description mismatch) + +
+           
+protected abstract  booleanDiagnosingMatcher.matches(java.lang.Object item, + Description mismatchDescription) + +
+           
+protected abstract  booleanTypeSafeDiagnosingMatcher.matchesSafely(T item, + Description mismatchDescription) + +
+          Subclasses should implement this.
+protected  booleanFeatureMatcher.matchesSafely(T actual, + Description mismatch) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.beans
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.beans with parameters of type Description
+ voidHasProperty.describeMismatchSafely(T item, + Description mismatchDescription) + +
+           
+ voidSamePropertyValuesAs.describeTo(Description description) + +
+           
+ voidSamePropertyValuesAs.PropertyMatcher.describeTo(Description description) + +
+           
+ voidHasPropertyWithValue.describeTo(Description description) + +
+           
+ voidHasProperty.describeTo(Description description) + +
+           
+ booleanSamePropertyValuesAs.PropertyMatcher.matches(java.lang.Object actual, + Description mismatch) + +
+           
+ booleanSamePropertyValuesAs.matchesSafely(T bean, + Description mismatch) + +
+           
+ booleanHasPropertyWithValue.matchesSafely(T bean, + Description mismatch) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.collection with parameters of type Description
+ voidIsEmptyCollection.describeMismatchSafely(java.util.Collection<? extends E> item, + Description mismatchDescription) + +
+           
+ voidIsArrayContainingInOrder.describeMismatchSafely(E[] item, + Description mismatchDescription) + +
+           
+ voidIsArrayContainingInAnyOrder.describeMismatchSafely(E[] item, + Description mismatchDescription) + +
+           
+ voidIsEmptyIterable.describeMismatchSafely(java.lang.Iterable<? extends E> iter, + Description mismatchDescription) + +
+           
+ voidIsMapContaining.describeMismatchSafely(java.util.Map<? extends K,? extends V> map, + Description mismatchDescription) + +
+           
+ voidIsArrayContaining.describeMismatchSafely(T[] item, + Description mismatchDescription) + +
+           
+ voidIsArray.describeMismatchSafely(T[] actual, + Description mismatchDescription) + +
+           
+ voidIsMapContaining.describeTo(Description description) + +
+           
+ voidIsIterableContainingInOrder.describeTo(Description description) + +
+           
+ voidIsIterableContainingInAnyOrder.describeTo(Description description) + +
+           
+ voidIsIn.describeTo(Description buffer) + +
+           
+ voidIsEmptyIterable.describeTo(Description description) + +
+           
+ voidIsEmptyCollection.describeTo(Description description) + +
+           
+ voidIsArrayContainingInOrder.describeTo(Description description) + +
+           
+ voidIsArrayContainingInAnyOrder.describeTo(Description description) + +
+           
+ voidIsArrayContaining.describeTo(Description description) + +
+           
+ voidIsArray.describeTo(Description description) + +
+           
+protected  booleanIsIterableContainingInOrder.matchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) + +
+           
+protected  booleanIsIterableContainingInAnyOrder.matchesSafely(java.lang.Iterable<? extends T> items, + Description mismatchDescription) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.core with parameters of type Description
+ voidIs.describeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+           
+ voidDescribedAs.describeMismatch(java.lang.Object item, + Description description) + +
+           
+ voidSubstringMatcher.describeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+           
+ voidSubstringMatcher.describeTo(Description description) + +
+           
+ voidIsSame.describeTo(Description description) + +
+           
+ voidIsNull.describeTo(Description description) + +
+           
+ voidIsNot.describeTo(Description description) + +
+           
+ voidIsInstanceOf.describeTo(Description description) + +
+           
+ voidIsEqual.describeTo(Description description) + +
+           
+ voidIsCollectionContaining.describeTo(Description description) + +
+           
+ voidIsAnything.describeTo(Description description) + +
+           
+ voidIs.describeTo(Description description) + +
+           
+ voidEvery.describeTo(Description description) + +
+           
+ voidDescribedAs.describeTo(Description description) + +
+           
+ voidCombinableMatcher.describeTo(Description description) + +
+           
+ voidAnyOf.describeTo(Description description) + +
+           
+ voidAllOf.describeTo(Description description) + +
+           
+protected  booleanIsInstanceOf.matches(java.lang.Object item, + Description mismatch) + +
+           
+ booleanAllOf.matches(java.lang.Object o, + Description mismatch) + +
+           
+protected  booleanIsCollectionContaining.matchesSafely(java.lang.Iterable<? super T> collection, + Description mismatchDescription) + +
+           
+ booleanEvery.matchesSafely(java.lang.Iterable<T> collection, + Description mismatchDescription) + +
+           
+protected  booleanCombinableMatcher.matchesSafely(T item, + Description mismatch) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.internal
+  +

+ + + + + + + + + +
Methods in org.hamcrest.internal with parameters of type Description
+ voidSelfDescribingValue.describeTo(Description description) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.number
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.number with parameters of type Description
+ voidBigDecimalCloseTo.describeMismatchSafely(java.math.BigDecimal item, + Description mismatchDescription) + +
+           
+ voidIsCloseTo.describeMismatchSafely(java.lang.Double item, + Description mismatchDescription) + +
+           
+ voidOrderingComparison.describeMismatchSafely(T actual, + Description mismatchDescription) + +
+           
+ voidOrderingComparison.describeTo(Description description) + +
+           
+ voidIsCloseTo.describeTo(Description description) + +
+           
+ voidBigDecimalCloseTo.describeTo(Description description) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.object
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.object with parameters of type Description
+ voidIsCompatibleType.describeMismatchSafely(java.lang.Class<?> cls, + Description mismatchDescription) + +
+           
+ voidIsEventFrom.describeTo(Description description) + +
+           
+ voidIsCompatibleType.describeTo(Description description) + +
+           
+ booleanIsEventFrom.matchesSafely(java.util.EventObject item, + Description mismatchDescription) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.text
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.text with parameters of type Description
+ voidStringContainsInOrder.describeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+           
+ voidIsEqualIgnoringWhiteSpace.describeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+           
+ voidIsEqualIgnoringCase.describeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+           
+ voidStringContainsInOrder.describeTo(Description description) + +
+           
+ voidIsEqualIgnoringWhiteSpace.describeTo(Description description) + +
+           
+ voidIsEqualIgnoringCase.describeTo(Description description) + +
+           
+ voidIsEmptyString.describeTo(Description description) + +
+           
+  +

+ + + + + +
+Uses of Description in org.hamcrest.xml
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest.xml with parameters of type Description
+ voidHasXPath.describeTo(Description description) + +
+           
+ booleanHasXPath.matchesSafely(org.w3c.dom.Node item, + Description mismatch) + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/DiagnosingMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/DiagnosingMatcher.html new file mode 100644 index 000000000..d14aa9d5a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/DiagnosingMatcher.html @@ -0,0 +1,217 @@ + + + + + + +Uses of Class org.hamcrest.DiagnosingMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.DiagnosingMatcher

+
+ + + + + + + + + + + + + +
+Packages that use DiagnosingMatcher
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of DiagnosingMatcher in org.hamcrest.beans
+  +

+ + + + + + + + + +
Subclasses of DiagnosingMatcher in org.hamcrest.beans
+static classSamePropertyValuesAs.PropertyMatcher + +
+           
+  +

+ + + + + +
+Uses of DiagnosingMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + +
Subclasses of DiagnosingMatcher in org.hamcrest.core
+ classAllOf<T> + +
+          Calculates the logical conjunction of multiple matchers.
+ classIsInstanceOf + +
+          Tests whether the value is an instance of a class.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/EasyMock2Matchers.html b/docs/javadoc/1.3/org/hamcrest/class-use/EasyMock2Matchers.html new file mode 100644 index 000000000..fe5291dec --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/EasyMock2Matchers.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.EasyMock2Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.EasyMock2Matchers

+
+No usage of org.hamcrest.EasyMock2Matchers +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Factory.html b/docs/javadoc/1.3/org/hamcrest/class-use/Factory.html new file mode 100644 index 000000000..6a6b0002c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Factory.html @@ -0,0 +1,1851 @@ + + + + + + +Uses of Class org.hamcrest.Factory (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.Factory

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use Factory
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Collections 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 Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
IsEmptyIterable.emptyIterable() + +
+          Creates a matcher for Iterables 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 Iterables 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 Maps 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 Maps 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 Maps 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 Maps 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 Collections 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 Collections 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 Maps 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 Maps 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 BigDecimals 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 Doubles 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 Nodes 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 Nodes 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 Nodes 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 Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/FeatureMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/FeatureMatcher.html new file mode 100644 index 000000000..0dd3606ab --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/FeatureMatcher.html @@ -0,0 +1,225 @@ + + + + + + +Uses of Class org.hamcrest.FeatureMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.FeatureMatcher

+
+ + + + + + + + + + + + + +
+Packages that use FeatureMatcher
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.objectMatchers that inspect objects and classes. 
+  +

+ + + + + +
+Uses of FeatureMatcher in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of FeatureMatcher in org.hamcrest.collection
+ classIsArrayWithSize<E> + +
+          Matches if array size satisfies a nested matcher.
+ classIsCollectionWithSize<E> + +
+          Matches if collection size satisfies a nested matcher.
+ classIsIterableWithSize<E> + +
+           
+  +

+ + + + + +
+Uses of FeatureMatcher in org.hamcrest.object
+  +

+ + + + + + + + + +
Subclasses of FeatureMatcher in org.hamcrest.object
+ classHasToString<T> + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/JMock1Matchers.html b/docs/javadoc/1.3/org/hamcrest/class-use/JMock1Matchers.html new file mode 100644 index 000000000..6a97465d5 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/JMock1Matchers.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.JMock1Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.JMock1Matchers

+
+No usage of org.hamcrest.JMock1Matchers +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/JavaLangMatcherAssert.html b/docs/javadoc/1.3/org/hamcrest/class-use/JavaLangMatcherAssert.html new file mode 100644 index 000000000..e7a913171 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/JavaLangMatcherAssert.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.JavaLangMatcherAssert (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.JavaLangMatcherAssert

+
+No usage of org.hamcrest.JavaLangMatcherAssert +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Matcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/Matcher.html new file mode 100644 index 000000000..d5012c304 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Matcher.html @@ -0,0 +1,8051 @@ + + + + + + +Uses of Interface org.hamcrest.Matcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Interface
org.hamcrest.Matcher

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use Matcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.integration  
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest that implement Matcher
+ classBaseMatcher<T> + +
+          BaseClass for all Matcher implementations.
+ classCustomMatcher<T> + +
+          Utility class for writing one off matchers.
+ classCustomTypeSafeMatcher<T> + +
+          Utility class for writing one off matchers.
+ classDiagnosingMatcher<T> + +
+          TODO(ngd): Document.
+ classFeatureMatcher<T,U> + +
+          Supporting class for matching a feature of an object.
+ classTypeSafeDiagnosingMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+ classTypeSafeMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest that return Matcher
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.allOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.allOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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> Matcher<T>
+
CoreMatchers.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 Matcher<java.lang.Object>Matchers.anything() + +
+          Creates a matcher that always matches, regardless of the examined object.
+static Matcher<java.lang.Object>CoreMatchers.anything() + +
+          Creates a matcher that always matches, regardless of the examined object.
+static Matcher<java.lang.Object>Matchers.anything(java.lang.String description) + +
+          Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+static Matcher<java.lang.Object>CoreMatchers.anything(java.lang.String description) + +
+          Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+static + + + + +
+<E> Matcher<E[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.arrayWithSize(int size) + +
+          Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+static + + + + +
+<E> Matcher<E[]>
+
Matchers.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 Matcher<java.math.BigDecimal>Matchers.closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) + +
+          Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+static Matcher<java.lang.Double>Matchers.closeTo(double operand, + double error) + +
+          Creates a matcher of Doubles 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>
+
Matchers.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 + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
Matchers.contains(E... items) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.contains(java.util.List<Matcher<? super E>> itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.contains(Matcher<? super E>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.contains(Matcher<? super E> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
Matchers.containsInAnyOrder(Matcher<? super E> itemMatcher) + +
+          Deprecated. use contains(Matcher itemMatcher) instead
+static + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
Matchers.containsInAnyOrder(Matcher<? super T>... itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
Matchers.containsInAnyOrder(T... items) + +
+          Creates an order agnostic matcher for Iterables 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 Matcher<java.lang.String>Matchers.containsString(java.lang.String substring) + +
+          Creates a matcher that matches if the examined String contains the specified + String anywhere.
+static Matcher<java.lang.String>CoreMatchers.containsString(java.lang.String substring) + +
+          Creates a matcher that matches if the examined String contains the specified + String anywhere.
+static + + + + +
+<T> Matcher<T>
+
Matchers.describedAs(java.lang.String description, + Matcher<T> matcher, + java.lang.Object... values) + +
+          Wraps an existing matcher, overriding its description with that specified.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.describedAs(java.lang.String description, + Matcher<T> matcher, + java.lang.Object... values) + +
+          Wraps an existing matcher, overriding its description with that specified.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
Matchers.empty() + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<E[]>
+
Matchers.emptyArray() + +
+          Creates a matcher for arrays that matches when the length of the array + is zero.
+static + + + + +
+<E> Matcher<java.util.Collection<E>>
+
Matchers.emptyCollectionOf(java.lang.Class<E> type) + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
Matchers.emptyIterable() + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
Matchers.emptyIterableOf(java.lang.Class<E> type) + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+static Matcher<java.lang.String>Matchers.endsWith(java.lang.String suffix) + +
+          Creates a matcher that matches if the examined String ends with the specified + String.
+static Matcher<java.lang.String>CoreMatchers.endsWith(java.lang.String suffix) + +
+          Creates a matcher that matches if the examined String ends with the specified + String.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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 + + + + +
+<T> Matcher<T>
+
CoreMatchers.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 Matcher<java.lang.String>Matchers.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>Matchers.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.util.EventObject>Matchers.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>Matchers.eventFrom(java.lang.Object source) + +
+          Creates a matcher of EventObject that matches any EventObject + announced by source.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
Matchers.everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
CoreMatchers.everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
Matchers.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>
+
Matchers.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 + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
Matchers.hasEntry(K key, + V value) + +
+          Creates a matcher for Maps 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>>
+
Matchers.hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps 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<java.lang.Iterable<? super T>>
+
Matchers.hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
CoreMatchers.hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.hasItem(T item) + +
+          Creates a matcher for Iterables 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<? super T>>
+
CoreMatchers.hasItem(T item) + +
+          Creates a matcher for Iterables 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<T[]>
+
Matchers.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[]>
+
Matchers.hasItemInArray(T element) + +
+          A shortcut to the frequently used hasItemInArray(equalTo(x)).
+static + + + + +
+<T> Matcher<java.lang.Iterable<T>>
+
Matchers.hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
CoreMatchers.hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.hasItems(T... items) + +
+          Creates a matcher for Iterables 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<java.lang.Iterable<T>>
+
CoreMatchers.hasItems(T... items) + +
+          Creates a matcher for Iterables 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 + + + + +
+<K> Matcher<java.util.Map<? extends K,?>>
+
Matchers.hasKey(K key) + +
+          Creates a matcher for Maps 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,?>>
+
Matchers.hasKey(Matcher<? super K> keyMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
Matchers.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 + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
Matchers.hasSize(int size) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
Matchers.hasSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
Matchers.hasToString(java.lang.String expectedToString) + +
+          Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
Matchers.hasValue(Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
Matchers.hasValue(V value) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+static Matcher<org.w3c.dom.Node>Matchers.hasXPath(java.lang.String xPath) + +
+          Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+static Matcher<org.w3c.dom.Node>Matchers.hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+static Matcher<org.w3c.dom.Node>Matchers.hasXPath(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) + +
+          Creates a matcher of Nodes 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>Matchers.hasXPath(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.is(java.lang.Class<T> type) + +
+          Deprecated. use isA(Class type) instead.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.is(java.lang.Class<T> type) + +
+          Deprecated. use isA(Class type) instead.
+static + + + + +
+<T> Matcher<T>
+
Matchers.is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
Matchers.is(T value) + +
+          A shortcut to the frequently used is(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.is(T value) + +
+          A shortcut to the frequently used is(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
Matchers.isA(java.lang.Class<T> type) + +
+          A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.isA(java.lang.Class<T> type) + +
+          A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+static Matcher<java.lang.String>Matchers.isEmptyOrNullString() + +
+          Creates a matcher of String that matches when the examined string is null, or + has zero length.
+static Matcher<java.lang.String>Matchers.isEmptyString() + +
+          Creates a matcher of String that matches when the examined string has zero length.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
Matchers.isIn(T[] param1) + +
+           
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>>
+
Matchers.iterableWithSize(int size) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
Matchers.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>
+
Matchers.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.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.not(T value) + +
+          A shortcut to the frequently used not(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.not(T value) + +
+          A shortcut to the frequently used not(equalTo(x)).
+static Matcher<java.lang.Object>Matchers.notNullValue() + +
+          A shortcut to the frequently used not(nullValue()).
+static Matcher<java.lang.Object>CoreMatchers.notNullValue() + +
+          A shortcut to the frequently used not(nullValue()).
+static + + + + +
+<T> Matcher<T>
+
Matchers.notNullValue(java.lang.Class<T> type) + +
+          A shortcut to the frequently used not(nullValue(X.class)).
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.notNullValue(java.lang.Class<T> type) + +
+          A shortcut to the frequently used not(nullValue(X.class)).
+static Matcher<java.lang.Object>Matchers.nullValue() + +
+          Creates a matcher that matches if examined object is null.
+static Matcher<java.lang.Object>CoreMatchers.nullValue() + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
Matchers.nullValue(java.lang.Class<T> type) + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.nullValue(java.lang.Class<T> type) + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
Matchers.sameInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.sameInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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.
+static Matcher<java.lang.String>Matchers.startsWith(java.lang.String prefix) + +
+          Creates a matcher that matches if the examined String starts with the specified + String.
+static Matcher<java.lang.String>CoreMatchers.startsWith(java.lang.String prefix) + +
+          Creates a matcher that matches if the examined String starts with the specified + String.
+static Matcher<java.lang.String>Matchers.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.
+static + + + + +
+<T> Matcher<T>
+
Matchers.theInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.theInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<java.lang.Class<?>>
+
Matchers.typeCompatibleWith(java.lang.Class<T> baseType) + +
+          Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest with parameters of type Matcher
+static + + + + +
+<T> Matcher<T>
+
Matchers.allOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.allOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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> AnyOf<T>
+
Matchers.anyOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
CoreMatchers.anyOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
CoreMatchers.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>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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 + + + + +
+<T> IsArray<T>
+
Matchers.array(Matcher<? super T>... elementMatchers) + +
+          Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+static + + + + +
+<E> Matcher<E[]>
+
Matchers.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[]>
+
Matchers.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[]>
+
Matchers.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 + + + + +
+<T> void
+
MatcherAssert.assertThat(java.lang.String reason, + T actual, + Matcher<? super T> matcher) + +
+           
+static + + + + +
+<T> void
+
MatcherAssert.assertThat(T actual, + Matcher<? super T> matcher) + +
+           
+static + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
Matchers.both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+static + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
CoreMatchers.both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
Matchers.contains(Matcher<? super E>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
Matchers.contains(Matcher<? super E> itemMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
Matchers.containsInAnyOrder(Matcher<? super E> itemMatcher) + +
+          Deprecated. use contains(Matcher itemMatcher) instead
+static + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
Matchers.containsInAnyOrder(Matcher<? super T>... itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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<T>
+
Matchers.describedAs(java.lang.String description, + Matcher<T> matcher, + java.lang.Object... values) + +
+          Wraps an existing matcher, overriding its description with that specified.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.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>
+
Matchers.either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+static + + + + +
+<LHS> CombinableMatcher.CombinableEitherMatcher<LHS>
+
CoreMatchers.either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
Matchers.everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
CoreMatchers.everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+static + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
Matchers.hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+static + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
Matchers.hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps 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<java.lang.Iterable<? super T>>
+
Matchers.hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
CoreMatchers.hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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<T[]>
+
Matchers.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<java.lang.Iterable<T>>
+
Matchers.hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
CoreMatchers.hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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 + + + + +
+<K> Matcher<java.util.Map<? extends K,?>>
+
Matchers.hasKey(Matcher<? super K> keyMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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 + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
Matchers.hasSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.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 + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
Matchers.hasValue(Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+static Matcher<org.w3c.dom.Node>Matchers.hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+static Matcher<org.w3c.dom.Node>Matchers.hasXPath(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+static + + + + +
+<T> Matcher<T>
+
Matchers.is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
CoreMatchers.is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
Matchers.iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+ booleanCondition.matching(Matcher<T> match) + +
+           
+abstract  booleanCondition.matching(Matcher<T> match, + java.lang.String message) + +
+           
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.not(Matcher<T> matcher) + +
+          Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+static + + + + +
+<T> boolean
+
JavaLangMatcherAssert.that(T argument, + Matcher<? super T> matcher) + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Method parameters in org.hamcrest with type arguments of type Matcher
+static + + + + +
+<T> Matcher<T>
+
Matchers.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>
+
CoreMatchers.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> AnyOf<T>
+
Matchers.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>
+
CoreMatchers.anyOf(java.lang.Iterable<Matcher<? super T>> matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<E> Matcher<E[]>
+
Matchers.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[]>
+
Matchers.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<java.lang.Iterable<? extends E>>
+
Matchers.contains(java.util.List<Matcher<? super E>> itemMatchers) + +
+          Creates a matcher for Iterables 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 + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
Matchers.containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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.
+  +

+ + + + + + + + +
Constructors in org.hamcrest with parameters of type Matcher
FeatureMatcher(Matcher<? super U> subMatcher, + java.lang.String featureDescription, + java.lang.String featureName) + +
+          Constructor
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.beans
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.beans that implement Matcher
+ classHasProperty<T> + +
+          A Matcher that checks that an object has a JavaBean property + with the specified name.
+ classHasPropertyWithValue<T> + +
+          Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+ classSamePropertyValuesAs<T> + +
+           
+static classSamePropertyValuesAs.PropertyMatcher + +
+           
+  +

+ + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.beans that return Matcher
+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.
+  +

+ + + + + + + + + +
Methods in org.hamcrest.beans with parameters of type Matcher
+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.
+  +

+ + + + + + + + +
Constructors in org.hamcrest.beans with parameters of type Matcher
HasPropertyWithValue(java.lang.String propertyName, + Matcher<?> valueMatcher) + +
+           
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.collection that implement Matcher
+ classIsArray<T> + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+ classIsArrayContaining<T> + +
+          Matches if an array contains an item satisfying a nested matcher.
+ classIsArrayContainingInAnyOrder<E> + +
+           
+ classIsArrayContainingInOrder<E> + +
+           
+ classIsArrayWithSize<E> + +
+          Matches if array size satisfies a nested matcher.
+ classIsCollectionWithSize<E> + +
+          Matches if collection size satisfies a nested matcher.
+ classIsEmptyCollection<E> + +
+          Tests if collection is empty.
+ classIsEmptyIterable<E> + +
+          Tests if collection is empty.
+ classIsIn<T> + +
+           
+ classIsIterableContainingInAnyOrder<T> + +
+           
+ classIsIterableContainingInOrder<E> + +
+           
+ classIsIterableWithSize<E> + +
+           
+ classIsMapContaining<K,V> + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.collection that return Matcher
+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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Collections 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 Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
IsEmptyIterable.emptyIterable() + +
+          Creates a matcher for Iterables 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 Iterables 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 Maps 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 Maps 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 Maps 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 Maps 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 Collections 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 Collections 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 Maps 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 Maps 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 Iterables 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 Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.collection with parameters of type Matcher
+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(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(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(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(Matcher<? super E>... itemMatchers) + +
+          Creates a matcher for Iterables 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 Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+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 Iterables 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 + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
IsMapContaining.hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+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 Maps 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 + + + + +
+<K> Matcher<java.util.Map<? extends K,?>>
+
IsMapContaining.hasKey(Matcher<? super K> keyMatcher) + +
+          Creates a matcher for Maps 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(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Collections 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 Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
IsIterableWithSize.iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Method parameters in org.hamcrest.collection with type arguments of type Matcher
+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[]>
+
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<java.lang.Iterable<? extends E>>
+
IsIterableContainingInOrder.contains(java.util.List<Matcher<? super E>> itemMatchers) + +
+          Creates a matcher for Iterables 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 + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
IsIterableContainingInAnyOrder.containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Constructors in org.hamcrest.collection with parameters of type Matcher
IsArray(Matcher<? super T>[] elementMatchers) + +
+           
IsArrayContaining(Matcher<? super T> elementMatcher) + +
+           
IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+           
IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+           
+  +

+ + + + + + + + + + + + + + + + + +
Constructor parameters in org.hamcrest.collection with type arguments of type Matcher
IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers) + +
+           
IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers) + +
+           
IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers) + +
+           
IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers) + +
+           
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.core that implement Matcher
+ classAllOf<T> + +
+          Calculates the logical conjunction of multiple matchers.
+ classAnyOf<T> + +
+          Calculates the logical disjunction of multiple matchers.
+ classCombinableMatcher<T> + +
+           
+ classDescribedAs<T> + +
+          Provides a custom description to another matcher.
+ classEvery<T> + +
+           
+ classIs<T> + +
+          Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+ classIsAnything<T> + +
+          A matcher that always returns true.
+ classIsCollectionContaining<T> + +
+           
+ classIsEqual<T> + +
+          Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+ classIsInstanceOf + +
+          Tests whether the value is an instance of a class.
+ classIsNot<T> + +
+          Calculates the logical negation of a matcher.
+ classIsNull<T> + +
+          Is the value null?
+ classIsSame<T> + +
+          Is the value the same object as another value?
+ classStringContains + +
+          Tests if the argument is a string that contains a substring.
+ classStringEndsWith + +
+          Tests if the argument is a string that contains a substring.
+ classStringStartsWith + +
+          Tests if the argument is a string that contains a substring.
+ classSubstringMatcher + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.core that return Matcher
+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 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 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 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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 Iterables 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.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.core with parameters of type Matcher
+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) + +
+          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) + +
+          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) + +
+          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) + +
+          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) + +
+          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) + +
+          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>
+
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>
+
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>
+
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>
+
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>
+
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.
+ CombinableMatcher<T>CombinableMatcher.and(Matcher<? super T> other) + +
+           
+ CombinableMatcher<X>CombinableMatcher.CombinableBothMatcher.and(Matcher<? super X> other) + +
+           
+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) + +
+          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) + +
+          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) + +
+          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) + +
+          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) + +
+          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) + +
+          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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<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 + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
Every.everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables 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 Iterables 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<T>>
+
IsCollectionContaining.hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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<T>
+
Is.is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+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.
+ CombinableMatcher<T>CombinableMatcher.or(Matcher<? super T> other) + +
+           
+ CombinableMatcher<X>CombinableMatcher.CombinableEitherMatcher.or(Matcher<? super X> other) + +
+           
+  +

+ + + + + + + + + + + + + +
Method parameters in org.hamcrest.core with type arguments of type Matcher
+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> 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.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Constructors in org.hamcrest.core with parameters of type Matcher
CombinableMatcher.CombinableBothMatcher(Matcher<? super X> matcher) + +
+           
CombinableMatcher.CombinableEitherMatcher(Matcher<? super X> matcher) + +
+           
CombinableMatcher(Matcher<? super T> matcher) + +
+           
DescribedAs(java.lang.String descriptionTemplate, + Matcher<T> matcher, + java.lang.Object[] values) + +
+           
Every(Matcher<? super T> matcher) + +
+           
Is(Matcher<T> matcher) + +
+           
IsCollectionContaining(Matcher<? super T> elementMatcher) + +
+           
IsNot(Matcher<T> matcher) + +
+           
+  +

+ + + + + + + + + + + +
Constructor parameters in org.hamcrest.core with type arguments of type Matcher
AllOf(java.lang.Iterable<Matcher<? super T>> matchers) + +
+           
AnyOf(java.lang.Iterable<Matcher<? super T>> matchers) + +
+           
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.integration
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest.integration with parameters of type Matcher
+static org.jmock.core.ConstraintJMock1Adapter.adapt(Matcher<?> matcher) + +
+          Convenience factory method that will adapt a + Hamcrest Matcher to act as an + jMock Constraint.
+static org.easymock.IArgumentMatcherEasyMock2Adapter.adapt(Matcher<?> matcher) + +
+          Convenience factory method that will adapt a + Hamcrest Matcher to act as an + EasyMock IArgumentMatcher and + report it to EasyMock so it can be kept track of.
+  +

+ + + + + + + + + + + +
Constructors in org.hamcrest.integration with parameters of type Matcher
EasyMock2Adapter(Matcher<?> matcher) + +
+           
JMock1Adapter(Matcher<?> matcher) + +
+           
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.number
+  +

+ + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.number that implement Matcher
+ classBigDecimalCloseTo + +
+           
+ classIsCloseTo + +
+          Is the value a number equal to a value within some range of + acceptable error?
+ classOrderingComparison<T extends Comparable<T>> + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.number that return Matcher
+static Matcher<java.math.BigDecimal>BigDecimalCloseTo.closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) + +
+          Creates a matcher of BigDecimals 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 Doubles 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 Matcher in org.hamcrest.object
+  +

+ + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.object that implement Matcher
+ classHasToString<T> + +
+           
+ classIsCompatibleType<T> + +
+           
+ classIsEventFrom + +
+          Tests if the value is an event announced by a specific object.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.object that return Matcher
+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.
+  +

+ + + + + + + + + +
Methods in org.hamcrest.object with parameters of type Matcher
+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.
+  +

+ + + + + + + + +
Constructors in org.hamcrest.object with parameters of type Matcher
HasToString(Matcher<? super java.lang.String> toStringMatcher) + +
+           
+  +

+ + + + + +
+Uses of Matcher in org.hamcrest.text
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.text that implement Matcher
+ classIsEmptyString + +
+          Matches empty Strings (and null).
+ classIsEqualIgnoringCase + +
+          Tests if a string is equal to another string, regardless of the case.
+ classIsEqualIgnoringWhiteSpace + +
+          Tests if a string is equal to another string, ignoring any changes in whitespace.
+ classStringContainsInOrder + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.text that return Matcher
+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 Matcher in org.hamcrest.xml
+  +

+ + + + + + + + + +
Classes in org.hamcrest.xml that implement Matcher
+ classHasXPath + +
+          Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.xml that return Matcher
+static Matcher<org.w3c.dom.Node>HasXPath.hasXPath(java.lang.String xPath) + +
+          Creates a matcher of Nodes 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 Nodes 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 Nodes 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 Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest.xml with parameters of type Matcher
+static Matcher<org.w3c.dom.Node>HasXPath.hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes 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, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+  +

+ + + + + + + + + + + +
Constructors in org.hamcrest.xml with parameters of type Matcher
HasXPath(java.lang.String xPathExpression, + Matcher<java.lang.String> valueMatcher) + +
+           
HasXPath(java.lang.String xPathExpression, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/MatcherAssert.html b/docs/javadoc/1.3/org/hamcrest/class-use/MatcherAssert.html new file mode 100644 index 000000000..39aee6e75 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/MatcherAssert.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.MatcherAssert (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.MatcherAssert

+
+No usage of org.hamcrest.MatcherAssert +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/Matchers.html b/docs/javadoc/1.3/org/hamcrest/class-use/Matchers.html new file mode 100644 index 000000000..4bfd62be6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/Matchers.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.Matchers (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.Matchers

+
+No usage of org.hamcrest.Matchers +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/SelfDescribing.html b/docs/javadoc/1.3/org/hamcrest/class-use/SelfDescribing.html new file mode 100644 index 000000000..9bd0b4c2f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/SelfDescribing.html @@ -0,0 +1,892 @@ + + + + + + +Uses of Interface org.hamcrest.SelfDescribing (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Interface
org.hamcrest.SelfDescribing

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use SelfDescribing
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.internal  
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest
+  +

+ + + + + + + + + +
Subinterfaces of SelfDescribing in org.hamcrest
+ interfaceMatcher<T> + +
+          A matcher over acceptable values.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest that implement SelfDescribing
+ classBaseMatcher<T> + +
+          BaseClass for all Matcher implementations.
+ classCustomMatcher<T> + +
+          Utility class for writing one off matchers.
+ classCustomTypeSafeMatcher<T> + +
+          Utility class for writing one off matchers.
+ classDiagnosingMatcher<T> + +
+          TODO(ngd): Document.
+ classFeatureMatcher<T,U> + +
+          Supporting class for matching a feature of an object.
+ classTypeSafeDiagnosingMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+ classTypeSafeMatcher<T> + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest with parameters of type SelfDescribing
+ DescriptionDescription.appendDescriptionOf(SelfDescribing value) + +
+          Appends the description of a SelfDescribing value to this description.
+ DescriptionDescription.NullDescription.appendDescriptionOf(SelfDescribing value) + +
+           
+ DescriptionBaseDescription.appendDescriptionOf(SelfDescribing value) + +
+           
+static java.lang.StringStringDescription.asString(SelfDescribing selfDescribing) + +
+          Alias for StringDescription.toString(SelfDescribing).
+static java.lang.StringStringDescription.toString(SelfDescribing selfDescribing) + +
+          Return the description of a SelfDescribing object as a String.
+  +

+ + + + + + + + + + + + + + + + + +
Method parameters in org.hamcrest with type arguments of type SelfDescribing
+ DescriptionDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+          Appends a list of SelfDescribing objects + to the description.
+ DescriptionDescription.NullDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+           
+ DescriptionBaseDescription.appendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.beans
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.beans that implement SelfDescribing
+ classHasProperty<T> + +
+          A Matcher that checks that an object has a JavaBean property + with the specified name.
+ classHasPropertyWithValue<T> + +
+          Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+ classSamePropertyValuesAs<T> + +
+           
+static classSamePropertyValuesAs.PropertyMatcher + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.collection that implement SelfDescribing
+ classIsArray<T> + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+ classIsArrayContaining<T> + +
+          Matches if an array contains an item satisfying a nested matcher.
+ classIsArrayContainingInAnyOrder<E> + +
+           
+ classIsArrayContainingInOrder<E> + +
+           
+ classIsArrayWithSize<E> + +
+          Matches if array size satisfies a nested matcher.
+ classIsCollectionWithSize<E> + +
+          Matches if collection size satisfies a nested matcher.
+ classIsEmptyCollection<E> + +
+          Tests if collection is empty.
+ classIsEmptyIterable<E> + +
+          Tests if collection is empty.
+ classIsIn<T> + +
+           
+ classIsIterableContainingInAnyOrder<T> + +
+           
+ classIsIterableContainingInOrder<E> + +
+           
+ classIsIterableWithSize<E> + +
+           
+ classIsMapContaining<K,V> + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.core that implement SelfDescribing
+ classAllOf<T> + +
+          Calculates the logical conjunction of multiple matchers.
+ classAnyOf<T> + +
+          Calculates the logical disjunction of multiple matchers.
+ classCombinableMatcher<T> + +
+           
+ classDescribedAs<T> + +
+          Provides a custom description to another matcher.
+ classEvery<T> + +
+           
+ classIs<T> + +
+          Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+ classIsAnything<T> + +
+          A matcher that always returns true.
+ classIsCollectionContaining<T> + +
+           
+ classIsEqual<T> + +
+          Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+ classIsInstanceOf + +
+          Tests whether the value is an instance of a class.
+ classIsNot<T> + +
+          Calculates the logical negation of a matcher.
+ classIsNull<T> + +
+          Is the value null?
+ classIsSame<T> + +
+          Is the value the same object as another value?
+ classStringContains + +
+          Tests if the argument is a string that contains a substring.
+ classStringEndsWith + +
+          Tests if the argument is a string that contains a substring.
+ classStringStartsWith + +
+          Tests if the argument is a string that contains a substring.
+ classSubstringMatcher + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.internal
+  +

+ + + + + + + + + +
Classes in org.hamcrest.internal that implement SelfDescribing
+ classSelfDescribingValue<T> + +
+           
+  +

+ + + + + + + + + +
Methods in org.hamcrest.internal that return SelfDescribing
+ SelfDescribingSelfDescribingValueIterator.next() + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.number
+  +

+ + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.number that implement SelfDescribing
+ classBigDecimalCloseTo + +
+           
+ classIsCloseTo + +
+          Is the value a number equal to a value within some range of + acceptable error?
+ classOrderingComparison<T extends Comparable<T>> + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.object
+  +

+ + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.object that implement SelfDescribing
+ classHasToString<T> + +
+           
+ classIsCompatibleType<T> + +
+           
+ classIsEventFrom + +
+          Tests if the value is an event announced by a specific object.
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.text
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Classes in org.hamcrest.text that implement SelfDescribing
+ classIsEmptyString + +
+          Matches empty Strings (and null).
+ classIsEqualIgnoringCase + +
+          Tests if a string is equal to another string, regardless of the case.
+ classIsEqualIgnoringWhiteSpace + +
+          Tests if a string is equal to another string, ignoring any changes in whitespace.
+ classStringContainsInOrder + +
+           
+  +

+ + + + + +
+Uses of SelfDescribing in org.hamcrest.xml
+  +

+ + + + + + + + + +
Classes in org.hamcrest.xml that implement SelfDescribing
+ classHasXPath + +
+          Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/StringDescription.html b/docs/javadoc/1.3/org/hamcrest/class-use/StringDescription.html new file mode 100644 index 000000000..adf936c2f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/StringDescription.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.StringDescription (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.StringDescription

+
+No usage of org.hamcrest.StringDescription +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeDiagnosingMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..6b00ab489 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,390 @@ + + + + + + +Uses of Class org.hamcrest.TypeSafeDiagnosingMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.TypeSafeDiagnosingMatcher

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use TypeSafeDiagnosingMatcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest
+  +

+ + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest
+ classFeatureMatcher<T,U> + +
+          Supporting class for matching a feature of an object.
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest.beans
+  +

+ + + + + + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest.beans
+ classHasPropertyWithValue<T> + +
+          Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+ classSamePropertyValuesAs<T> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest.collection
+ classIsArrayWithSize<E> + +
+          Matches if array size satisfies a nested matcher.
+ classIsCollectionWithSize<E> + +
+          Matches if collection size satisfies a nested matcher.
+ classIsIterableContainingInAnyOrder<T> + +
+           
+ classIsIterableContainingInOrder<E> + +
+           
+ classIsIterableWithSize<E> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest.core
+ classCombinableMatcher<T> + +
+           
+ classEvery<T> + +
+           
+ classIsCollectionContaining<T> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest.object
+  +

+ + + + + + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest.object
+ classHasToString<T> + +
+           
+ classIsEventFrom + +
+          Tests if the value is an event announced by a specific object.
+  +

+ + + + + +
+Uses of TypeSafeDiagnosingMatcher in org.hamcrest.xml
+  +

+ + + + + + + + + +
Subclasses of TypeSafeDiagnosingMatcher in org.hamcrest.xml
+ classHasXPath + +
+          Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeMatcher.html b/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeMatcher.html new file mode 100644 index 000000000..845c4c327 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/class-use/TypeSafeMatcher.html @@ -0,0 +1,460 @@ + + + + + + +Uses of Class org.hamcrest.TypeSafeMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.TypeSafeMatcher

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use TypeSafeMatcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest
+  +

+ + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest
+ classCustomTypeSafeMatcher<T> + +
+          Utility class for writing one off matchers.
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.beans
+  +

+ + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.beans
+ classHasProperty<T> + +
+          A Matcher that checks that an object has a JavaBean property + with the specified name.
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.collection
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.collection
+ classIsArray<T> + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+ classIsArrayContaining<T> + +
+          Matches if an array contains an item satisfying a nested matcher.
+ classIsArrayContainingInAnyOrder<E> + +
+           
+ classIsArrayContainingInOrder<E> + +
+           
+ classIsEmptyCollection<E> + +
+          Tests if collection is empty.
+ classIsEmptyIterable<E> + +
+          Tests if collection is empty.
+ classIsMapContaining<K,V> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.core
+ classStringContains + +
+          Tests if the argument is a string that contains a substring.
+ classStringEndsWith + +
+          Tests if the argument is a string that contains a substring.
+ classStringStartsWith + +
+          Tests if the argument is a string that contains a substring.
+ classSubstringMatcher + +
+           
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.number
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.number
+ classBigDecimalCloseTo + +
+           
+ classIsCloseTo + +
+          Is the value a number equal to a value within some range of + acceptable error?
+ classOrderingComparison<T extends Comparable<T>> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.object
+  +

+ + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.object
+ classIsCompatibleType<T> + +
+           
+  +

+ + + + + +
+Uses of TypeSafeMatcher in org.hamcrest.text
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of TypeSafeMatcher in org.hamcrest.text
+ classIsEqualIgnoringCase + +
+          Tests if a string is equal to another string, regardless of the case.
+ classIsEqualIgnoringWhiteSpace + +
+          Tests if a string is equal to another string, ignoring any changes in whitespace.
+ classStringContainsInOrder + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsArray.html b/docs/javadoc/1.3/org/hamcrest/collection/IsArray.html new file mode 100644 index 000000000..0f18d5dc6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsArray.html @@ -0,0 +1,444 @@ + + + + + + +IsArray (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsArray<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T[]>
+          extended by org.hamcrest.collection.IsArray<T>
+
+
+
All Implemented Interfaces:
Matcher<T[]>, SelfDescribing
+
+
+
+
public class IsArray<T>
extends TypeSafeMatcher<T[]>
+ + +

+Matcher for array whose elements satisfy a sequence of matchers. + The array size must equal the number of element matchers. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsArray(Matcher<? super T>[] elementMatchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> IsArray<T>
+
array(Matcher<? super T>... elementMatchers) + +
+          Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+ voiddescribeMismatchSafely(T[] actual, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+protected  java.lang.StringdescriptionEnd() + +
+          Returns the string that ends the description.
+protected  java.lang.StringdescriptionSeparator() + +
+          Returns the string that separates the elements in the description.
+protected  java.lang.StringdescriptionStart() + +
+          Returns the string that starts the description.
+ booleanmatchesSafely(T[] array) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsArray

+
+public IsArray(Matcher<? super T>[] elementMatchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T[] array)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<T[]>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(T[] actual,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<T[]>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+descriptionStart

+
+protected java.lang.String descriptionStart()
+
+
Returns the string that starts the description. + + Can be overridden in subclasses to customise how the matcher is + described. +

+

+
+
+
+
+ +

+descriptionSeparator

+
+protected java.lang.String descriptionSeparator()
+
+
Returns the string that separates the elements in the description. + + Can be overridden in subclasses to customise how the matcher is + described. +

+

+
+
+
+
+ +

+descriptionEnd

+
+protected java.lang.String descriptionEnd()
+
+
Returns the string that ends the description. + + Can be overridden in subclasses to customise how the matcher is + described. +

+

+
+
+
+
+ +

+array

+
+public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. +

+ For example: +

assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
+

+

+
Parameters:
elementMatchers - the matchers that the elements of examined arrays should satisfy
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContaining.html b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContaining.html new file mode 100644 index 000000000..a2daf53f8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContaining.html @@ -0,0 +1,405 @@ + + + + + + +IsArrayContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsArrayContaining<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T[]>
+          extended by org.hamcrest.collection.IsArrayContaining<T>
+
+
+
All Implemented Interfaces:
Matcher<T[]>, SelfDescribing
+
+
+
+
public class IsArrayContaining<T>
extends TypeSafeMatcher<T[]>
+ + +

+Matches if an array contains an item satisfying a nested matcher. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsArrayContaining(Matcher<? super T> elementMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(T[] item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T[]>
+
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[]>
+
hasItemInArray(T element) + +
+          A shortcut to the frequently used hasItemInArray(equalTo(x)).
+ booleanmatchesSafely(T[] array) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsArrayContaining

+
+public IsArrayContaining(Matcher<? super T> elementMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T[] array)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<T[]>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(T[] item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<T[]>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasItemInArray

+
+public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. +

+ For example: +

assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
+

+

+
Parameters:
elementMatcher - the matcher to apply to elements in examined arrays
+
+
+
+ +

+hasItemInArray

+
+public static <T> Matcher<T[]> hasItemInArray(T element)
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)). +

+ For example: +

assertThat(hasItemInArray(x))
+ instead of: +
assertThat(hasItemInArray(equalTo(x)))
+

+

+
Parameters:
element - the element that should be present in examined arrays
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInAnyOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..82290cbda --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInAnyOrder.html @@ -0,0 +1,451 @@ + + + + + + +IsArrayContainingInAnyOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsArrayContainingInAnyOrder<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<E[]>
+          extended by org.hamcrest.collection.IsArrayContainingInAnyOrder<E>
+
+
+
All Implemented Interfaces:
Matcher<E[]>, SelfDescribing
+
+
+
+
public class IsArrayContainingInAnyOrder<E>
extends TypeSafeMatcher<E[]>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<E> Matcher<E[]>
+
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[]>
+
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[]>
+
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.
+ voiddescribeMismatchSafely(E[] item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(E[] item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsArrayContainingInAnyOrder

+
+public IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(E[] item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<E[]>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(E[] item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<E[]>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

+ N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

+ N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
+
+
+
+ +

+arrayContainingInAnyOrder

+
+public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

+ N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
+

+

+
Parameters:
items - the items that must equal the entries of an examined array, in any order
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInOrder.html new file mode 100644 index 000000000..4b2db6130 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayContainingInOrder.html @@ -0,0 +1,436 @@ + + + + + + +IsArrayContainingInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsArrayContainingInOrder<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<E[]>
+          extended by org.hamcrest.collection.IsArrayContainingInOrder<E>
+
+
+
All Implemented Interfaces:
Matcher<E[]>, SelfDescribing
+
+
+
+
public class IsArrayContainingInOrder<E>
extends TypeSafeMatcher<E[]>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<E> Matcher<E[]>
+
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[]>
+
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[]>
+
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.
+ voiddescribeMismatchSafely(E[] item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(E[] item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsArrayContainingInOrder

+
+public IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(E[] item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<E[]>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(E[] item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<E[]>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, + the examined array must be of the same length as the number of specified items. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
+

+

+
Parameters:
items - the items that must equal the items within an examined array
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
+

+

+
Parameters:
itemMatchers - the matchers that must be satisfied by the items in the examined array
+
+
+
+ +

+arrayContaining

+
+public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsArrayWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayWithSize.html new file mode 100644 index 000000000..707ff4c60 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsArrayWithSize.html @@ -0,0 +1,395 @@ + + + + + + +IsArrayWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsArrayWithSize<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.FeatureMatcher<E[],java.lang.Integer>
+              extended by org.hamcrest.collection.IsArrayWithSize<E>
+
+
+
All Implemented Interfaces:
Matcher<E[]>, SelfDescribing
+
+
+
+
public class IsArrayWithSize<E>
extends FeatureMatcher<E[],java.lang.Integer>
+ + +

+Matches if array size satisfies a nested matcher. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<E> Matcher<E[]>
+
arrayWithSize(int size) + +
+          Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+static + + + + +
+<E> Matcher<E[]>
+
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<E[]>
+
emptyArray() + +
+          Creates a matcher for arrays that matches when the length of the array + is zero.
+protected  java.lang.IntegerfeatureValueOf(E[] actual) + +
+          Implement this to extract the interesting feature.
+ + + + + + + +
Methods inherited from class org.hamcrest.FeatureMatcher
describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsArrayWithSize

+
+public IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+featureValueOf

+
+protected java.lang.Integer featureValueOf(E[] actual)
+
+
Description copied from class: FeatureMatcher
+
Implement this to extract the interesting feature. +

+

+
Specified by:
featureValueOf in class FeatureMatcher<E[],java.lang.Integer>
+
+
+
Parameters:
actual - the target object +
Returns:
the feature to be matched
+
+
+
+ +

+arrayWithSize

+
+public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the length of an examined array
+
+
+
+ +

+arrayWithSize

+
+public static <E> Matcher<E[]> arrayWithSize(int size)
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size. +

+ For example: +

assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
+

+

+
Parameters:
size - the length that an examined array must have for a positive match
+
+
+
+ +

+emptyArray

+
+public static <E> Matcher<E[]> emptyArray()
+
+
Creates a matcher for arrays that matches when the length of the array + is zero. +

+ For example: +

assertThat(new String[0], emptyArray())
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsCollectionWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/IsCollectionWithSize.html new file mode 100644 index 000000000..1798819e6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsCollectionWithSize.html @@ -0,0 +1,362 @@ + + + + + + +IsCollectionWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsCollectionWithSize<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
+              extended by org.hamcrest.collection.IsCollectionWithSize<E>
+
+
+
All Implemented Interfaces:
Matcher<java.util.Collection<? extends E>>, SelfDescribing
+
+
+
+
public class IsCollectionWithSize<E>
extends FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
+ + +

+Matches if collection size satisfies a nested matcher. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  java.lang.IntegerfeatureValueOf(java.util.Collection<? extends E> actual) + +
+          Implement this to extract the interesting feature.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
hasSize(int size) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
hasSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+ + + + + + + +
Methods inherited from class org.hamcrest.FeatureMatcher
describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsCollectionWithSize

+
+public IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+featureValueOf

+
+protected java.lang.Integer featureValueOf(java.util.Collection<? extends E> actual)
+
+
Description copied from class: FeatureMatcher
+
Implement this to extract the interesting feature. +

+

+
Specified by:
featureValueOf in class FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
+
+
+
Parameters:
actual - the target object +
Returns:
the feature to be matched
+
+
+
+ +

+hasSize

+
+public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the size of an examined Collection
+
+
+
+ +

+hasSize

+
+public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasSize(2))
+

+

+
Parameters:
size - the expected size of an examined Collection
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyCollection.html b/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyCollection.html new file mode 100644 index 000000000..4a36b40c3 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyCollection.html @@ -0,0 +1,404 @@ + + + + + + +IsEmptyCollection (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsEmptyCollection<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.util.Collection<? extends E>>
+          extended by org.hamcrest.collection.IsEmptyCollection<E>
+
+
+
All Implemented Interfaces:
Matcher<java.util.Collection<? extends E>>, SelfDescribing
+
+
+
+
public class IsEmptyCollection<E>
extends TypeSafeMatcher<java.util.Collection<? extends E>>
+ + +

+Tests if collection is empty. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEmptyCollection() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.util.Collection<? extends E> item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<E> Matcher<java.util.Collection<? extends E>>
+
empty() + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+static + + + + +
+<E> Matcher<java.util.Collection<E>>
+
emptyCollectionOf(java.lang.Class<E> type) + +
+          Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+ booleanmatchesSafely(java.util.Collection<? extends E> item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEmptyCollection

+
+public IsEmptyCollection()
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.util.Collection<? extends E> item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.util.Collection<? extends E> item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+empty

+
+public static <E> Matcher<java.util.Collection<? extends E>> empty()
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +

+ For example: +

assertThat(new ArrayList<String>(), is(empty()))
+

+

+
+
+
+
+ +

+emptyCollectionOf

+
+public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> type)
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
+

+

+
Parameters:
type - the type of the collection's content
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyIterable.html b/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyIterable.html new file mode 100644 index 000000000..d28c1e9db --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsEmptyIterable.html @@ -0,0 +1,400 @@ + + + + + + +IsEmptyIterable (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsEmptyIterable<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.Iterable<? extends E>>
+          extended by org.hamcrest.collection.IsEmptyIterable<E>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<? extends E>>, SelfDescribing
+
+
+
+
public class IsEmptyIterable<E>
extends TypeSafeMatcher<java.lang.Iterable<? extends E>>
+ + +

+Tests if collection is empty. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEmptyIterable() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.Iterable<? extends E> iter, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
emptyIterable() + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
emptyIterableOf(java.lang.Class<E> type) + +
+          Creates a matcher for Iterables matching examined iterables that yield no items.
+ booleanmatchesSafely(java.lang.Iterable<? extends E> iterable) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEmptyIterable

+
+public IsEmptyIterable()
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.Iterable<? extends E> iterable)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.Iterable<? extends E> iter,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+emptyIterable

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
+
+
Creates a matcher for Iterables matching examined iterables that yield no items. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyIterable()))
+

+

+
+
+
+
+ +

+emptyIterableOf

+
+public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> type)
+
+
Creates a matcher for Iterables matching examined iterables that yield no items. +

+ For example: +

assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
+

+

+
Parameters:
type - the type of the iterable's content
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsIn.html b/docs/javadoc/1.3/org/hamcrest/collection/IsIn.html new file mode 100644 index 000000000..df1ba06b5 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsIn.html @@ -0,0 +1,411 @@ + + + + + + +IsIn (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsIn<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.collection.IsIn<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsIn<T>
extends BaseMatcher<T>
+ + +

+


+ +

+ + + + + + + + + + + + + + +
+Constructor Summary
IsIn(java.util.Collection<T> collection) + +
+           
IsIn(T[] elements) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description buffer) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
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(T[] elements) + +
+          Creates a matcher that matches when the examined object is found within the + specified array.
+static + + + + +
+<T> Matcher<T>
+
isOneOf(T... elements) + +
+          Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+ booleanmatches(java.lang.Object o) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsIn

+
+public IsIn(java.util.Collection<T> collection)
+
+
+
+ +

+IsIn

+
+public IsIn(T[] elements)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
o - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description buffer)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
buffer - The description to be built or appended to.
+
+
+
+ +

+isIn

+
+public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
+
+
Creates a matcher that matches when the examined object is found within the + specified collection. +

+ For example: +

assertThat("foo", isIn(Arrays.asList("bar", "foo")))
+

+

+
Parameters:
collection - the collection in which matching items must be found
+
+
+
+ +

+isIn

+
+public static <T> Matcher<T> isIn(T[] elements)
+
+
Creates a matcher that matches when the examined object is found within the + specified array. +

+ For example: +

assertThat("foo", isIn(new String[]{"bar", "foo"}))
+

+

+
Parameters:
elements - the array in which matching items must be found
+
+
+
+ +

+isOneOf

+
+public static <T> Matcher<T> isOneOf(T... elements)
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements. +

+ For example: +

assertThat("foo", isIn("bar", "foo"))
+

+

+
Parameters:
elements - the elements amongst which matching items will be found
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInAnyOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..921e6543a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInAnyOrder.html @@ -0,0 +1,465 @@ + + + + + + +IsIterableContainingInAnyOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsIterableContainingInAnyOrder<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
+          extended by org.hamcrest.collection.IsIterableContainingInAnyOrder<T>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<? extends T>>, SelfDescribing
+
+
+
+
public class IsIterableContainingInAnyOrder<T>
extends TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
containsInAnyOrder(Matcher<? super E> itemMatcher) + +
+          Deprecated. use contains(Matcher itemMatcher) instead
+static + + + + +
+<T> Matcher<java.lang.Iterable<? extends T>>
+
containsInAnyOrder(Matcher<? super T>... itemMatchers) + +
+          Creates an order agnostic matcher for Iterables 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>>
+
containsInAnyOrder(T... items) + +
+          Creates an order agnostic matcher for Iterables 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.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+protected  booleanmatchesSafely(java.lang.Iterable<? extends T> items, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsIterableContainingInAnyOrder

+
+public IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected boolean matchesSafely(java.lang.Iterable<? extends T> items,
+                                Description mismatchDescription)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+containsInAnyOrder

+
+@Deprecated
+public static <E> Matcher<java.lang.Iterable<? extends E>> containsInAnyOrder(Matcher<? super E> itemMatcher)
+
+
Deprecated. use contains(Matcher itemMatcher) instead +

+

Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. +

+ For example: +

assertThat(Arrays.asList("foo"), containsInAnyOrder(equalTo("foo")))
+

+

+
Parameters:
itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
+
+
Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

+ N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
+
+
Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

+ N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
+

+

+
Parameters:
items - the items that must equal the items provided by an examined Iterable in any order
+
+
+
+ +

+containsInAnyOrder

+
+public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
+
+
Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

+ N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInOrder.html new file mode 100644 index 000000000..923f88271 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableContainingInOrder.html @@ -0,0 +1,452 @@ + + + + + + +IsIterableContainingInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsIterableContainingInOrder<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
+          extended by org.hamcrest.collection.IsIterableContainingInOrder<E>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<? extends E>>, SelfDescribing
+
+
+
+
public class IsIterableContainingInOrder<E>
extends TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<E> Matcher<java.lang.Iterable<? extends E>>
+
contains(E... items) + +
+          Creates a matcher for Iterables 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>>
+
contains(java.util.List<Matcher<? super E>> itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
contains(Matcher<? super E>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
contains(Matcher<? super E> itemMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+protected  booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsIterableContainingInOrder

+
+public IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
+                                Description mismatchDescription)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
+
+
Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
+

+

+
Parameters:
items - the items that must equal the items provided by an examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. +

+ For example: +

assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
+

+

+
Parameters:
itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
+

+

+
Parameters:
itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
+
+
+
+ +

+contains

+
+public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
+
+
Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
+

+

+
Parameters:
itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsIterableWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableWithSize.html new file mode 100644 index 000000000..9f09b2671 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsIterableWithSize.html @@ -0,0 +1,362 @@ + + + + + + +IsIterableWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsIterableWithSize<E>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
+              extended by org.hamcrest.collection.IsIterableWithSize<E>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<E>>, SelfDescribing
+
+
+
+
public class IsIterableWithSize<E>
extends FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  java.lang.IntegerfeatureValueOf(java.lang.Iterable<E> actual) + +
+          Implement this to extract the interesting feature.
+static + + + + +
+<E> Matcher<java.lang.Iterable<E>>
+
iterableWithSize(int size) + +
+          Creates a matcher for Iterables 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>>
+
iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) + +
+          Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+ + + + + + + +
Methods inherited from class org.hamcrest.FeatureMatcher
describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsIterableWithSize

+
+public IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+featureValueOf

+
+protected java.lang.Integer featureValueOf(java.lang.Iterable<E> actual)
+
+
Description copied from class: FeatureMatcher
+
Implement this to extract the interesting feature. +

+

+
Specified by:
featureValueOf in class FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
+
+
+
Parameters:
actual - the target object +
Returns:
the feature to be matched
+
+
+
+ +

+iterableWithSize

+
+public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
+

+

+
Parameters:
sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
+
+
+
+ +

+iterableWithSize

+
+public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
+

+

+
Parameters:
size - the number of items that should be yielded by an examined Iterable
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/IsMapContaining.html b/docs/javadoc/1.3/org/hamcrest/collection/IsMapContaining.html new file mode 100644 index 000000000..1dd64d45b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/IsMapContaining.html @@ -0,0 +1,542 @@ + + + + + + +IsMapContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.collection +
+Class IsMapContaining<K,V>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
+          extended by org.hamcrest.collection.IsMapContaining<K,V>
+
+
+
All Implemented Interfaces:
Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
+
+
+
+
public class IsMapContaining<K,V>
extends TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.util.Map<? extends K,? extends V> map, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<K,V> Matcher<java.util.Map<? extends K,? extends V>>
+
hasEntry(K key, + V value) + +
+          Creates a matcher for Maps 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>>
+
hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+static + + + + +
+<K> Matcher<java.util.Map<? extends K,?>>
+
hasKey(K key) + +
+          Creates a matcher for Maps 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,?>>
+
hasKey(Matcher<? super K> keyMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
hasValue(Matcher<? super V> valueMatcher) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+static + + + + +
+<V> Matcher<java.util.Map<?,? extends V>>
+
hasValue(V value) + +
+          Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+ booleanmatchesSafely(java.util.Map<? extends K,? extends V> map) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsMapContaining

+
+public IsMapContaining(Matcher<? super K> keyMatcher,
+                       Matcher<? super V> valueMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.util.Map<? extends K,? extends V> map)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.util.Map<? extends K,? extends V> map,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasEntry

+
+public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
+                                                                             Matcher<? super V> valueMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. +

+ For example: +

assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
+

+

+
Parameters:
keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
+
+
+
+ +

+hasEntry

+
+public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
+                                                                             V value)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. +

+ For example: +

assertThat(myMap, hasEntry("bar", "foo"))
+

+

+
Parameters:
key - the key that, in combination with the value, must be describe at least one entry
value - the value that, in combination with the key, must be describe at least one entry
+
+
+
+ +

+hasKey

+
+public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. +

+ For example: +

assertThat(myMap, hasKey(equalTo("bar")))
+

+

+
Parameters:
keyMatcher - the matcher that must be satisfied by at least one key
+
+
+
+ +

+hasKey

+
+public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. +

+ For example: +

assertThat(myMap, hasKey("bar"))
+

+

+
Parameters:
key - the key that satisfying maps must contain
+
+
+
+ +

+hasValue

+
+public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. +

+ For example: +

assertThat(myMap, hasValue(equalTo("foo")))
+

+

+
Parameters:
valueMatcher - the matcher that must be satisfied by at least one value
+
+
+
+ +

+hasValue

+
+public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. +

+ For example: +

assertThat(myMap, hasValue("foo"))
+

+

+
Parameters:
value - the value that satisfying maps must contain
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArray.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArray.html new file mode 100644 index 000000000..81f26e4b6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArray.html @@ -0,0 +1,223 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsArray (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsArray

+
+ + + + + + + + + + + + + +
+Packages that use IsArray
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.collectionMatchers of arrays and collections. 
+  +

+ + + + + +
+Uses of IsArray in org.hamcrest
+  +

+ + + + + + + + + +
Methods in org.hamcrest that return IsArray
+static + + + + +
+<T> IsArray<T>
+
Matchers.array(Matcher<? super T>... elementMatchers) + +
+          Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+  +

+ + + + + +
+Uses of IsArray in org.hamcrest.collection
+  +

+ + + + + + + + + +
Methods in org.hamcrest.collection that return IsArray
+static + + + + +
+<T> IsArray<T>
+
IsArray.array(Matcher<? super T>... elementMatchers) + +
+          Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContaining.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContaining.html new file mode 100644 index 000000000..89eaf5a51 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContaining.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsArrayContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsArrayContaining

+
+No usage of org.hamcrest.collection.IsArrayContaining +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInAnyOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..084ec01ea --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInAnyOrder.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsArrayContainingInAnyOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsArrayContainingInAnyOrder

+
+No usage of org.hamcrest.collection.IsArrayContainingInAnyOrder +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInOrder.html new file mode 100644 index 000000000..db92988c7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayContainingInOrder.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsArrayContainingInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsArrayContainingInOrder

+
+No usage of org.hamcrest.collection.IsArrayContainingInOrder +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayWithSize.html new file mode 100644 index 000000000..06538db0c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsArrayWithSize.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsArrayWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsArrayWithSize

+
+No usage of org.hamcrest.collection.IsArrayWithSize +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsCollectionWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsCollectionWithSize.html new file mode 100644 index 000000000..3610bffcd --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsCollectionWithSize.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsCollectionWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsCollectionWithSize

+
+No usage of org.hamcrest.collection.IsCollectionWithSize +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyCollection.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyCollection.html new file mode 100644 index 000000000..6ada8b465 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyCollection.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsEmptyCollection (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsEmptyCollection

+
+No usage of org.hamcrest.collection.IsEmptyCollection +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyIterable.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyIterable.html new file mode 100644 index 000000000..1b5f2ba62 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsEmptyIterable.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsEmptyIterable (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsEmptyIterable

+
+No usage of org.hamcrest.collection.IsEmptyIterable +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIn.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIn.html new file mode 100644 index 000000000..a6e7f0c52 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIn.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsIn (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsIn

+
+No usage of org.hamcrest.collection.IsIn +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInAnyOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..7d4ac39c2 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInAnyOrder.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsIterableContainingInAnyOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsIterableContainingInAnyOrder

+
+No usage of org.hamcrest.collection.IsIterableContainingInAnyOrder +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInOrder.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInOrder.html new file mode 100644 index 000000000..c2682f149 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableContainingInOrder.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsIterableContainingInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsIterableContainingInOrder

+
+No usage of org.hamcrest.collection.IsIterableContainingInOrder +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableWithSize.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableWithSize.html new file mode 100644 index 000000000..c13202d1a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsIterableWithSize.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsIterableWithSize (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsIterableWithSize

+
+No usage of org.hamcrest.collection.IsIterableWithSize +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsMapContaining.html b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsMapContaining.html new file mode 100644 index 000000000..f403a39da --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/class-use/IsMapContaining.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.collection.IsMapContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.collection.IsMapContaining

+
+No usage of org.hamcrest.collection.IsMapContaining +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/package-frame.html b/docs/javadoc/1.3/org/hamcrest/collection/package-frame.html new file mode 100644 index 000000000..d6d103962 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/package-frame.html @@ -0,0 +1,56 @@ + + + + + + +org.hamcrest.collection (Hamcrest) + + + + + + + + + + + +org.hamcrest.collection + + + + +
+Classes  + +
+IsArray +
+IsArrayContaining +
+IsArrayContainingInAnyOrder +
+IsArrayContainingInOrder +
+IsArrayWithSize +
+IsCollectionWithSize +
+IsEmptyCollection +
+IsEmptyIterable +
+IsIn +
+IsIterableContainingInAnyOrder +
+IsIterableContainingInOrder +
+IsIterableWithSize +
+IsMapContaining
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/package-summary.html b/docs/javadoc/1.3/org/hamcrest/collection/package-summary.html new file mode 100644 index 000000000..42b1d1ed3 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/package-summary.html @@ -0,0 +1,220 @@ + + + + + + +org.hamcrest.collection (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.collection +

+Matchers of arrays and collections. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Class Summary
IsArray<T>Matcher for array whose elements satisfy a sequence of matchers.
IsArrayContaining<T>Matches if an array contains an item satisfying a nested matcher.
IsArrayContainingInAnyOrder<E> 
IsArrayContainingInOrder<E> 
IsArrayWithSize<E>Matches if array size satisfies a nested matcher.
IsCollectionWithSize<E>Matches if collection size satisfies a nested matcher.
IsEmptyCollection<E>Tests if collection is empty.
IsEmptyIterable<E>Tests if collection is empty.
IsIn<T> 
IsIterableContainingInAnyOrder<T> 
IsIterableContainingInOrder<E> 
IsIterableWithSize<E> 
IsMapContaining<K,V> 
+  + +

+

+Package org.hamcrest.collection Description +

+ +

+

Matchers of arrays and collections.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/package-tree.html b/docs/javadoc/1.3/org/hamcrest/collection/package-tree.html new file mode 100644 index 000000000..52dd0cd2f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/package-tree.html @@ -0,0 +1,162 @@ + + + + + + +org.hamcrest.collection Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.collection +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/collection/package-use.html b/docs/javadoc/1.3/org/hamcrest/collection/package-use.html new file mode 100644 index 000000000..5a8c45e86 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/collection/package-use.html @@ -0,0 +1,189 @@ + + + + + + +Uses of Package org.hamcrest.collection (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.collection

+
+ + + + + + + + + + + + + +
+Packages that use org.hamcrest.collection
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.collectionMatchers of arrays and collections. 
+  +

+ + + + + + + + +
+Classes in org.hamcrest.collection used by org.hamcrest
IsArray + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+  +

+ + + + + + + + +
+Classes in org.hamcrest.collection used by org.hamcrest.collection
IsArray + +
+          Matcher for array whose elements satisfy a sequence of matchers.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/AllOf.html b/docs/javadoc/1.3/org/hamcrest/core/AllOf.html new file mode 100644 index 000000000..16ae7fcbe --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/AllOf.html @@ -0,0 +1,556 @@ + + + + + + +AllOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class AllOf<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.DiagnosingMatcher<T>
+          extended by org.hamcrest.core.AllOf<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class AllOf<T>
extends DiagnosingMatcher<T>
+ + +

+Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns false. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
AllOf(java.lang.Iterable<Matcher<? super T>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<T>
+
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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+static + + + + +
+<T> Matcher<T>
+
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(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(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(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(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.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object o, + Description mismatch) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.DiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+AllOf

+
+public AllOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o,
+                       Description mismatch)
+
+
+
Specified by:
matches in class DiagnosingMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> allOf(Matcher<? super T> first,
+                                   Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+
+ +

+allOf

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/AnyOf.html b/docs/javadoc/1.3/org/hamcrest/core/AnyOf.html new file mode 100644 index 000000000..b54cb30ee --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/AnyOf.html @@ -0,0 +1,598 @@ + + + + + + +AnyOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class AnyOf<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.AnyOf<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class AnyOf<T>
extends BaseMatcher<T>
+ + +

+Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns true. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
AnyOf(java.lang.Iterable<Matcher<? super T>> matchers) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> AnyOf<T>
+
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(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
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(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(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(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(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.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ voiddescribeTo(Description description, + java.lang.String operator) + +
+           
+ booleanmatches(java.lang.Object o) + +
+          Evaluates the matcher for argument item.
+protected  booleanmatches(java.lang.Object o, + boolean shortcut) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+AnyOf

+
+public AnyOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Specified by:
matches in interface Matcher<T>
+
+
+
Parameters:
o - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Specified by:
describeTo in interface SelfDescribing
+
+
+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> anyOf(Matcher<T> first,
+                                 Matcher<? super T> second)
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+anyOf

+
+public static <T> AnyOf<T> 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. +

+ For example: +

assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
+

+

+
+
+
+
+ +

+matches

+
+protected boolean matches(java.lang.Object o,
+                          boolean shortcut)
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description,
+                       java.lang.String operator)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..a4aa58cd9 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,255 @@ + + + + + + +CombinableMatcher.CombinableBothMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class CombinableMatcher.CombinableBothMatcher<X>

+
+java.lang.Object
+  extended by org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<X>
+
+
+
Enclosing class:
CombinableMatcher<T>
+
+
+
+
public static final class CombinableMatcher.CombinableBothMatcher<X>
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
CombinableMatcher.CombinableBothMatcher(Matcher<? super X> matcher) + +
+           
+  + + + + + + + + + + + +
+Method Summary
+ CombinableMatcher<X>and(Matcher<? super X> other) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CombinableMatcher.CombinableBothMatcher

+
+public CombinableMatcher.CombinableBothMatcher(Matcher<? super X> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+and

+
+public CombinableMatcher<X> and(Matcher<? super X> other)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..4981f839d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,255 @@ + + + + + + +CombinableMatcher.CombinableEitherMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class CombinableMatcher.CombinableEitherMatcher<X>

+
+java.lang.Object
+  extended by org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<X>
+
+
+
Enclosing class:
CombinableMatcher<T>
+
+
+
+
public static final class CombinableMatcher.CombinableEitherMatcher<X>
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
CombinableMatcher.CombinableEitherMatcher(Matcher<? super X> matcher) + +
+           
+  + + + + + + + + + + + +
+Method Summary
+ CombinableMatcher<X>or(Matcher<? super X> other) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CombinableMatcher.CombinableEitherMatcher

+
+public CombinableMatcher.CombinableEitherMatcher(Matcher<? super X> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+or

+
+public CombinableMatcher<X> or(Matcher<? super X> other)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.html new file mode 100644 index 000000000..88aa7dc22 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/CombinableMatcher.html @@ -0,0 +1,433 @@ + + + + + + +CombinableMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class CombinableMatcher<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.core.CombinableMatcher<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class CombinableMatcher<T>
extends TypeSafeDiagnosingMatcher<T>
+ + +

+


+ +

+ + + + + + + + + + + + + + + +
+Nested Class Summary
+static classCombinableMatcher.CombinableBothMatcher<X> + +
+           
+static classCombinableMatcher.CombinableEitherMatcher<X> + +
+           
+  + + + + + + + + + + +
+Constructor Summary
CombinableMatcher(Matcher<? super T> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ CombinableMatcher<T>and(Matcher<? super T> other) + +
+           
+static + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<LHS> CombinableMatcher.CombinableEitherMatcher<LHS>
+
either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+protected  booleanmatchesSafely(T item, + Description mismatch) + +
+          Subclasses should implement this.
+ CombinableMatcher<T>or(Matcher<? super T> other) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CombinableMatcher

+
+public CombinableMatcher(Matcher<? super T> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected boolean matchesSafely(T item,
+                                Description mismatch)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<T>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+and

+
+public CombinableMatcher<T> and(Matcher<? super T> other)
+
+
+
+
+
+
+ +

+or

+
+public CombinableMatcher<T> or(Matcher<? super T> other)
+
+
+
+
+
+
+ +

+both

+
+public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when both of the specified matchers match the examined object. +

+ For example: +

assertThat("fab", both(containsString("a")).and(containsString("b")))
+

+

+
+
+
+
+ +

+either

+
+public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
+
+
Creates a matcher that matches when either of the specified matchers match the examined object. +

+ For example: +

assertThat("fan", either(containsString("a")).and(containsString("b")))
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/DescribedAs.html b/docs/javadoc/1.3/org/hamcrest/core/DescribedAs.html new file mode 100644 index 000000000..d120cc606 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/DescribedAs.html @@ -0,0 +1,373 @@ + + + + + + +DescribedAs (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class DescribedAs<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.DescribedAs<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class DescribedAs<T>
extends BaseMatcher<T>
+ + +

+Provides a custom description to another matcher. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
DescribedAs(java.lang.String descriptionTemplate, + Matcher<T> matcher, + java.lang.Object[] values) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<T>
+
describedAs(java.lang.String description, + Matcher<T> matcher, + java.lang.Object... values) + +
+          Wraps an existing matcher, overriding its description with that specified.
+ voiddescribeMismatch(java.lang.Object item, + Description description) + +
+          Generate a description of why the matcher has not accepted the item.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object o) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+DescribedAs

+
+public DescribedAs(java.lang.String descriptionTemplate,
+                   Matcher<T> matcher,
+                   java.lang.Object[] values)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
o - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+describeMismatch

+
+public void describeMismatch(java.lang.Object item,
+                             Description description)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
Overrides:
describeMismatch in class BaseMatcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
description - The description to be built or appended to.
+
+
+
+ +

+describedAs

+
+public static <T> Matcher<T> describedAs(java.lang.String description,
+                                         Matcher<T> matcher,
+                                         java.lang.Object... values)
+
+
Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. +

+ For example: +

describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
+

+

+
Parameters:
description - the new description for the wrapped matcher
matcher - the matcher to wrap
values - optional values to insert into the tokenised description
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/Every.html b/docs/javadoc/1.3/org/hamcrest/core/Every.html new file mode 100644 index 000000000..ddc96f992 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/Every.html @@ -0,0 +1,343 @@ + + + + + + +Every (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class Every<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<java.lang.Iterable<T>>
+          extended by org.hamcrest.core.Every<T>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<T>>, SelfDescribing
+
+
+
+
public class Every<T>
extends TypeSafeDiagnosingMatcher<java.lang.Iterable<T>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
Every(Matcher<? super T> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<U> Matcher<java.lang.Iterable<U>>
+
everyItem(Matcher<U> itemMatcher) + +
+          Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+ booleanmatchesSafely(java.lang.Iterable<T> collection, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Every

+
+public Every(Matcher<? super T> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.Iterable<T> collection,
+                             Description mismatchDescription)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<T>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+everyItem

+
+public static <U> Matcher<java.lang.Iterable<U>> everyItem(Matcher<U> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. +

+ For example: +

assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to every item provided by the examined Iterable
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/Is.html b/docs/javadoc/1.3/org/hamcrest/core/Is.html new file mode 100644 index 000000000..bcfff1c27 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/Is.html @@ -0,0 +1,474 @@ + + + + + + +Is (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class Is<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.Is<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class Is<T>
extends BaseMatcher<T>
+ + +

+Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive. + + For example: assertThat(cheese, equalTo(smelly)) + vs. assertThat(cheese, is(equalTo(smelly))) +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
Is(Matcher<T> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) + +
+          Generate a description of why the matcher has not accepted the item.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
is(java.lang.Class<T> type) + +
+          Deprecated. use isA(Class type) instead.
+static + + + + +
+<T> Matcher<T>
+
is(Matcher<T> matcher) + +
+          Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+static + + + + +
+<T> Matcher<T>
+
is(T value) + +
+          A shortcut to the frequently used is(equalTo(x)).
+static + + + + +
+<T> Matcher<T>
+
isA(java.lang.Class<T> type) + +
+          A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+ booleanmatches(java.lang.Object arg) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Is

+
+public Is(Matcher<T> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object arg)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
arg - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+describeMismatch

+
+public void describeMismatch(java.lang.Object item,
+                             Description mismatchDescription)
+
+
Description copied from interface: Matcher
+
Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this. +

+

+
Specified by:
describeMismatch in interface Matcher<T>
Overrides:
describeMismatch in class BaseMatcher<T>
+
+
+
Parameters:
item - The item that the Matcher has rejected.
mismatchDescription - The description to be built or appended to.
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(Matcher<T> matcher)
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. +

+ For example: +

assertThat(cheese, is(equalTo(smelly)))
+ instead of: +
assertThat(cheese, equalTo(smelly))
+

+

+
+
+
+
+ +

+is

+
+public static <T> Matcher<T> is(T value)
+
+
A shortcut to the frequently used is(equalTo(x)). +

+ For example: +

assertThat(cheese, is(smelly))
+ instead of: +
assertThat(cheese, is(equalTo(smelly)))
+

+

+
+
+
+
+ +

+is

+
+@Deprecated
+public static <T> Matcher<T> is(java.lang.Class<T> type)
+
+
Deprecated. use isA(Class type) instead. +

+

A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, is(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+
+ +

+isA

+
+public static <T> Matcher<T> isA(java.lang.Class<T> type)
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)). +

+ For example: +

assertThat(cheese, isA(Cheddar.class))
+ instead of: +
assertThat(cheese, is(instanceOf(Cheddar.class)))
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsAnything.html b/docs/javadoc/1.3/org/hamcrest/core/IsAnything.html new file mode 100644 index 000000000..41e0bf71d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsAnything.html @@ -0,0 +1,360 @@ + + + + + + +IsAnything (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsAnything<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.IsAnything<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsAnything<T>
extends BaseMatcher<T>
+ + +

+A matcher that always returns true. +

+ +

+


+ +

+ + + + + + + + + + + + + + +
+Constructor Summary
IsAnything() + +
+           
IsAnything(java.lang.String message) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static Matcher<java.lang.Object>anything() + +
+          Creates a matcher that always matches, regardless of the examined object.
+static Matcher<java.lang.Object>anything(java.lang.String description) + +
+          Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object o) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsAnything

+
+public IsAnything()
+
+
+
+ +

+IsAnything

+
+public IsAnything(java.lang.String message)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
o - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything()
+
+
Creates a matcher that always matches, regardless of the examined object. +

+

+
+
+
+
+ +

+anything

+
+public static Matcher<java.lang.Object> anything(java.lang.String description)
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String. +

+

+
Parameters:
description - a meaningful String used when describing itself
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsCollectionContaining.html b/docs/javadoc/1.3/org/hamcrest/core/IsCollectionContaining.html new file mode 100644 index 000000000..25ca4104b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsCollectionContaining.html @@ -0,0 +1,452 @@ + + + + + + +IsCollectionContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsCollectionContaining<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
+          extended by org.hamcrest.core.IsCollectionContaining<T>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Iterable<? super T>>, SelfDescribing
+
+
+
+
public class IsCollectionContaining<T>
extends TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsCollectionContaining(Matcher<? super T> elementMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<java.lang.Iterable<? super T>>
+
hasItem(Matcher<? super T> itemMatcher) + +
+          Creates a matcher for Iterables 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>>
+
hasItem(T item) + +
+          Creates a matcher for Iterables 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>>
+
hasItems(Matcher<? super T>... itemMatchers) + +
+          Creates a matcher for Iterables 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>>
+
hasItems(T... items) + +
+          Creates a matcher for Iterables 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.
+protected  booleanmatchesSafely(java.lang.Iterable<? super T> collection, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsCollectionContaining

+
+public IsCollectionContaining(Matcher<? super T> elementMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
+                                Description mismatchDescription)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
+

+

+
Parameters:
itemMatcher - the matcher to apply to items provided by the examined Iterable
+
+
+
+ +

+hasItem

+
+public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
+

+

+
Parameters:
item - the item to compare against the items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
+

+

+
Parameters:
itemMatchers - the matchers to apply to items provided by the examined Iterable
+
+
+
+ +

+hasItems

+
+public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
+
+
Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. +

+ For example: +

assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
+

+

+
Parameters:
items - the items to compare against the items provided by the examined Iterable
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsEqual.html b/docs/javadoc/1.3/org/hamcrest/core/IsEqual.html new file mode 100644 index 000000000..857522d96 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsEqual.html @@ -0,0 +1,352 @@ + + + + + + +IsEqual (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsEqual<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.IsEqual<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsEqual<T>
extends BaseMatcher<T>
+ + +

+Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod? +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEqual(T equalArg) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
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.
+ booleanmatches(java.lang.Object actualValue) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEqual

+
+public IsEqual(T equalArg)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object actualValue)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
actualValue - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+equalTo

+
+public static <T> Matcher<T> 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. + +

If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

+ +

The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

+

+ For example: +

+ assertThat("foo", equalTo("foo"));
+ assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
+ 
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsInstanceOf.html b/docs/javadoc/1.3/org/hamcrest/core/IsInstanceOf.html new file mode 100644 index 000000000..f2986c738 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsInstanceOf.html @@ -0,0 +1,390 @@ + + + + + + +IsInstanceOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsInstanceOf

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.DiagnosingMatcher<java.lang.Object>
+          extended by org.hamcrest.core.IsInstanceOf
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Object>, SelfDescribing
+
+
+
+
public class IsInstanceOf
extends DiagnosingMatcher<java.lang.Object>
+ + +

+Tests whether the value is an instance of a class. + Classes of basic types will be converted to the relevant "Object" classes +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsInstanceOf(java.lang.Class<?> expectedClass) + +
+          Creates a new instance of IsInstanceOf
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T> Matcher<T>
+
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.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T> Matcher<T>
+
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.
+protected  booleanmatches(java.lang.Object item, + Description mismatch) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.DiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsInstanceOf

+
+public IsInstanceOf(java.lang.Class<?> expectedClass)
+
+
Creates a new instance of IsInstanceOf +

+

+
Parameters:
expectedClass - The predicate evaluates to true for instances of this class + or one of its subclasses.
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+protected boolean matches(java.lang.Object item,
+                          Description mismatch)
+
+
+
Specified by:
matches in class DiagnosingMatcher<java.lang.Object>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+instanceOf

+
+public static <T> Matcher<T> 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. + +

The created matcher assumes no relationship between specified type and the examined object.

+

+ For example: +

assertThat(new Canoe(), instanceOf(Paddlable.class));
+

+

+
+
+
+
+ +

+any

+
+public static <T> Matcher<T> 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. + +

The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

+

+ For example: +

assertThat(new Canoe(), instanceOf(Canoe.class));
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsNot.html b/docs/javadoc/1.3/org/hamcrest/core/IsNot.html new file mode 100644 index 000000000..d9574e837 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsNot.html @@ -0,0 +1,368 @@ + + + + + + +IsNot (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsNot<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.IsNot<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsNot<T>
extends BaseMatcher<T>
+ + +

+Calculates the logical negation of a matcher. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsNot(Matcher<T> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object arg) + +
+          Evaluates the matcher for argument item.
+static + + + + +
+<T> Matcher<T>
+
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>
+
not(T value) + +
+          A shortcut to the frequently used not(equalTo(x)).
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsNot

+
+public IsNot(Matcher<T> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object arg)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
arg - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(Matcher<T> matcher)
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. +

+ For example: +

assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
matcher - the matcher whose sense should be inverted
+
+
+
+ +

+not

+
+public static <T> Matcher<T> not(T value)
+
+
A shortcut to the frequently used not(equalTo(x)). +

+ For example: +

assertThat(cheese, is(not(smelly)))
+ instead of: +
assertThat(cheese, is(not(equalTo(smelly))))
+

+

+
Parameters:
value - the value that any examined object should not equal
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsNull.html b/docs/javadoc/1.3/org/hamcrest/core/IsNull.html new file mode 100644 index 000000000..a1f30d65e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsNull.html @@ -0,0 +1,418 @@ + + + + + + +IsNull (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsNull<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.IsNull<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsNull<T>
extends BaseMatcher<T>
+ + +

+Is the value null? +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsNull() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object o) + +
+          Evaluates the matcher for argument item.
+static Matcher<java.lang.Object>notNullValue() + +
+          A shortcut to the frequently used not(nullValue()).
+static + + + + +
+<T> Matcher<T>
+
notNullValue(java.lang.Class<T> type) + +
+          A shortcut to the frequently used not(nullValue(X.class)).
+static Matcher<java.lang.Object>nullValue() + +
+          Creates a matcher that matches if examined object is null.
+static + + + + +
+<T> Matcher<T>
+
nullValue(java.lang.Class<T> type) + +
+          Creates a matcher that matches if examined object is null.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsNull

+
+public IsNull()
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object o)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
o - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+nullValue

+
+public static Matcher<java.lang.Object> nullValue()
+
+
Creates a matcher that matches if examined object is null. +

+ For example: +

assertThat(cheese, is(nullValue())
+

+

+
+
+
+
+ +

+notNullValue

+
+public static Matcher<java.lang.Object> notNullValue()
+
+
A shortcut to the frequently used not(nullValue()). +

+ For example: +

assertThat(cheese, is(notNullValue()))
+ instead of: +
assertThat(cheese, is(not(nullValue())))
+

+

+
+
+
+
+ +

+nullValue

+
+public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
+
+
Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. +

+ For example: +

assertThat(cheese, is(nullValue(Cheese.class))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+
+ +

+notNullValue

+
+public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
+
+
A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. +

+ For example: +

assertThat(cheese, is(notNullValue(X.class)))
+ instead of: +
assertThat(cheese, is(not(nullValue(X.class))))
+

+

+
Parameters:
type - dummy parameter used to infer the generic type of the returned matcher
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/IsSame.html b/docs/javadoc/1.3/org/hamcrest/core/IsSame.html new file mode 100644 index 000000000..8a4f32b7a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/IsSame.html @@ -0,0 +1,362 @@ + + + + + + +IsSame (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class IsSame<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.core.IsSame<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class IsSame<T>
extends BaseMatcher<T>
+ + +

+Is the value the same object as another value? +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsSame(T object) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatches(java.lang.Object arg) + +
+          Evaluates the matcher for argument item.
+static + + + + +
+<T> Matcher<T>
+
sameInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+static + + + + +
+<T> Matcher<T>
+
theInstance(T target) + +
+          Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsSame

+
+public IsSame(T object)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object arg)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
arg - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+sameInstance

+
+public static <T> Matcher<T> sameInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+
+ +

+theInstance

+
+public static <T> Matcher<T> theInstance(T target)
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object. +

+

+
Parameters:
target - the target instance against which others should be assessed
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/StringContains.html b/docs/javadoc/1.3/org/hamcrest/core/StringContains.html new file mode 100644 index 000000000..1f044d14b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/StringContains.html @@ -0,0 +1,358 @@ + + + + + + +StringContains (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class StringContains

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.core.SubstringMatcher
+              extended by org.hamcrest.core.StringContains
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class StringContains
extends SubstringMatcher
+ + +

+Tests if the argument is a string that contains a substring. +

+ +

+


+ +

+ + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from class org.hamcrest.core.SubstringMatcher
substring
+  + + + + + + + + + + +
+Constructor Summary
StringContains(java.lang.String substring) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static Matcher<java.lang.String>containsString(java.lang.String substring) + +
+          Creates a matcher that matches if the examined String contains the specified + String anywhere.
+protected  booleanevalSubstringOf(java.lang.String s) + +
+           
+protected  java.lang.Stringrelationship() + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.core.SubstringMatcher
describeMismatchSafely, describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+StringContains

+
+public StringContains(java.lang.String substring)
+
+
+ + + + + + + + +
+Method Detail
+ +

+evalSubstringOf

+
+protected boolean evalSubstringOf(java.lang.String s)
+
+
+
Specified by:
evalSubstringOf in class SubstringMatcher
+
+
+
+
+
+
+ +

+relationship

+
+protected java.lang.String relationship()
+
+
+
Specified by:
relationship in class SubstringMatcher
+
+
+
+
+
+
+ +

+containsString

+
+public static Matcher<java.lang.String> containsString(java.lang.String substring)
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere. +

+ For example: +

assertThat("myStringOfNote", containsString("ring"))
+

+

+
Parameters:
substring - the substring that the returned matcher will expect to find within any examined string
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/StringEndsWith.html b/docs/javadoc/1.3/org/hamcrest/core/StringEndsWith.html new file mode 100644 index 000000000..b8c39c0c9 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/StringEndsWith.html @@ -0,0 +1,358 @@ + + + + + + +StringEndsWith (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class StringEndsWith

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.core.SubstringMatcher
+              extended by org.hamcrest.core.StringEndsWith
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class StringEndsWith
extends SubstringMatcher
+ + +

+Tests if the argument is a string that contains a substring. +

+ +

+


+ +

+ + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from class org.hamcrest.core.SubstringMatcher
substring
+  + + + + + + + + + + +
+Constructor Summary
StringEndsWith(java.lang.String substring) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static Matcher<java.lang.String>endsWith(java.lang.String suffix) + +
+          Creates a matcher that matches if the examined String ends with the specified + String.
+protected  booleanevalSubstringOf(java.lang.String s) + +
+           
+protected  java.lang.Stringrelationship() + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.core.SubstringMatcher
describeMismatchSafely, describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+StringEndsWith

+
+public StringEndsWith(java.lang.String substring)
+
+
+ + + + + + + + +
+Method Detail
+ +

+evalSubstringOf

+
+protected boolean evalSubstringOf(java.lang.String s)
+
+
+
Specified by:
evalSubstringOf in class SubstringMatcher
+
+
+
+
+
+
+ +

+relationship

+
+protected java.lang.String relationship()
+
+
+
Specified by:
relationship in class SubstringMatcher
+
+
+
+
+
+
+ +

+endsWith

+
+public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
+
+
Creates a matcher that matches if the examined String ends with the specified + String. +

+ For example: +

assertThat("myStringOfNote", endsWith("Note"))
+

+

+
Parameters:
suffix - the substring that the returned matcher will expect at the end of any examined string
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/StringStartsWith.html b/docs/javadoc/1.3/org/hamcrest/core/StringStartsWith.html new file mode 100644 index 000000000..e334cc83f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/StringStartsWith.html @@ -0,0 +1,358 @@ + + + + + + +StringStartsWith (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class StringStartsWith

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.core.SubstringMatcher
+              extended by org.hamcrest.core.StringStartsWith
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class StringStartsWith
extends SubstringMatcher
+ + +

+Tests if the argument is a string that contains a substring. +

+ +

+


+ +

+ + + + + + + +
+Field Summary
+ + + + + + + +
Fields inherited from class org.hamcrest.core.SubstringMatcher
substring
+  + + + + + + + + + + +
+Constructor Summary
StringStartsWith(java.lang.String substring) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  booleanevalSubstringOf(java.lang.String s) + +
+           
+protected  java.lang.Stringrelationship() + +
+           
+static Matcher<java.lang.String>startsWith(java.lang.String prefix) + +
+          Creates a matcher that matches if the examined String starts with the specified + String.
+ + + + + + + +
Methods inherited from class org.hamcrest.core.SubstringMatcher
describeMismatchSafely, describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+StringStartsWith

+
+public StringStartsWith(java.lang.String substring)
+
+
+ + + + + + + + +
+Method Detail
+ +

+evalSubstringOf

+
+protected boolean evalSubstringOf(java.lang.String s)
+
+
+
Specified by:
evalSubstringOf in class SubstringMatcher
+
+
+
+
+
+
+ +

+relationship

+
+protected java.lang.String relationship()
+
+
+
Specified by:
relationship in class SubstringMatcher
+
+
+
+
+
+
+ +

+startsWith

+
+public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
+
+
Creates a matcher that matches if the examined String starts with the specified + String. +

+ For example: +

assertThat("myStringOfNote", startsWith("my"))
+

+

+
Parameters:
prefix - the substring that the returned matcher will expect at the start of any examined string
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/SubstringMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/SubstringMatcher.html new file mode 100644 index 000000000..4fd64d41e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/SubstringMatcher.html @@ -0,0 +1,413 @@ + + + + + + +SubstringMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.core +
+Class SubstringMatcher

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.core.SubstringMatcher
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
Direct Known Subclasses:
StringContains, StringEndsWith, StringStartsWith
+
+
+
+
public abstract class SubstringMatcher
extends TypeSafeMatcher<java.lang.String>
+ + +

+


+ +

+ + + + + + + + + + + +
+Field Summary
+protected  java.lang.Stringsubstring + +
+           
+  + + + + + + + + + + + +
+Constructor Summary
+protected SubstringMatcher(java.lang.String substring) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+protected abstract  booleanevalSubstringOf(java.lang.String string) + +
+           
+ booleanmatchesSafely(java.lang.String item) + +
+          Subclasses should implement this.
+protected abstract  java.lang.Stringrelationship() + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+substring

+
+protected final java.lang.String substring
+
+
+
+
+ + + + + + + + +
+Constructor Detail
+ +

+SubstringMatcher

+
+protected SubstringMatcher(java.lang.String substring)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.String item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.String item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+evalSubstringOf

+
+protected abstract boolean evalSubstringOf(java.lang.String string)
+
+
+
+
+
+
+ +

+relationship

+
+protected abstract java.lang.String relationship()
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/AllOf.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/AllOf.html new file mode 100644 index 000000000..6554c1dff --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/AllOf.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.AllOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.AllOf

+
+No usage of org.hamcrest.core.AllOf +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/AnyOf.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/AnyOf.html new file mode 100644 index 000000000..b23820ede --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/AnyOf.html @@ -0,0 +1,553 @@ + + + + + + +Uses of Class org.hamcrest.core.AnyOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.AnyOf

+
+ + + + + + + + + + + + + +
+Packages that use AnyOf
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of AnyOf in org.hamcrest
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest that return AnyOf
+static + + + + +
+<T> AnyOf<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.anyOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
CoreMatchers.anyOf(Matcher<? super T>... matchers) + +
+          Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+static + + + + +
+<T> AnyOf<T>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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>
+
CoreMatchers.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>
+
Matchers.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 + + + + +
+<T> AnyOf<T>
+
CoreMatchers.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.
+  +

+ + + + + +
+Uses of AnyOf in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.core that return AnyOf
+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.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..729bc2a8d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,238 @@ + + + + + + +Uses of Class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.CombinableMatcher.CombinableBothMatcher

+
+ + + + + + + + + + + + + +
+Packages that use CombinableMatcher.CombinableBothMatcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of CombinableMatcher.CombinableBothMatcher in org.hamcrest
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest that return CombinableMatcher.CombinableBothMatcher
+static + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
Matchers.both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+static + + + + +
+<LHS> CombinableMatcher.CombinableBothMatcher<LHS>
+
CoreMatchers.both(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when both of the specified matchers match the examined object.
+  +

+ + + + + +
+Uses of CombinableMatcher.CombinableBothMatcher in org.hamcrest.core
+  +

+ + + + + + + + + +
Methods in org.hamcrest.core that return CombinableMatcher.CombinableBothMatcher
+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.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..932603a3e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,238 @@ + + + + + + +Uses of Class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher

+
+ + + + + + + + + + + + + +
+Packages that use CombinableMatcher.CombinableEitherMatcher
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of CombinableMatcher.CombinableEitherMatcher in org.hamcrest
+  +

+ + + + + + + + + + + + + +
Methods in org.hamcrest that return CombinableMatcher.CombinableEitherMatcher
+static + + + + +
+<LHS> CombinableMatcher.CombinableEitherMatcher<LHS>
+
Matchers.either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+static + + + + +
+<LHS> CombinableMatcher.CombinableEitherMatcher<LHS>
+
CoreMatchers.either(Matcher<? super LHS> matcher) + +
+          Creates a matcher that matches when either of the specified matchers match the examined object.
+  +

+ + + + + +
+Uses of CombinableMatcher.CombinableEitherMatcher in org.hamcrest.core
+  +

+ + + + + + + + + +
Methods in org.hamcrest.core that return CombinableMatcher.CombinableEitherMatcher
+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.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.html new file mode 100644 index 000000000..cc3197ab8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/CombinableMatcher.html @@ -0,0 +1,204 @@ + + + + + + +Uses of Class org.hamcrest.core.CombinableMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.CombinableMatcher

+
+ + + + + + + + + +
+Packages that use CombinableMatcher
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of CombinableMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + + + + + +
Methods in org.hamcrest.core that return CombinableMatcher
+ CombinableMatcher<T>CombinableMatcher.and(Matcher<? super T> other) + +
+           
+ CombinableMatcher<X>CombinableMatcher.CombinableBothMatcher.and(Matcher<? super X> other) + +
+           
+ CombinableMatcher<T>CombinableMatcher.or(Matcher<? super T> other) + +
+           
+ CombinableMatcher<X>CombinableMatcher.CombinableEitherMatcher.or(Matcher<? super X> other) + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/DescribedAs.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/DescribedAs.html new file mode 100644 index 000000000..097ed6688 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/DescribedAs.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.DescribedAs (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.DescribedAs

+
+No usage of org.hamcrest.core.DescribedAs +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/Every.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/Every.html new file mode 100644 index 000000000..ab3a804d2 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/Every.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.Every (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.Every

+
+No usage of org.hamcrest.core.Every +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/Is.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/Is.html new file mode 100644 index 000000000..9cc6c0831 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/Is.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.Is (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.Is

+
+No usage of org.hamcrest.core.Is +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsAnything.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsAnything.html new file mode 100644 index 000000000..22c10c8ca --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsAnything.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsAnything (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsAnything

+
+No usage of org.hamcrest.core.IsAnything +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsCollectionContaining.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsCollectionContaining.html new file mode 100644 index 000000000..fb54db596 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsCollectionContaining.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsCollectionContaining (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsCollectionContaining

+
+No usage of org.hamcrest.core.IsCollectionContaining +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsEqual.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsEqual.html new file mode 100644 index 000000000..d809056fe --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsEqual.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsEqual (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsEqual

+
+No usage of org.hamcrest.core.IsEqual +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsInstanceOf.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsInstanceOf.html new file mode 100644 index 000000000..776bdae0f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsInstanceOf.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsInstanceOf (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsInstanceOf

+
+No usage of org.hamcrest.core.IsInstanceOf +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNot.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNot.html new file mode 100644 index 000000000..58e54ff22 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNot.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsNot (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsNot

+
+No usage of org.hamcrest.core.IsNot +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNull.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNull.html new file mode 100644 index 000000000..467f7fec4 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsNull.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsNull (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsNull

+
+No usage of org.hamcrest.core.IsNull +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/IsSame.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsSame.html new file mode 100644 index 000000000..7d6828f5b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/IsSame.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.IsSame (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.IsSame

+
+No usage of org.hamcrest.core.IsSame +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/StringContains.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringContains.html new file mode 100644 index 000000000..b943fa212 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringContains.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.StringContains (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.StringContains

+
+No usage of org.hamcrest.core.StringContains +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/StringEndsWith.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringEndsWith.html new file mode 100644 index 000000000..aa528f8c3 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringEndsWith.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.StringEndsWith (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.StringEndsWith

+
+No usage of org.hamcrest.core.StringEndsWith +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/StringStartsWith.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringStartsWith.html new file mode 100644 index 000000000..4ad6fd675 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/StringStartsWith.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.core.StringStartsWith (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.StringStartsWith

+
+No usage of org.hamcrest.core.StringStartsWith +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/class-use/SubstringMatcher.html b/docs/javadoc/1.3/org/hamcrest/core/class-use/SubstringMatcher.html new file mode 100644 index 000000000..eb41e08df --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/class-use/SubstringMatcher.html @@ -0,0 +1,196 @@ + + + + + + +Uses of Class org.hamcrest.core.SubstringMatcher (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.core.SubstringMatcher

+
+ + + + + + + + + +
+Packages that use SubstringMatcher
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + +
+Uses of SubstringMatcher in org.hamcrest.core
+  +

+ + + + + + + + + + + + + + + + + +
Subclasses of SubstringMatcher in org.hamcrest.core
+ classStringContains + +
+          Tests if the argument is a string that contains a substring.
+ classStringEndsWith + +
+          Tests if the argument is a string that contains a substring.
+ classStringStartsWith + +
+          Tests if the argument is a string that contains a substring.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/package-frame.html b/docs/javadoc/1.3/org/hamcrest/core/package-frame.html new file mode 100644 index 000000000..f88aa74b2 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/package-frame.html @@ -0,0 +1,68 @@ + + + + + + +org.hamcrest.core (Hamcrest) + + + + + + + + + + + +org.hamcrest.core + + + + +
+Classes  + +
+AllOf +
+AnyOf +
+CombinableMatcher +
+CombinableMatcher.CombinableBothMatcher +
+CombinableMatcher.CombinableEitherMatcher +
+DescribedAs +
+Every +
+Is +
+IsAnything +
+IsCollectionContaining +
+IsEqual +
+IsInstanceOf +
+IsNot +
+IsNull +
+IsSame +
+StringContains +
+StringEndsWith +
+StringStartsWith +
+SubstringMatcher
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/package-summary.html b/docs/javadoc/1.3/org/hamcrest/core/package-summary.html new file mode 100644 index 000000000..9f7a6374f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/package-summary.html @@ -0,0 +1,246 @@ + + + + + + +org.hamcrest.core (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.core +

+Fundamental matchers of objects and values, and composite matchers. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Class Summary
AllOf<T>Calculates the logical conjunction of multiple matchers.
AnyOf<T>Calculates the logical disjunction of multiple matchers.
CombinableMatcher<T> 
CombinableMatcher.CombinableBothMatcher<X> 
CombinableMatcher.CombinableEitherMatcher<X> 
DescribedAs<T>Provides a custom description to another matcher.
Every<T> 
Is<T>Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
IsAnything<T>A matcher that always returns true.
IsCollectionContaining<T> 
IsEqual<T>Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
IsInstanceOfTests whether the value is an instance of a class.
IsNot<T>Calculates the logical negation of a matcher.
IsNull<T>Is the value null?
IsSame<T>Is the value the same object as another value?
StringContainsTests if the argument is a string that contains a substring.
StringEndsWithTests if the argument is a string that contains a substring.
StringStartsWithTests if the argument is a string that contains a substring.
SubstringMatcher 
+  + +

+

+Package org.hamcrest.core Description +

+ +

+

Fundamental matchers of objects and values, and composite matchers.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/package-tree.html b/docs/javadoc/1.3/org/hamcrest/core/package-tree.html new file mode 100644 index 000000000..c1086a5b3 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/package-tree.html @@ -0,0 +1,164 @@ + + + + + + +org.hamcrest.core Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.core +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/core/package-use.html b/docs/javadoc/1.3/org/hamcrest/core/package-use.html new file mode 100644 index 000000000..65f2c813b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/core/package-use.html @@ -0,0 +1,225 @@ + + + + + + +Uses of Package org.hamcrest.core (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.core

+
+ + + + + + + + + + + + + +
+Packages that use org.hamcrest.core
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
+  +

+ + + + + + + + + + + + + + +
+Classes in org.hamcrest.core used by org.hamcrest
AnyOf + +
+          Calculates the logical disjunction of multiple matchers.
CombinableMatcher.CombinableBothMatcher + +
+           
CombinableMatcher.CombinableEitherMatcher + +
+           
+  +

+ + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest.core used by org.hamcrest.core
AnyOf + +
+          Calculates the logical disjunction of multiple matchers.
CombinableMatcher + +
+           
CombinableMatcher.CombinableBothMatcher + +
+           
CombinableMatcher.CombinableEitherMatcher + +
+           
SubstringMatcher + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/EasyMock2Adapter.html b/docs/javadoc/1.3/org/hamcrest/integration/EasyMock2Adapter.html new file mode 100644 index 000000000..ac9206ceb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/EasyMock2Adapter.html @@ -0,0 +1,319 @@ + + + + + + +EasyMock2Adapter (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.integration +
+Class EasyMock2Adapter

+
+java.lang.Object
+  extended by org.hamcrest.integration.EasyMock2Adapter
+
+
+
All Implemented Interfaces:
org.easymock.IArgumentMatcher
+
+
+
+
public class EasyMock2Adapter
extends java.lang.Object
implements org.easymock.IArgumentMatcher
+ + +

+An adapter allowing a Hamcrest Matcher + to act as an EasyMock IArgumentMatcher. +

+ +

+

+
Author:
+
Joe Walnes
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
EasyMock2Adapter(Matcher<?> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static org.easymock.IArgumentMatcheradapt(Matcher<?> matcher) + +
+          Convenience factory method that will adapt a + Hamcrest Matcher to act as an + EasyMock IArgumentMatcher and + report it to EasyMock so it can be kept track of.
+ voidappendTo(java.lang.StringBuffer buffer) + +
+           
+ booleanmatches(java.lang.Object argument) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+EasyMock2Adapter

+
+public EasyMock2Adapter(Matcher<?> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+adapt

+
+public static org.easymock.IArgumentMatcher adapt(Matcher<?> matcher)
+
+
Convenience factory method that will adapt a + Hamcrest Matcher to act as an + EasyMock IArgumentMatcher and + report it to EasyMock so it can be kept track of. +

+

+
+
+
+
+
+
+
+ +

+matches

+
+public boolean matches(java.lang.Object argument)
+
+
+
Specified by:
matches in interface org.easymock.IArgumentMatcher
+
+
+
+
+
+
+ +

+appendTo

+
+public void appendTo(java.lang.StringBuffer buffer)
+
+
+
Specified by:
appendTo in interface org.easymock.IArgumentMatcher
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/JMock1Adapter.html b/docs/javadoc/1.3/org/hamcrest/integration/JMock1Adapter.html new file mode 100644 index 000000000..5ecf2eaad --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/JMock1Adapter.html @@ -0,0 +1,319 @@ + + + + + + +JMock1Adapter (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.integration +
+Class JMock1Adapter

+
+java.lang.Object
+  extended by org.hamcrest.integration.JMock1Adapter
+
+
+
All Implemented Interfaces:
org.jmock.core.Constraint, org.jmock.core.SelfDescribing
+
+
+
+
public class JMock1Adapter
extends java.lang.Object
implements org.jmock.core.Constraint
+ + +

+An adapter allowing a Hamcrest Matcher + to act as an jMock1 Constraint. + Note, this is not necessary for jMock2 as it supports Hamcrest + out of the box. +

+ +

+

+
Author:
+
Joe Walnes
+
+
+ +

+ + + + + + + + + + + +
+Constructor Summary
JMock1Adapter(Matcher<?> matcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static org.jmock.core.Constraintadapt(Matcher<?> matcher) + +
+          Convenience factory method that will adapt a + Hamcrest Matcher to act as an + jMock Constraint.
+ java.lang.StringBufferdescribeTo(java.lang.StringBuffer buffer) + +
+           
+ booleaneval(java.lang.Object o) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+JMock1Adapter

+
+public JMock1Adapter(Matcher<?> matcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+adapt

+
+public static org.jmock.core.Constraint adapt(Matcher<?> matcher)
+
+
Convenience factory method that will adapt a + Hamcrest Matcher to act as an + jMock Constraint. +

+

+
+
+
+
+
+
+
+ +

+eval

+
+public boolean eval(java.lang.Object o)
+
+
+
Specified by:
eval in interface org.jmock.core.Constraint
+
+
+
+
+
+
+ +

+describeTo

+
+public java.lang.StringBuffer describeTo(java.lang.StringBuffer buffer)
+
+
+
Specified by:
describeTo in interface org.jmock.core.SelfDescribing
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/class-use/EasyMock2Adapter.html b/docs/javadoc/1.3/org/hamcrest/integration/class-use/EasyMock2Adapter.html new file mode 100644 index 000000000..213ea095b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/class-use/EasyMock2Adapter.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.integration.EasyMock2Adapter (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.integration.EasyMock2Adapter

+
+No usage of org.hamcrest.integration.EasyMock2Adapter +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/class-use/JMock1Adapter.html b/docs/javadoc/1.3/org/hamcrest/integration/class-use/JMock1Adapter.html new file mode 100644 index 000000000..bbf520631 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/class-use/JMock1Adapter.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.integration.JMock1Adapter (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.integration.JMock1Adapter

+
+No usage of org.hamcrest.integration.JMock1Adapter +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/package-frame.html b/docs/javadoc/1.3/org/hamcrest/integration/package-frame.html new file mode 100644 index 000000000..f4df61ced --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/package-frame.html @@ -0,0 +1,34 @@ + + + + + + +org.hamcrest.integration (Hamcrest) + + + + + + + + + + + +org.hamcrest.integration + + + + +
+Classes  + +
+EasyMock2Adapter +
+JMock1Adapter
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/package-summary.html b/docs/javadoc/1.3/org/hamcrest/integration/package-summary.html new file mode 100644 index 000000000..60220711c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/package-summary.html @@ -0,0 +1,163 @@ + + + + + + +org.hamcrest.integration (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.integration +

+ + + + + + + + + + + + + +
+Class Summary
EasyMock2AdapterAn adapter allowing a Hamcrest Matcher + to act as an EasyMock IArgumentMatcher.
JMock1AdapterAn adapter allowing a Hamcrest Matcher + to act as an jMock1 Constraint.
+  + +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/package-tree.html b/docs/javadoc/1.3/org/hamcrest/integration/package-tree.html new file mode 100644 index 000000000..c51cd3159 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/package-tree.html @@ -0,0 +1,155 @@ + + + + + + +org.hamcrest.integration Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.integration +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+
    +
  • java.lang.Object
      +
    • org.hamcrest.integration.EasyMock2Adapter (implements org.easymock.IArgumentMatcher) +
    • org.hamcrest.integration.JMock1Adapter (implements org.jmock.core.Constraint) +
    +
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/integration/package-use.html b/docs/javadoc/1.3/org/hamcrest/integration/package-use.html new file mode 100644 index 000000000..5acbf1cda --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/integration/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.integration (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.integration

+
+No usage of org.hamcrest.integration +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/ArrayIterator.html b/docs/javadoc/1.3/org/hamcrest/internal/ArrayIterator.html new file mode 100644 index 000000000..ca7fb70f2 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/ArrayIterator.html @@ -0,0 +1,302 @@ + + + + + + +ArrayIterator (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.internal +
+Class ArrayIterator

+
+java.lang.Object
+  extended by org.hamcrest.internal.ArrayIterator
+
+
+
All Implemented Interfaces:
java.util.Iterator<java.lang.Object>
+
+
+
+
public class ArrayIterator
extends java.lang.Object
implements java.util.Iterator<java.lang.Object>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
ArrayIterator(java.lang.Object array) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ booleanhasNext() + +
+           
+ java.lang.Objectnext() + +
+           
+ voidremove() + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+ArrayIterator

+
+public ArrayIterator(java.lang.Object array)
+
+
+ + + + + + + + +
+Method Detail
+ +

+hasNext

+
+public boolean hasNext()
+
+
+
Specified by:
hasNext in interface java.util.Iterator<java.lang.Object>
+
+
+
+
+
+
+ +

+next

+
+public java.lang.Object next()
+
+
+
Specified by:
next in interface java.util.Iterator<java.lang.Object>
+
+
+
+
+
+
+ +

+remove

+
+public void remove()
+
+
+
Specified by:
remove in interface java.util.Iterator<java.lang.Object>
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/ReflectiveTypeFinder.html b/docs/javadoc/1.3/org/hamcrest/internal/ReflectiveTypeFinder.html new file mode 100644 index 000000000..75c3746e8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/ReflectiveTypeFinder.html @@ -0,0 +1,296 @@ + + + + + + +ReflectiveTypeFinder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.internal +
+Class ReflectiveTypeFinder

+
+java.lang.Object
+  extended by org.hamcrest.internal.ReflectiveTypeFinder
+
+
+
+
public class ReflectiveTypeFinder
extends java.lang.Object
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
ReflectiveTypeFinder(java.lang.String methodName, + int expectedNumberOfParameters, + int typedParameter) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  booleancanObtainExpectedTypeFrom(java.lang.reflect.Method method) + +
+           
+protected  java.lang.Class<?>expectedTypeFrom(java.lang.reflect.Method method) + +
+           
+ java.lang.Class<?>findExpectedType(java.lang.Class<?> fromClass) + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+ReflectiveTypeFinder

+
+public ReflectiveTypeFinder(java.lang.String methodName,
+                            int expectedNumberOfParameters,
+                            int typedParameter)
+
+
+ + + + + + + + +
+Method Detail
+ +

+findExpectedType

+
+public java.lang.Class<?> findExpectedType(java.lang.Class<?> fromClass)
+
+
+
+
+
+
+ +

+canObtainExpectedTypeFrom

+
+protected boolean canObtainExpectedTypeFrom(java.lang.reflect.Method method)
+
+
+
Parameters:
method - The method to examine. +
Returns:
true if this method references the relevant type
+
+
+
+ +

+expectedTypeFrom

+
+protected java.lang.Class<?> expectedTypeFrom(java.lang.reflect.Method method)
+
+
+
Parameters:
method - The method from which to extract +
Returns:
The type we're looking for
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValue.html b/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValue.html new file mode 100644 index 000000000..f3b2f0448 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValue.html @@ -0,0 +1,263 @@ + + + + + + +SelfDescribingValue (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.internal +
+Class SelfDescribingValue<T>

+
+java.lang.Object
+  extended by org.hamcrest.internal.SelfDescribingValue<T>
+
+
+
All Implemented Interfaces:
SelfDescribing
+
+
+
+
public class SelfDescribingValue<T>
extends java.lang.Object
implements SelfDescribing
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
SelfDescribingValue(T value) + +
+           
+  + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+SelfDescribingValue

+
+public SelfDescribingValue(T value)
+
+
+ + + + + + + + +
+Method Detail
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Specified by:
describeTo in interface SelfDescribing
+
+
+
Parameters:
description - The description to be built or appended to.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValueIterator.html b/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValueIterator.html new file mode 100644 index 000000000..a5274b34b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/SelfDescribingValueIterator.html @@ -0,0 +1,302 @@ + + + + + + +SelfDescribingValueIterator (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.internal +
+Class SelfDescribingValueIterator<T>

+
+java.lang.Object
+  extended by org.hamcrest.internal.SelfDescribingValueIterator<T>
+
+
+
All Implemented Interfaces:
java.util.Iterator<SelfDescribing>
+
+
+
+
public class SelfDescribingValueIterator<T>
extends java.lang.Object
implements java.util.Iterator<SelfDescribing>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
SelfDescribingValueIterator(java.util.Iterator<T> values) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ booleanhasNext() + +
+           
+ SelfDescribingnext() + +
+           
+ voidremove() + +
+           
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+SelfDescribingValueIterator

+
+public SelfDescribingValueIterator(java.util.Iterator<T> values)
+
+
+ + + + + + + + +
+Method Detail
+ +

+hasNext

+
+public boolean hasNext()
+
+
+
Specified by:
hasNext in interface java.util.Iterator<SelfDescribing>
+
+
+
+
+
+
+ +

+next

+
+public SelfDescribing next()
+
+
+
Specified by:
next in interface java.util.Iterator<SelfDescribing>
+
+
+
+
+
+
+ +

+remove

+
+public void remove()
+
+
+
Specified by:
remove in interface java.util.Iterator<SelfDescribing>
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/class-use/ArrayIterator.html b/docs/javadoc/1.3/org/hamcrest/internal/class-use/ArrayIterator.html new file mode 100644 index 000000000..580dc79f6 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/class-use/ArrayIterator.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.internal.ArrayIterator (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.internal.ArrayIterator

+
+No usage of org.hamcrest.internal.ArrayIterator +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/class-use/ReflectiveTypeFinder.html b/docs/javadoc/1.3/org/hamcrest/internal/class-use/ReflectiveTypeFinder.html new file mode 100644 index 000000000..cb3d2f58f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/class-use/ReflectiveTypeFinder.html @@ -0,0 +1,186 @@ + + + + + + +Uses of Class org.hamcrest.internal.ReflectiveTypeFinder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.internal.ReflectiveTypeFinder

+
+ + + + + + + + + +
+Packages that use ReflectiveTypeFinder
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
+  +

+ + + + + +
+Uses of ReflectiveTypeFinder in org.hamcrest
+  +

+ + + + + + + + + + + +
Constructors in org.hamcrest with parameters of type ReflectiveTypeFinder
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
TypeSafeMatcher(ReflectiveTypeFinder typeFinder) + +
+          Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValue.html b/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValue.html new file mode 100644 index 000000000..0e048cce7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValue.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.internal.SelfDescribingValue (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.internal.SelfDescribingValue

+
+No usage of org.hamcrest.internal.SelfDescribingValue +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValueIterator.html b/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValueIterator.html new file mode 100644 index 000000000..851d2f413 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/class-use/SelfDescribingValueIterator.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.internal.SelfDescribingValueIterator (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.internal.SelfDescribingValueIterator

+
+No usage of org.hamcrest.internal.SelfDescribingValueIterator +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/package-frame.html b/docs/javadoc/1.3/org/hamcrest/internal/package-frame.html new file mode 100644 index 000000000..b5d9e134d --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/package-frame.html @@ -0,0 +1,38 @@ + + + + + + +org.hamcrest.internal (Hamcrest) + + + + + + + + + + + +org.hamcrest.internal + + + + +
+Classes  + +
+ArrayIterator +
+ReflectiveTypeFinder +
+SelfDescribingValue +
+SelfDescribingValueIterator
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/package-summary.html b/docs/javadoc/1.3/org/hamcrest/internal/package-summary.html new file mode 100644 index 000000000..af143cac2 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/package-summary.html @@ -0,0 +1,169 @@ + + + + + + +org.hamcrest.internal (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.internal +

+ + + + + + + + + + + + + + + + + + + + + +
+Class Summary
ArrayIterator 
ReflectiveTypeFinder 
SelfDescribingValue<T> 
SelfDescribingValueIterator<T> 
+  + +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/package-tree.html b/docs/javadoc/1.3/org/hamcrest/internal/package-tree.html new file mode 100644 index 000000000..56218ccee --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/package-tree.html @@ -0,0 +1,156 @@ + + + + + + +org.hamcrest.internal Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.internal +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/internal/package-use.html b/docs/javadoc/1.3/org/hamcrest/internal/package-use.html new file mode 100644 index 000000000..8d374ed7b --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/internal/package-use.html @@ -0,0 +1,170 @@ + + + + + + +Uses of Package org.hamcrest.internal (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.internal

+
+ + + + + + + + + +
+Packages that use org.hamcrest.internal
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
+  +

+ + + + + + + + +
+Classes in org.hamcrest.internal used by org.hamcrest
ReflectiveTypeFinder + +
+           
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/BigDecimalCloseTo.html b/docs/javadoc/1.3/org/hamcrest/number/BigDecimalCloseTo.html new file mode 100644 index 000000000..01a463290 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/BigDecimalCloseTo.html @@ -0,0 +1,365 @@ + + + + + + +BigDecimalCloseTo (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.number +
+Class BigDecimalCloseTo

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.math.BigDecimal>
+          extended by org.hamcrest.number.BigDecimalCloseTo
+
+
+
All Implemented Interfaces:
Matcher<java.math.BigDecimal>, SelfDescribing
+
+
+
+
public class BigDecimalCloseTo
extends TypeSafeMatcher<java.math.BigDecimal>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
BigDecimalCloseTo(java.math.BigDecimal value, + java.math.BigDecimal error) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static Matcher<java.math.BigDecimal>closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) + +
+          Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+ voiddescribeMismatchSafely(java.math.BigDecimal item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(java.math.BigDecimal item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+BigDecimalCloseTo

+
+public BigDecimalCloseTo(java.math.BigDecimal value,
+                         java.math.BigDecimal error)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.math.BigDecimal item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.math.BigDecimal>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.math.BigDecimal item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.math.BigDecimal>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+closeTo

+
+public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
+                                                    java.math.BigDecimal error)
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. +

+ For example: +

assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
+

+

+
Parameters:
operand - the expected value of matching BigDecimals
error - the delta (+/-) within which matches will be allowed
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/IsCloseTo.html b/docs/javadoc/1.3/org/hamcrest/number/IsCloseTo.html new file mode 100644 index 000000000..2205eac5a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/IsCloseTo.html @@ -0,0 +1,369 @@ + + + + + + +IsCloseTo (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.number +
+Class IsCloseTo

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.Double>
+          extended by org.hamcrest.number.IsCloseTo
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Double>, SelfDescribing
+
+
+
+
public class IsCloseTo
extends TypeSafeMatcher<java.lang.Double>
+ + +

+Is the value a number equal to a value within some range of + acceptable error? +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsCloseTo(double value, + double error) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static Matcher<java.lang.Double>closeTo(double operand, + double error) + +
+          Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+ voiddescribeMismatchSafely(java.lang.Double item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(java.lang.Double item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsCloseTo

+
+public IsCloseTo(double value,
+                 double error)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.Double item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.Double>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.Double item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+closeTo

+
+public static Matcher<java.lang.Double> closeTo(double operand,
+                                                double error)
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. +

+ For example: +

assertThat(1.03, is(closeTo(1.0, 0.03)))
+

+

+
Parameters:
operand - the expected value of matching doubles
error - the delta (+/-) within which matches will be allowed
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/OrderingComparison.html b/docs/javadoc/1.3/org/hamcrest/number/OrderingComparison.html new file mode 100644 index 000000000..ec239d0df --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/OrderingComparison.html @@ -0,0 +1,490 @@ + + + + + + +OrderingComparison (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.number +
+Class OrderingComparison<T extends java.lang.Comparable<T>>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<T>
+          extended by org.hamcrest.number.OrderingComparison<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class OrderingComparison<T extends java.lang.Comparable<T>>
extends TypeSafeMatcher<T>
+ + +

+


+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
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.
+ voiddescribeMismatchSafely(T actual, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static + + + + +
+<T extends java.lang.Comparable<T>> +
+Matcher<T>
+
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>
+
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>
+
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>
+
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.
+ booleanmatchesSafely(T actual) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(T actual)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<T extends java.lang.Comparable<T>>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(T actual,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<T extends java.lang.Comparable<T>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+comparesEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, comparesEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return zero
+
+
+
+ +

+greaterThan

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(2, greaterThan(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
+
+
+
+ +

+greaterThanOrEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, greaterThanOrEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
+
+
+
+ +

+lessThan

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, lessThan(2))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
+
+
+
+ +

+lessThanOrEqualTo

+
+public static <T extends java.lang.Comparable<T>> Matcher<T> 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. +

+ For example: +

assertThat(1, lessThanOrEqualTo(1))
+

+

+
Parameters:
value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/class-use/BigDecimalCloseTo.html b/docs/javadoc/1.3/org/hamcrest/number/class-use/BigDecimalCloseTo.html new file mode 100644 index 000000000..3b1cab5fd --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/class-use/BigDecimalCloseTo.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.number.BigDecimalCloseTo (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.number.BigDecimalCloseTo

+
+No usage of org.hamcrest.number.BigDecimalCloseTo +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/class-use/IsCloseTo.html b/docs/javadoc/1.3/org/hamcrest/number/class-use/IsCloseTo.html new file mode 100644 index 000000000..24e4fb982 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/class-use/IsCloseTo.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.number.IsCloseTo (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.number.IsCloseTo

+
+No usage of org.hamcrest.number.IsCloseTo +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/class-use/OrderingComparison.html b/docs/javadoc/1.3/org/hamcrest/number/class-use/OrderingComparison.html new file mode 100644 index 000000000..e9e569e91 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/class-use/OrderingComparison.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.number.OrderingComparison (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.number.OrderingComparison

+
+No usage of org.hamcrest.number.OrderingComparison +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/package-frame.html b/docs/javadoc/1.3/org/hamcrest/number/package-frame.html new file mode 100644 index 000000000..b92ecd4b9 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/package-frame.html @@ -0,0 +1,36 @@ + + + + + + +org.hamcrest.number (Hamcrest) + + + + + + + + + + + +org.hamcrest.number + + + + +
+Classes  + +
+BigDecimalCloseTo +
+IsCloseTo +
+OrderingComparison
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/package-summary.html b/docs/javadoc/1.3/org/hamcrest/number/package-summary.html new file mode 100644 index 000000000..2abe5f4da --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/package-summary.html @@ -0,0 +1,181 @@ + + + + + + +org.hamcrest.number (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.number +

+Matchers that perform numeric comparisons. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + +
+Class Summary
BigDecimalCloseTo 
IsCloseToIs the value a number equal to a value within some range of + acceptable error?
OrderingComparison<T extends Comparable<T>> 
+  + +

+

+Package org.hamcrest.number Description +

+ +

+

Matchers that perform numeric comparisons.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/package-tree.html b/docs/javadoc/1.3/org/hamcrest/number/package-tree.html new file mode 100644 index 000000000..2ce536feb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/package-tree.html @@ -0,0 +1,158 @@ + + + + + + +org.hamcrest.number Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.number +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/number/package-use.html b/docs/javadoc/1.3/org/hamcrest/number/package-use.html new file mode 100644 index 000000000..d14fd8e37 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/number/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.number (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.number

+
+No usage of org.hamcrest.number +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/HasToString.html b/docs/javadoc/1.3/org/hamcrest/object/HasToString.html new file mode 100644 index 000000000..ea040a70f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/HasToString.html @@ -0,0 +1,358 @@ + + + + + + +HasToString (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.object +
+Class HasToString<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<T>
+          extended by org.hamcrest.FeatureMatcher<T,java.lang.String>
+              extended by org.hamcrest.object.HasToString<T>
+
+
+
All Implemented Interfaces:
Matcher<T>, SelfDescribing
+
+
+
+
public class HasToString<T>
extends FeatureMatcher<T,java.lang.String>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
HasToString(Matcher<? super java.lang.String> toStringMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+protected  java.lang.StringfeatureValueOf(T actual) + +
+          Implement this to extract the interesting feature.
+static + + + + +
+<T> Matcher<T>
+
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(java.lang.String expectedToString) + +
+          Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+ + + + + + + +
Methods inherited from class org.hamcrest.FeatureMatcher
describeTo, matchesSafely
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+HasToString

+
+public HasToString(Matcher<? super java.lang.String> toStringMatcher)
+
+
+ + + + + + + + +
+Method Detail
+ +

+featureValueOf

+
+protected java.lang.String featureValueOf(T actual)
+
+
Description copied from class: FeatureMatcher
+
Implement this to extract the interesting feature. +

+

+
Specified by:
featureValueOf in class FeatureMatcher<T,java.lang.String>
+
+
+
Parameters:
actual - the target object +
Returns:
the feature to be matched
+
+
+
+ +

+hasToString

+
+public static <T> Matcher<T> 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. +

+ For example: +

assertThat(true, hasToString(equalTo("TRUE")))
+

+

+
Parameters:
toStringMatcher - the matcher used to verify the toString result
+
+
+
+ +

+hasToString

+
+public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. +

+ For example: +

assertThat(true, hasToString("TRUE"))
+

+

+
Parameters:
expectedToString - the expected toString result
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/IsCompatibleType.html b/docs/javadoc/1.3/org/hamcrest/object/IsCompatibleType.html new file mode 100644 index 000000000..551240bc8 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/IsCompatibleType.html @@ -0,0 +1,367 @@ + + + + + + +IsCompatibleType (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.object +
+Class IsCompatibleType<T>

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.Class<?>>
+          extended by org.hamcrest.object.IsCompatibleType<T>
+
+
+
All Implemented Interfaces:
Matcher<java.lang.Class<?>>, SelfDescribing
+
+
+
+
public class IsCompatibleType<T>
extends TypeSafeMatcher<java.lang.Class<?>>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsCompatibleType(java.lang.Class<T> type) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.Class<?> cls, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(java.lang.Class<?> cls) + +
+          Subclasses should implement this.
+static + + + + +
+<T> Matcher<java.lang.Class<?>>
+
typeCompatibleWith(java.lang.Class<T> baseType) + +
+          Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsCompatibleType

+
+public IsCompatibleType(java.lang.Class<T> type)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.Class<?> cls)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.Class<?>>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.Class<?> cls,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.Class<?>>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+typeCompatibleWith

+
+public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. +

+ For example: +

assertThat(Integer.class, typeCompatibleWith(Number.class))
+

+

+
Parameters:
baseType - the base class to examine classes against
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/IsEventFrom.html b/docs/javadoc/1.3/org/hamcrest/object/IsEventFrom.html new file mode 100644 index 000000000..b5a9e8c3a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/IsEventFrom.html @@ -0,0 +1,368 @@ + + + + + + +IsEventFrom (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.object +
+Class IsEventFrom

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<java.util.EventObject>
+          extended by org.hamcrest.object.IsEventFrom
+
+
+
All Implemented Interfaces:
Matcher<java.util.EventObject>, SelfDescribing
+
+
+
+
public class IsEventFrom
extends TypeSafeDiagnosingMatcher<java.util.EventObject>
+ + +

+Tests if the value is an event announced by a specific object. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEventFrom(java.lang.Class<?> eventClass, + java.lang.Object source) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static Matcher<java.util.EventObject>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>eventFrom(java.lang.Object source) + +
+          Creates a matcher of EventObject that matches any EventObject + announced by source.
+ booleanmatchesSafely(java.util.EventObject item, + Description mismatchDescription) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEventFrom

+
+public IsEventFrom(java.lang.Class<?> eventClass,
+                   java.lang.Object source)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.util.EventObject item,
+                             Description mismatchDescription)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<java.util.EventObject>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+eventFrom

+
+public static Matcher<java.util.EventObject> 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. +

+ For example: +
assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
+

+

+
Parameters:
eventClass - the class of the event to match on
source - the source of the event
+
+
+
+ +

+eventFrom

+
+public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source. +

+ For example: +
assertThat(myEvent, is(eventFrom(myBean)))
+

+

+
Parameters:
source - the source of the event
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/class-use/HasToString.html b/docs/javadoc/1.3/org/hamcrest/object/class-use/HasToString.html new file mode 100644 index 000000000..8a22d2ed1 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/class-use/HasToString.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.object.HasToString (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.object.HasToString

+
+No usage of org.hamcrest.object.HasToString +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/class-use/IsCompatibleType.html b/docs/javadoc/1.3/org/hamcrest/object/class-use/IsCompatibleType.html new file mode 100644 index 000000000..6b665fa08 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/class-use/IsCompatibleType.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.object.IsCompatibleType (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.object.IsCompatibleType

+
+No usage of org.hamcrest.object.IsCompatibleType +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/class-use/IsEventFrom.html b/docs/javadoc/1.3/org/hamcrest/object/class-use/IsEventFrom.html new file mode 100644 index 000000000..8d105e599 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/class-use/IsEventFrom.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.object.IsEventFrom (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.object.IsEventFrom

+
+No usage of org.hamcrest.object.IsEventFrom +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/package-frame.html b/docs/javadoc/1.3/org/hamcrest/object/package-frame.html new file mode 100644 index 000000000..3126333ec --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/package-frame.html @@ -0,0 +1,36 @@ + + + + + + +org.hamcrest.object (Hamcrest) + + + + + + + + + + + +org.hamcrest.object + + + + +
+Classes  + +
+HasToString +
+IsCompatibleType +
+IsEventFrom
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/package-summary.html b/docs/javadoc/1.3/org/hamcrest/object/package-summary.html new file mode 100644 index 000000000..bdc3b7c58 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/package-summary.html @@ -0,0 +1,180 @@ + + + + + + +org.hamcrest.object (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.object +

+Matchers that inspect objects and classes. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + +
+Class Summary
HasToString<T> 
IsCompatibleType<T> 
IsEventFromTests if the value is an event announced by a specific object.
+  + +

+

+Package org.hamcrest.object Description +

+ +

+

Matchers that inspect objects and classes.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/package-tree.html b/docs/javadoc/1.3/org/hamcrest/object/package-tree.html new file mode 100644 index 000000000..c26d34a16 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/package-tree.html @@ -0,0 +1,162 @@ + + + + + + +org.hamcrest.object Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.object +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/object/package-use.html b/docs/javadoc/1.3/org/hamcrest/object/package-use.html new file mode 100644 index 000000000..d732786e9 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/object/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.object (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.object

+
+No usage of org.hamcrest.object +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/package-frame.html b/docs/javadoc/1.3/org/hamcrest/package-frame.html new file mode 100644 index 000000000..ff625e453 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/package-frame.html @@ -0,0 +1,92 @@ + + + + + + +org.hamcrest (Hamcrest) + + + + + + + + + + + +org.hamcrest + + + + +
+Interfaces  + +
+Condition.Step +
+Description +
+Matcher +
+SelfDescribing
+ + + + + + +
+Classes  + +
+BaseDescription +
+BaseMatcher +
+Condition +
+CoreMatchers +
+CustomMatcher +
+CustomTypeSafeMatcher +
+Description.NullDescription +
+DiagnosingMatcher +
+EasyMock2Matchers +
+FeatureMatcher +
+JavaLangMatcherAssert +
+JMock1Matchers +
+MatcherAssert +
+Matchers +
+StringDescription +
+TypeSafeDiagnosingMatcher +
+TypeSafeMatcher
+ + + + + + +
+Annotation Types  + +
+Factory
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/package-summary.html b/docs/javadoc/1.3/org/hamcrest/package-summary.html new file mode 100644 index 000000000..93aa5d7eb --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/package-summary.html @@ -0,0 +1,279 @@ + + + + + + +org.hamcrest (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest +

+The stable API defining Matcher and its associated interfaces and classes. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + + + + + +
+Interface Summary
Condition.Step<I,O> 
DescriptionA description of a Matcher.
Matcher<T>A matcher over acceptable values.
SelfDescribingThe ability of an object to describe itself.
+  + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Class Summary
BaseDescriptionA Description that is stored as a string.
BaseMatcher<T>BaseClass for all Matcher implementations.
Condition<T>A Condition implements part of a multi-step match.
CoreMatchers 
CustomMatcher<T>Utility class for writing one off matchers.
CustomTypeSafeMatcher<T>Utility class for writing one off matchers.
Description.NullDescription 
DiagnosingMatcher<T>TODO(ngd): Document.
EasyMock2Matchers 
FeatureMatcher<T,U>Supporting class for matching a feature of an object.
JavaLangMatcherAssertIntegration method for use with Java's assert keyword.
JMock1Matchers 
MatcherAssert 
Matchers 
StringDescriptionA Description that is stored as a string.
TypeSafeDiagnosingMatcher<T>Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher<T>Convenient base class for Matchers that require a non-null value of a specific type.
+  + +

+ + + + + + + + + +
+Annotation Types Summary
FactoryMarks a Hamcrest static factory method so tools recognise them.
+  + +

+

+Package org.hamcrest Description +

+ +

+

The stable API defining Matcher and its associated interfaces and classes. + Hamcrest sub-projects define their convenience classes in the org.hamcrest package. +

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/package-tree.html b/docs/javadoc/1.3/org/hamcrest/package-tree.html new file mode 100644 index 000000000..83aaa1aea --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/package-tree.html @@ -0,0 +1,177 @@ + + + + + + +org.hamcrest Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +

+Interface Hierarchy +

+ +

+Annotation Type Hierarchy +

+
    +
  • org.hamcrest.Factory (implements java.lang.annotation.Annotation) +
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/package-use.html b/docs/javadoc/1.3/org/hamcrest/package-use.html new file mode 100644 index 000000000..d014b5bc4 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/package-use.html @@ -0,0 +1,659 @@ + + + + + + +Uses of Package org.hamcrest (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Packages that use org.hamcrest
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes. 
org.hamcrest.beansMatchers of Java Bean properties and their values. 
org.hamcrest.collectionMatchers of arrays and collections. 
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers. 
org.hamcrest.integration  
org.hamcrest.internal  
org.hamcrest.numberMatchers that perform numeric comparisons. 
org.hamcrest.objectMatchers that inspect objects and classes. 
org.hamcrest.textMatchers that perform text comparisons. 
org.hamcrest.xmlMatchers of XML documents. 
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest
BaseDescription + +
+          A Description that is stored as a string.
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Condition + +
+          A Condition implements part of a multi-step match.
Condition.Step + +
+           
Description + +
+          A description of a Matcher.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.beans
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
DiagnosingMatcher + +
+          TODO(ngd): Document.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.collection
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
FeatureMatcher + +
+          Supporting class for matching a feature of an object.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.core
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
DiagnosingMatcher + +
+          TODO(ngd): Document.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.integration
Matcher + +
+          A matcher over acceptable values.
+  +

+ + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.internal
Description + +
+          A description of a Matcher.
SelfDescribing + +
+          The ability of an object to describe itself.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.number
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.object
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
FeatureMatcher + +
+          Supporting class for matching a feature of an object.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.text
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type.
+  +

+ + + + + + + + + + + + + + + + + + + + + + + +
+Classes in org.hamcrest used by org.hamcrest.xml
BaseMatcher + +
+          BaseClass for all Matcher implementations.
Description + +
+          A description of a Matcher.
Factory + +
+          Marks a Hamcrest static factory method so tools recognise them.
Matcher + +
+          A matcher over acceptable values.
SelfDescribing + +
+          The ability of an object to describe itself.
TypeSafeDiagnosingMatcher + +
+          Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+  +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/IsEmptyString.html b/docs/javadoc/1.3/org/hamcrest/text/IsEmptyString.html new file mode 100644 index 000000000..d11d4467c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/IsEmptyString.html @@ -0,0 +1,352 @@ + + + + + + +IsEmptyString (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.text +
+Class IsEmptyString

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<java.lang.String>
+      extended by org.hamcrest.text.IsEmptyString
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public final class IsEmptyString
extends BaseMatcher<java.lang.String>
+ + +

+Matches empty Strings (and null). +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEmptyString() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static Matcher<java.lang.String>isEmptyOrNullString() + +
+          Creates a matcher of String that matches when the examined string is null, or + has zero length.
+static Matcher<java.lang.String>isEmptyString() + +
+          Creates a matcher of String that matches when the examined string has zero length.
+ booleanmatches(java.lang.Object item) + +
+          Evaluates the matcher for argument item.
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, describeMismatch, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEmptyString

+
+public IsEmptyString()
+
+
+ + + + + + + + +
+Method Detail
+ +

+matches

+
+public boolean matches(java.lang.Object item)
+
+
Description copied from interface: Matcher
+
Evaluates the matcher for argument item. +

+ This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type. +

+

+
Parameters:
item - the object against which the matcher is evaluated. +
Returns:
true if item matches, otherwise false.
See Also:
BaseMatcher
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+isEmptyString

+
+public static Matcher<java.lang.String> isEmptyString()
+
+
Creates a matcher of String that matches when the examined string has zero length. +

+ For example: +

assertThat("", isEmptyString())
+

+

+
+
+
+
+ +

+isEmptyOrNullString

+
+public static Matcher<java.lang.String> isEmptyOrNullString()
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length. +

+ For example: +

assertThat(((String)null), isEmptyString())
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringCase.html b/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringCase.html new file mode 100644 index 000000000..6eb7aa6b0 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringCase.html @@ -0,0 +1,364 @@ + + + + + + +IsEqualIgnoringCase (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.text +
+Class IsEqualIgnoringCase

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.text.IsEqualIgnoringCase
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class IsEqualIgnoringCase
extends TypeSafeMatcher<java.lang.String>
+ + +

+Tests if a string is equal to another string, regardless of the case. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEqualIgnoringCase(java.lang.String string) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static Matcher<java.lang.String>equalToIgnoringCase(java.lang.String expectedString) + +
+          Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+ booleanmatchesSafely(java.lang.String item) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEqualIgnoringCase

+
+public IsEqualIgnoringCase(java.lang.String string)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.String item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.String item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+equalToIgnoringCase

+
+public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. +

+ For example: +

assertThat("Foo", equalToIgnoringCase("FOO"))
+

+

+
Parameters:
expectedString - the expected value of matched strings
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html b/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html new file mode 100644 index 000000000..b03ce3ba1 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html @@ -0,0 +1,388 @@ + + + + + + +IsEqualIgnoringWhiteSpace (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.text +
+Class IsEqualIgnoringWhiteSpace

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class IsEqualIgnoringWhiteSpace
extends TypeSafeMatcher<java.lang.String>
+ + +

+Tests if a string is equal to another string, ignoring any changes in whitespace. +

+ +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
IsEqualIgnoringWhiteSpace(java.lang.String string) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static Matcher<java.lang.String>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.
+ booleanmatchesSafely(java.lang.String item) + +
+          Subclasses should implement this.
+ java.lang.StringstripSpace(java.lang.String toBeStripped) + +
+           
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+IsEqualIgnoringWhiteSpace

+
+public IsEqualIgnoringWhiteSpace(java.lang.String string)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.String item)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.String item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+stripSpace

+
+public java.lang.String stripSpace(java.lang.String toBeStripped)
+
+
+
+
+
+
+ +

+equalToIgnoringWhiteSpace

+
+public static Matcher<java.lang.String> 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. To be + exact, the following whitespace rules are applied: +
    +
  • all leading and trailing whitespace of both the expectedString and the examined string are ignored
  • +
  • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
  • +
+

+ For example: +

assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
+

+

+
Parameters:
expectedString - the expected value of matched strings
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/StringContainsInOrder.html b/docs/javadoc/1.3/org/hamcrest/text/StringContainsInOrder.html new file mode 100644 index 000000000..0c9ccf4fe --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/StringContainsInOrder.html @@ -0,0 +1,360 @@ + + + + + + +StringContainsInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.text +
+Class StringContainsInOrder

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeMatcher<java.lang.String>
+          extended by org.hamcrest.text.StringContainsInOrder
+
+
+
All Implemented Interfaces:
Matcher<java.lang.String>, SelfDescribing
+
+
+
+
public class StringContainsInOrder
extends TypeSafeMatcher<java.lang.String>
+ + +

+


+ +

+ + + + + + + + + + + +
+Constructor Summary
StringContainsInOrder(java.lang.Iterable<java.lang.String> substrings) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeMismatchSafely(java.lang.String item, + Description mismatchDescription) + +
+          Subclasses should override this.
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+ booleanmatchesSafely(java.lang.String s) + +
+          Subclasses should implement this.
+static Matcher<java.lang.String>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.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+StringContainsInOrder

+
+public StringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
+
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(java.lang.String s)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should implement this. The item will already have been checked for + the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeMismatchSafely

+
+public void describeMismatchSafely(java.lang.String item,
+                                   Description mismatchDescription)
+
+
Description copied from class: TypeSafeMatcher
+
Subclasses should override this. The item will already have been checked for + the specific type and will never be null. +

+

+
Overrides:
describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+stringContainsInOrder

+
+public static Matcher<java.lang.String> 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. +

+ For example: +

assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
+

+

+
Parameters:
substrings - the substrings that must be contained within matching strings
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEmptyString.html b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEmptyString.html new file mode 100644 index 000000000..d8000a8c1 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEmptyString.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.text.IsEmptyString (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.text.IsEmptyString

+
+No usage of org.hamcrest.text.IsEmptyString +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringCase.html b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringCase.html new file mode 100644 index 000000000..4aaf3fbb7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringCase.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.text.IsEqualIgnoringCase (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.text.IsEqualIgnoringCase

+
+No usage of org.hamcrest.text.IsEqualIgnoringCase +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringWhiteSpace.html b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringWhiteSpace.html new file mode 100644 index 000000000..b88a4009c --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/class-use/IsEqualIgnoringWhiteSpace.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.text.IsEqualIgnoringWhiteSpace (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.text.IsEqualIgnoringWhiteSpace

+
+No usage of org.hamcrest.text.IsEqualIgnoringWhiteSpace +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/class-use/StringContainsInOrder.html b/docs/javadoc/1.3/org/hamcrest/text/class-use/StringContainsInOrder.html new file mode 100644 index 000000000..abbd3d0fa --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/class-use/StringContainsInOrder.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.text.StringContainsInOrder (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.text.StringContainsInOrder

+
+No usage of org.hamcrest.text.StringContainsInOrder +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/package-frame.html b/docs/javadoc/1.3/org/hamcrest/text/package-frame.html new file mode 100644 index 000000000..dbbc6928e --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/package-frame.html @@ -0,0 +1,38 @@ + + + + + + +org.hamcrest.text (Hamcrest) + + + + + + + + + + + +org.hamcrest.text + + + + +
+Classes  + +
+IsEmptyString +
+IsEqualIgnoringCase +
+IsEqualIgnoringWhiteSpace +
+StringContainsInOrder
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/package-summary.html b/docs/javadoc/1.3/org/hamcrest/text/package-summary.html new file mode 100644 index 000000000..8faae2197 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/package-summary.html @@ -0,0 +1,184 @@ + + + + + + +org.hamcrest.text (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.text +

+Matchers that perform text comparisons. +

+See: +
+          Description +

+ + + + + + + + + + + + + + + + + + + + + +
+Class Summary
IsEmptyStringMatches empty Strings (and null).
IsEqualIgnoringCaseTests if a string is equal to another string, regardless of the case.
IsEqualIgnoringWhiteSpaceTests if a string is equal to another string, ignoring any changes in whitespace.
StringContainsInOrder 
+  + +

+

+Package org.hamcrest.text Description +

+ +

+

Matchers that perform text comparisons.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/package-tree.html b/docs/javadoc/1.3/org/hamcrest/text/package-tree.html new file mode 100644 index 000000000..d951bb17f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/package-tree.html @@ -0,0 +1,158 @@ + + + + + + +org.hamcrest.text Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.text +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/text/package-use.html b/docs/javadoc/1.3/org/hamcrest/text/package-use.html new file mode 100644 index 000000000..4751269a7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/text/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.text (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.text

+
+No usage of org.hamcrest.text +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/HasXPath.html b/docs/javadoc/1.3/org/hamcrest/xml/HasXPath.html new file mode 100644 index 000000000..68ccff21a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/HasXPath.html @@ -0,0 +1,492 @@ + + + + + + +HasXPath (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ +

+ +org.hamcrest.xml +
+Class HasXPath

+
+java.lang.Object
+  extended by org.hamcrest.BaseMatcher<T>
+      extended by org.hamcrest.TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
+          extended by org.hamcrest.xml.HasXPath
+
+
+
All Implemented Interfaces:
Matcher<org.w3c.dom.Node>, SelfDescribing
+
+
+
+
public class HasXPath
extends TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
+ + +

+Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression. +

+ +

+

+
Author:
+
Joe Walnes, Steve Freeman
+
+
+ +

+ + + + + + + + + + + +
+Field Summary
+static javax.xml.namespace.NamespaceContextNO_NAMESPACE_CONTEXT + +
+           
+  + + + + + + + + + + + + + +
+Constructor Summary
HasXPath(java.lang.String xPathExpression, + Matcher<java.lang.String> valueMatcher) + +
+           
HasXPath(java.lang.String xPathExpression, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddescribeTo(Description description) + +
+          Generates a description of the object.
+static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) + +
+          Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) + +
+          Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) + +
+          Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+ booleanmatchesSafely(org.w3c.dom.Node item, + Description mismatch) + +
+          Subclasses should implement this.
+ + + + + + + +
Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher
describeMismatch, matches
+ + + + + + + +
Methods inherited from class org.hamcrest.BaseMatcher
_dont_implement_Matcher___instead_extend_BaseMatcher_, toString
+ + + + + + + +
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+NO_NAMESPACE_CONTEXT

+
+public static final javax.xml.namespace.NamespaceContext NO_NAMESPACE_CONTEXT
+
+
+
+
+ + + + + + + + +
+Constructor Detail
+ +

+HasXPath

+
+public HasXPath(java.lang.String xPathExpression,
+                Matcher<java.lang.String> valueMatcher)
+
+
+
Parameters:
xPathExpression - XPath expression.
valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
+
+
+ +

+HasXPath

+
+public HasXPath(java.lang.String xPathExpression,
+                javax.xml.namespace.NamespaceContext namespaceContext,
+                Matcher<java.lang.String> valueMatcher)
+
+
+
Parameters:
xPathExpression - XPath expression.
namespaceContext - Resolves XML namespace prefixes in the XPath expression
valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
+
+ + + + + + + + +
+Method Detail
+ +

+matchesSafely

+
+public boolean matchesSafely(org.w3c.dom.Node item,
+                             Description mismatch)
+
+
Description copied from class: TypeSafeDiagnosingMatcher
+
Subclasses should implement this. The item will already have been checked + for the specific type and will never be null. +

+

+
Specified by:
matchesSafely in class TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
+
+
+
+
+
+
+ +

+describeTo

+
+public void describeTo(Description description)
+
+
Description copied from interface: SelfDescribing
+
Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately. +

+

+
Parameters:
description - The description to be built or appended to.
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 Matcher<java.lang.String> valueMatcher)
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
+

+

+
Parameters:
xPath - the target xpath
valueMatcher - matcher for the value at the specified xpath
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 javax.xml.namespace.NamespaceContext namespaceContext,
+                                                 Matcher<java.lang.String> valueMatcher)
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
+

+

+
Parameters:
xPath - the target xpath
namespaceContext - the namespace for matching nodes
valueMatcher - matcher for the value at the specified xpath
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese"))
+

+

+
Parameters:
xPath - the target xpath
+
+
+
+ +

+hasXPath

+
+public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
+                                                 javax.xml.namespace.NamespaceContext namespaceContext)
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. +

+ For example: +

assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
+

+

+
Parameters:
xPath - the target xpath
namespaceContext - the namespace for matching nodes
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/class-use/HasXPath.html b/docs/javadoc/1.3/org/hamcrest/xml/class-use/HasXPath.html new file mode 100644 index 000000000..71dd6cf3a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/class-use/HasXPath.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Class org.hamcrest.xml.HasXPath (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Class
org.hamcrest.xml.HasXPath

+
+No usage of org.hamcrest.xml.HasXPath +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/package-frame.html b/docs/javadoc/1.3/org/hamcrest/xml/package-frame.html new file mode 100644 index 000000000..19867beaf --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/package-frame.html @@ -0,0 +1,32 @@ + + + + + + +org.hamcrest.xml (Hamcrest) + + + + + + + + + + + +org.hamcrest.xml + + + + +
+Classes  + +
+HasXPath
+ + + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/package-summary.html b/docs/javadoc/1.3/org/hamcrest/xml/package-summary.html new file mode 100644 index 000000000..43f5cc4f7 --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/package-summary.html @@ -0,0 +1,172 @@ + + + + + + +org.hamcrest.xml (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+

+Package org.hamcrest.xml +

+Matchers of XML documents. +

+See: +
+          Description +

+ + + + + + + + + +
+Class Summary
HasXPathApplies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+  + +

+

+Package org.hamcrest.xml Description +

+ +

+

Matchers of XML documents.

+

+ +

+

+
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/package-tree.html b/docs/javadoc/1.3/org/hamcrest/xml/package-tree.html new file mode 100644 index 000000000..075c6289a --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/package-tree.html @@ -0,0 +1,158 @@ + + + + + + +org.hamcrest.xml Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For Package org.hamcrest.xml +

+
+
+
Package Hierarchies:
All Packages
+
+

+Class Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/org/hamcrest/xml/package-use.html b/docs/javadoc/1.3/org/hamcrest/xml/package-use.html new file mode 100644 index 000000000..7f149497f --- /dev/null +++ b/docs/javadoc/1.3/org/hamcrest/xml/package-use.html @@ -0,0 +1,144 @@ + + + + + + +Uses of Package org.hamcrest.xml (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Uses of Package
org.hamcrest.xml

+
+No usage of org.hamcrest.xml +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/overview-frame.html b/docs/javadoc/1.3/overview-frame.html new file mode 100644 index 000000000..611ddcd79 --- /dev/null +++ b/docs/javadoc/1.3/overview-frame.html @@ -0,0 +1,60 @@ + + + + + + +Overview List (Hamcrest) + + + + + + + + + + + + + + + +
+
+ + + + + +
All Classes +

+ +Packages +
+org.hamcrest +
+org.hamcrest.beans +
+org.hamcrest.collection +
+org.hamcrest.core +
+org.hamcrest.integration +
+org.hamcrest.internal +
+org.hamcrest.number +
+org.hamcrest.object +
+org.hamcrest.text +
+org.hamcrest.xml +
+

+ +

+  + + diff --git a/docs/javadoc/1.3/overview-summary.html b/docs/javadoc/1.3/overview-summary.html new file mode 100644 index 000000000..74687e8d0 --- /dev/null +++ b/docs/javadoc/1.3/overview-summary.html @@ -0,0 +1,221 @@ + + + + + + +Overview (Hamcrest) + + + + + + + + + + + + +


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+Hamcrest is a library of matchers, which can be combined in +to create flexible expressions of intent in tests. +

+See: +
+          Description +

+ + + + + + + + + +
+Hamcrest API and Utility Classes
org.hamcrestThe stable API defining Matcher and its associated interfaces and classes.
+ +

+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Matcher Library
org.hamcrest.beansMatchers of Java Bean properties and their values.
org.hamcrest.collectionMatchers of arrays and collections.
org.hamcrest.coreFundamental matchers of objects and values, and composite matchers.
org.hamcrest.internal 
org.hamcrest.numberMatchers that perform numeric comparisons.
org.hamcrest.objectMatchers that inspect objects and classes.
org.hamcrest.textMatchers that perform text comparisons.
org.hamcrest.xmlMatchers of XML documents.
+ +

+  + + + + + + + + +
+Integration
org.hamcrest.integration 
+ +

+

+

Hamcrest is a library of matchers, which can be combined in +to create flexible expressions of intent in tests.

+ +

Documentation can be found at: http://hamcrest.org/.

+

+ +

+


+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/overview-tree.html b/docs/javadoc/1.3/overview-tree.html new file mode 100644 index 000000000..765148cef --- /dev/null +++ b/docs/javadoc/1.3/overview-tree.html @@ -0,0 +1,187 @@ + + + + + + +Class Hierarchy (Hamcrest) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+
+

+Hierarchy For All Packages

+
+
+
Package Hierarchies:
org.hamcrest, org.hamcrest.beans, org.hamcrest.collection, org.hamcrest.core, org.hamcrest.integration, org.hamcrest.internal, org.hamcrest.number, org.hamcrest.object, org.hamcrest.text, org.hamcrest.xml
+
+

+Class Hierarchy +

+ +

+Interface Hierarchy +

+ +

+Annotation Type Hierarchy +

+
    +
  • org.hamcrest.Factory (implements java.lang.annotation.Annotation) +
+
+ + + + + + + + + + + + + + + +
+ +
+ + + +
+ + + diff --git a/docs/javadoc/1.3/package-list b/docs/javadoc/1.3/package-list new file mode 100644 index 000000000..3f5e945f7 --- /dev/null +++ b/docs/javadoc/1.3/package-list @@ -0,0 +1,10 @@ +org.hamcrest +org.hamcrest.beans +org.hamcrest.collection +org.hamcrest.core +org.hamcrest.integration +org.hamcrest.internal +org.hamcrest.number +org.hamcrest.object +org.hamcrest.text +org.hamcrest.xml diff --git a/docs/javadoc/1.3/resources/inherit.gif b/docs/javadoc/1.3/resources/inherit.gif new file mode 100644 index 000000000..c814867a1 Binary files /dev/null and b/docs/javadoc/1.3/resources/inherit.gif differ diff --git a/docs/javadoc/1.3/stylesheet.css b/docs/javadoc/1.3/stylesheet.css new file mode 100644 index 000000000..6ea9e5161 --- /dev/null +++ b/docs/javadoc/1.3/stylesheet.css @@ -0,0 +1,29 @@ +/* Javadoc style sheet */ + +/* Define colors, fonts and other style attributes here to override the defaults */ + +/* Page background color */ +body { background-color: #FFFFFF; color:#000000 } + +/* Headings */ +h1 { font-size: 145% } + +/* Table colors */ +.TableHeadingColor { background: #CCCCFF; color:#000000 } /* Dark mauve */ +.TableSubHeadingColor { background: #EEEEFF; color:#000000 } /* Light mauve */ +.TableRowColor { background: #FFFFFF; color:#000000 } /* White */ + +/* Font used in left-hand frame lists */ +.FrameTitleFont { font-size: 100%; font-family: Helvetica, Arial, sans-serif; color:#000000 } +.FrameHeadingFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 } +.FrameItemFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 } + +/* Navigation bar fonts and colors */ +.NavBarCell1 { background-color:#EEEEFF; color:#000000} /* Light mauve */ +.NavBarCell1Rev { background-color:#00008B; color:#FFFFFF} /* Dark Blue */ +.NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;color:#000000;} +.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;color:#FFFFFF;} + +.NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000} +.NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000} + diff --git a/docs/javadoc/2.0.0.0/allclasses-frame.html b/docs/javadoc/2.0.0.0/allclasses-frame.html new file mode 100644 index 000000000..875b31090 --- /dev/null +++ b/docs/javadoc/2.0.0.0/allclasses-frame.html @@ -0,0 +1,97 @@ + + + + + +All Classes (JavaHamcrest 2.0.0.0 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.0.0.0/allclasses-noframe.html b/docs/javadoc/2.0.0.0/allclasses-noframe.html new file mode 100644 index 000000000..d4ade420c --- /dev/null +++ b/docs/javadoc/2.0.0.0/allclasses-noframe.html @@ -0,0 +1,97 @@ + + + + + +All Classes (JavaHamcrest 2.0.0.0 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.0.0.0/constant-values.html b/docs/javadoc/2.0.0.0/constant-values.html new file mode 100644 index 000000000..807f0c73c --- /dev/null +++ b/docs/javadoc/2.0.0.0/constant-values.html @@ -0,0 +1,122 @@ + + + + + +Constant Field Values (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Constant Field Values

+

Contents

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/deprecated-list.html b/docs/javadoc/2.0.0.0/deprecated-list.html new file mode 100644 index 000000000..39e0bc69c --- /dev/null +++ b/docs/javadoc/2.0.0.0/deprecated-list.html @@ -0,0 +1,199 @@ + + + + + +Deprecated List (JavaHamcrest 2.0.0.0 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

Deprecated API

+

Contents

+ +
+
+ + + +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.0.0.0/help-doc.html b/docs/javadoc/2.0.0.0/help-doc.html new file mode 100644 index 000000000..ffc5e6ea4 --- /dev/null +++ b/docs/javadoc/2.0.0.0/help-doc.html @@ -0,0 +1,223 @@ + + + + + +API Help (JavaHamcrest 2.0.0.0 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

How This API Document Is Organized

+
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+
+
+
    +
  • +

    Overview

    +

    The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

    +
  • +
  • +

    Package

    +

    Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:

    +
      +
    • Interfaces (italic)
    • +
    • Classes
    • +
    • Enums
    • +
    • Exceptions
    • +
    • Errors
    • +
    • Annotation Types
    • +
    +
  • +
  • +

    Class/Interface

    +

    Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:

    +
      +
    • Class inheritance diagram
    • +
    • Direct Subclasses
    • +
    • All Known Subinterfaces
    • +
    • All Known Implementing Classes
    • +
    • Class/interface declaration
    • +
    • Class/interface description
    • +
    +
      +
    • Nested Class Summary
    • +
    • Field Summary
    • +
    • Constructor Summary
    • +
    • Method Summary
    • +
    +
      +
    • Field Detail
    • +
    • Constructor Detail
    • +
    • Method Detail
    • +
    +

    Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.

    +
  • +
  • +

    Annotation Type

    +

    Each annotation type has its own separate page with the following sections:

    +
      +
    • Annotation Type declaration
    • +
    • Annotation Type description
    • +
    • Required Element Summary
    • +
    • Optional Element Summary
    • +
    • Element Detail
    • +
    +
  • +
  • +

    Enum

    +

    Each enum has its own separate page with the following sections:

    +
      +
    • Enum declaration
    • +
    • Enum description
    • +
    • Enum Constant Summary
    • +
    • Enum Constant Detail
    • +
    +
  • +
  • +

    Tree (Class Hierarchy)

    +

    There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.

    +
      +
    • When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
    • +
    • When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
    • +
    +
  • +
  • +

    Deprecated API

    +

    The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.

    +
  • +
  • +

    Index

    +

    The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.

    +
  • +
  • +

    Prev/Next

    +

    These links take you to the next or previous class, interface, package, or related page.

    +
  • +
  • +

    Frames/No Frames

    +

    These links show and hide the HTML frames. All pages are available with or without frames.

    +
  • +
  • +

    All Classes

    +

    The All Classes link shows all classes and interfaces except non-static nested types.

    +
  • +
  • +

    Serialized Form

    +

    Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.

    +
  • +
  • +

    Constant Field Values

    +

    The Constant Field Values page lists the static final fields and their values.

    +
  • +
+This help file applies to API documentation generated using the standard doclet.
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.0.0.0/index-all.html b/docs/javadoc/2.0.0.0/index-all.html new file mode 100644 index 000000000..395627342 --- /dev/null +++ b/docs/javadoc/2.0.0.0/index-all.html @@ -0,0 +1,2580 @@ + + + + + +Index (JavaHamcrest 2.0.0.0 API) + + + + + + + + +
+ + + + + + + +
+ + +
A B C D E F G H I L M N O P R S T U _  + + +

A

+
+
aFileNamed(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithAbsolutePath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithCanonicalPath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(long) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(Matcher<Long>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
AllOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical conjunction of multiple matchers.
+
+
AllOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AllOf
+
 
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
and(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
and(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
and(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
anEmptyMap() - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anEmptyMap() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anExistingDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFileOrDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
any(Class<T>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
AnyOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical disjunction of multiple matchers.
+
+
AnyOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AnyOf
+
 
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anything() - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
append(String) - Method in class org.hamcrest.BaseDescription
+
+
Append the String str to the description.
+
+
append(char) - Method in class org.hamcrest.BaseDescription
+
+
Append the char c to the description.
+
+
append(String) - Method in class org.hamcrest.StringDescription
+
 
+
append(char) - Method in class org.hamcrest.StringDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.BaseDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in interface org.hamcrest.Description
+
+
Appends the description of a SelfDescribing value to this description.
+
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in interface org.hamcrest.Description
+
+
Appends a list of SelfDescribing objects + to the description.
+
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendText(String) - Method in class org.hamcrest.BaseDescription
+
 
+
appendText(String) - Method in interface org.hamcrest.Description
+
+
Appends some plain text to the description.
+
+
appendText(String) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValue(Object) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValue(Object) - Method in interface org.hamcrest.Description
+
+
Appends an arbitrary value to the description.
+
+
appendValue(Object) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, T...) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, Iterable<T>) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
apply(I, Description) - Method in interface org.hamcrest.Condition.Step
+
 
+
aReadableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsArray
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContaining(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
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.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
ArrayIterator - Class in org.hamcrest.internal
+
 
+
ArrayIterator(Object) - Constructor for class org.hamcrest.internal.ArrayIterator
+
 
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
assertThat(T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, boolean) - Static method in class org.hamcrest.MatcherAssert
+
 
+
asString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+ +
+
aWritableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
+ + + +

B

+
+
BaseDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
BaseDescription() - Constructor for class org.hamcrest.BaseDescription
+
 
+
BaseMatcher<T> - Class in org.hamcrest
+
+
BaseClass for all Matcher implementations.
+
+
BaseMatcher() - Constructor for class org.hamcrest.BaseMatcher
+
 
+
BigDecimalCloseTo - Class in org.hamcrest.number
+
 
+
BigDecimalCloseTo(BigDecimal, BigDecimal) - Constructor for class org.hamcrest.number.BigDecimalCloseTo
+
 
+
blankOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankOrNullString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
+ + + +

C

+
+
CAN_READ - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
CAN_WRITE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
canObtainExpectedTypeFrom(Method) - Method in class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
check(File) - Method in interface org.hamcrest.io.FileMatchers.FileStatus
+
 
+
closeTo(double, double) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.number.BigDecimalCloseTo
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(double, double) - Static method in class org.hamcrest.number.IsCloseTo
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
CombinableBothMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
CombinableEitherMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
CombinableMatcher<T> - Class in org.hamcrest.core
+
 
+
CombinableMatcher(Matcher<? super T>) - Constructor for class org.hamcrest.core.CombinableMatcher
+
 
+
CombinableMatcher.CombinableBothMatcher<X> - Class in org.hamcrest.core
+
 
+
CombinableMatcher.CombinableEitherMatcher<X> - Class in org.hamcrest.core
+
 
+
ComparatorMatcherBuilder<T> - Class in org.hamcrest.comparator
+
 
+
comparedBy(Comparator<T>) - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparatorss of T.
+
+
comparesEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
Condition<T> - Class in org.hamcrest
+
+
A Condition implements part of a multi-step match.
+
+
Condition.Step<I,O> - Interface in org.hamcrest
+
 
+
contains(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsString(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
converted(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
CoreMatchers - Class in org.hamcrest
+
 
+
CoreMatchers() - Constructor for class org.hamcrest.CoreMatchers
+
 
+
CustomMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomMatcher(String) - Constructor for class org.hamcrest.CustomMatcher
+
 
+
CustomTypeSafeMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomTypeSafeMatcher(String) - Constructor for class org.hamcrest.CustomTypeSafeMatcher
+
 
+
+ + + +

D

+
+
DescribedAs<T> - Class in org.hamcrest.core
+
+
Provides a custom description to another matcher.
+
+
DescribedAs(String, Matcher<T>, Object[]) - Constructor for class org.hamcrest.core.DescribedAs
+
 
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.core.DescribedAs
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.CoreMatchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.Matchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.BaseMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.Is
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in interface org.hamcrest.Matcher
+
+
Generate a description of why the matcher has not accepted the item.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.IsArrayContaining
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
 
+
describeMismatchSafely(Collection<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeMismatchSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeMismatchSafely(Map<? extends K, ? extends V>, Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeMismatchSafely(BigDecimal, Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeMismatchSafely(Class<?>, Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should override this.
+
+
describeTo(Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIn
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AllOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AnyOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Every
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Is
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsAnything
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsEqual
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNot
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNull
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsSame
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomTypeSafeMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.internal.SelfDescribingValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
describeTo(Description) - Method in interface org.hamcrest.SelfDescribing
+
+
Generates a description of the object.
+
+
describeTo(Description) - Method in class org.hamcrest.text.IsBlankString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
Description - Interface in org.hamcrest
+
+
A description of a Matcher.
+
+
Description.NullDescription - Class in org.hamcrest
+
 
+
descriptionEnd() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that ends the description.
+
+
descriptionSeparator() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that separates the elements in the description.
+
+
descriptionStart() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that starts the description.
+
+
DiagnosingMatcher<T> - Class in org.hamcrest
+
+
TODO(ngd): Document.
+
+
DiagnosingMatcher() - Constructor for class org.hamcrest.DiagnosingMatcher
+
 
+
+ + + +

E

+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
empty() - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
empty() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyArray() - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyArray() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyIterable() - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterable() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
emptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
endsWith(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
equalTo(T) - Static method in class org.hamcrest.core.IsEqual
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.text.IsEqualIgnoringCase
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToObject(Object) - Static method in class org.hamcrest.core.IsEqual
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringContains
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringEndsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringStartsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
Every<T> - Class in org.hamcrest.core
+
 
+
Every(Matcher<? super T>) - Constructor for class org.hamcrest.core.Every
+
 
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.core.Every
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
EXISTS - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
expectedTypeFrom(Method) - Method in class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
+ + + +

F

+
+
FeatureMatcher<T,U> - Class in org.hamcrest
+
+
Supporting class for matching a feature of an object.
+
+
FeatureMatcher(Matcher<? super U>, String, String) - Constructor for class org.hamcrest.FeatureMatcher
+
+
Constructor
+
+
featureValueOf(E[]) - Method in class org.hamcrest.collection.IsArrayWithSize
+
 
+
featureValueOf(Collection<? extends E>) - Method in class org.hamcrest.collection.IsCollectionWithSize
+
 
+
featureValueOf(Iterable<E>) - Method in class org.hamcrest.collection.IsIterableWithSize
+
 
+
featureValueOf(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapWithSize
+
 
+
featureValueOf(T) - Method in class org.hamcrest.FeatureMatcher
+
+
Implement this to extract the interesting feature.
+
+
featureValueOf(T) - Method in class org.hamcrest.object.HasToString
+
 
+
FileMatchers - Class in org.hamcrest.io
+
 
+
FileMatchers() - Constructor for class org.hamcrest.io.FileMatchers
+
 
+
FileMatchers.FileStatus - Interface in org.hamcrest.io
+
 
+
findExpectedType(Class<?>) - Method in class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
+ + + +

G

+
+
getPropertyDescriptor(String, Object) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns the description of the property with the provided + name on the provided object's interface.
+
+
greaterThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
greaterThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

H

+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.collection.IsArrayContaining
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.collection.IsArrayContaining
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasNext() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
hasNext() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
HasProperty<T> - Class in org.hamcrest.beans
+
+
A Matcher that checks that an object has a JavaBean property + with the specified name.
+
+
HasProperty(String) - Constructor for class org.hamcrest.beans.HasProperty
+
 
+
hasProperty(String) - Static method in class org.hamcrest.beans.HasProperty
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasProperty(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
HasPropertyWithValue<T> - Class in org.hamcrest.beans
+
+
Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+
+
HasPropertyWithValue(String, Matcher<?>) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
 
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
HasToString<T> - Class in org.hamcrest.object
+
 
+
HasToString(Matcher<? super String>) - Constructor for class org.hamcrest.object.HasToString
+
 
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
HasXPath - Class in org.hamcrest.xml
+
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+
HasXPath(String, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
HasXPath(String, NamespaceContext, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
+ + + +

I

+
+
in(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
in(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
Is<T> - Class in org.hamcrest.core
+
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+
+
Is(Matcher<T>) - Constructor for class org.hamcrest.core.Is
+
 
+
is(Matcher<T>) - Static method in class org.hamcrest.core.Is
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
IS_DIRECTORY - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
IS_FILE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
isA(Class<T>) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
IsAnything<T> - Class in org.hamcrest.core
+
+
A matcher that always returns true.
+
+
IsAnything() - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsAnything(String) - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsArray<T> - Class in org.hamcrest.collection
+
+
Matcher for array whose elements satisfy a sequence of matchers.
+
+
IsArray(Matcher<? super T>[]) - Constructor for class org.hamcrest.collection.IsArray
+
 
+
IsArrayContaining<T> - Class in org.hamcrest.collection
+
+
Matches if an array contains an item satisfying a nested matcher.
+
+
IsArrayContaining(Matcher<? super T>) - Constructor for class org.hamcrest.collection.IsArrayContaining
+
 
+
IsArrayContainingInAnyOrder<E> - Class in org.hamcrest.collection
+
 
+
IsArrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
 
+
IsArrayContainingInOrder<E> - Class in org.hamcrest.collection
+
 
+
IsArrayContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInOrder
+
 
+
IsArrayWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if array size satisfies a nested matcher.
+
+
IsArrayWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsArrayWithSize
+
 
+
IsBlankString - Class in org.hamcrest.text
+
+
Matches blank Strings (and null).
+
+
IsCloseTo - Class in org.hamcrest.number
+
+
Is the value a number equal to a value within some range of + acceptable error?
+
+
IsCloseTo(double, double) - Constructor for class org.hamcrest.number.IsCloseTo
+
 
+
IsCollectionContaining<T> - Class in org.hamcrest.core
+
 
+
IsCollectionContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsCollectionContaining
+
 
+
IsCollectionWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if collection size satisfies a nested matcher.
+
+
IsCollectionWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsCollectionWithSize
+
 
+
IsCompatibleType<T> - Class in org.hamcrest.object
+
 
+
IsCompatibleType(Class<T>) - Constructor for class org.hamcrest.object.IsCompatibleType
+
 
+
IsEmptyCollection<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyCollection() - Constructor for class org.hamcrest.collection.IsEmptyCollection
+
 
+
IsEmptyIterable<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyIterable() - Constructor for class org.hamcrest.collection.IsEmptyIterable
+
 
+
isEmptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEmptyString - Class in org.hamcrest.text
+
+
Matches empty Strings (and null).
+
+
isEmptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEqual<T> - Class in org.hamcrest.core
+
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+
+
IsEqual(T) - Constructor for class org.hamcrest.core.IsEqual
+
 
+
IsEqualIgnoringCase - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, regardless of the case.
+
+
IsEqualIgnoringCase(String) - Constructor for class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
IsEqualIgnoringWhiteSpace - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, ignoring any changes in whitespace.
+
+
IsEqualIgnoringWhiteSpace(String) - Constructor for class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
 
+
IsEventFrom - Class in org.hamcrest.object
+
+
Tests if the value is an event announced by a specific object.
+
+
IsEventFrom(Class<?>, Object) - Constructor for class org.hamcrest.object.IsEventFrom
+
 
+
IsIn<T> - Class in org.hamcrest.collection
+
 
+
IsIn(Collection<T>) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
IsIn(T[]) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
isIn(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
IsInstanceOf - Class in org.hamcrest.core
+
+
Tests whether the value is an instance of a class.
+
+
IsInstanceOf(Class<?>) - Constructor for class org.hamcrest.core.IsInstanceOf
+
+
Creates a new instance of IsInstanceOf
+
+
IsIterableContainingInAnyOrder<T> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInAnyOrder(Collection<Matcher<? super T>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
IsIterableContainingInOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
IsIterableContainingInRelativeOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInRelativeOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
IsIterableWithSize<E> - Class in org.hamcrest.collection
+
 
+
IsIterableWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsIterableWithSize
+
 
+
IsMapContaining<K,V> - Class in org.hamcrest.collection
+
 
+
IsMapContaining(Matcher<? super K>, Matcher<? super V>) - Constructor for class org.hamcrest.collection.IsMapContaining
+
 
+
IsMapWithSize<K,V> - Class in org.hamcrest.collection
+
+
Matches if map size satisfies a nested matcher.
+
+
IsMapWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsMapWithSize
+
 
+
IsNaN - Class in org.hamcrest.number
+
+
Is the value a number actually not a number (NaN)?
+
+
IsNot<T> - Class in org.hamcrest.core
+
+
Calculates the logical negation of a matcher.
+
+
IsNot(Matcher<T>) - Constructor for class org.hamcrest.core.IsNot
+
 
+
IsNull<T> - Class in org.hamcrest.core
+
+
Is the value null?
+
+
IsNull() - Constructor for class org.hamcrest.core.IsNull
+
 
+
isOneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
isOneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
IsSame<T> - Class in org.hamcrest.core
+
+
Is the value the same object as another value?
+
+
IsSame(T) - Constructor for class org.hamcrest.core.IsSame
+
 
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
+ + + +

L

+
+
lessThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
lessThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

M

+
+
matched(T, Description) - Static method in class org.hamcrest.Condition
+
 
+
Matcher<T> - Interface in org.hamcrest
+
+
+ A matcher over acceptable values.
+
+
MatcherAssert - Class in org.hamcrest
+
 
+
MatcherAssert() - Constructor for class org.hamcrest.MatcherAssert
+
 
+
Matchers - Class in org.hamcrest
+
 
+
Matchers() - Constructor for class org.hamcrest.Matchers
+
 
+
matches(Object, Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher
+
 
+
matches(Object) - Method in class org.hamcrest.collection.IsIn
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.AllOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.AnyOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.DescribedAs
+
 
+
matches(Object) - Method in class org.hamcrest.core.Is
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsAnything
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsEqual
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNot
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNull
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsSame
+
 
+
matches(Object) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object) - Method in interface org.hamcrest.Matcher
+
+
Evaluates the matcher for argument item.
+
+
matches(Object) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
matches(Object) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Methods made final to prevent accidental override.
+
+
matchesPattern(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
MatchesPattern - Class in org.hamcrest.text
+
 
+
MatchesPattern(Pattern) - Constructor for class org.hamcrest.text.MatchesPattern
+
 
+
matchesPattern(Pattern) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
matchesSafely(T) - Method in class org.hamcrest.beans.HasProperty
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.IsArray
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.IsArrayContaining
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
 
+
matchesSafely(Collection<? extends E>) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
matchesSafely(Iterable<? extends E>) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
matchesSafely(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.core.Every
+
 
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
 
+
matchesSafely(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
matchesSafely(BigDecimal) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsNaN
+
 
+
matchesSafely(Class<?>) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
matchesSafely(EventObject, Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsBlankString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(T) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(Node, Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
matching(Matcher<T>, String) - Method in class org.hamcrest.Condition
+
 
+
matching(Matcher<T>) - Method in class org.hamcrest.Condition
+
 
+
+ + + +

N

+
+
next() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
next() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
NO_ARGUMENTS - Static variable in class org.hamcrest.beans.PropertyUtil
+
 
+
NO_NAMESPACE_CONTEXT - Static variable in class org.hamcrest.xml.HasXPath
+
 
+
NONE - Static variable in interface org.hamcrest.Description
+
+
A description that consumes input but does nothing.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.core.IsNot
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.core.IsNot
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
NOT_MATCHED - Static variable in class org.hamcrest.Condition
+
 
+
notANumber() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notANumber() - Static method in class org.hamcrest.number.IsNaN
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notMatched() - Static method in class org.hamcrest.Condition
+
 
+
notNullValue() - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
NullDescription() - Constructor for class org.hamcrest.Description.NullDescription
+
 
+
nullSafe(Matcher<? super E>[]) - Static method in class org.hamcrest.internal.NullSafety
+
 
+
NullSafety - Class in org.hamcrest.internal
+
 
+
NullSafety() - Constructor for class org.hamcrest.internal.NullSafety
+
 
+
nullValue() - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
+ + + +

O

+
+
oneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
oneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
or(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
or(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
OrderingComparison - Class in org.hamcrest.number
+
 
+
org.hamcrest - package org.hamcrest
+
 
+
org.hamcrest.beans - package org.hamcrest.beans
+
+
Matchers of Java Bean properties and their values.
+
+
org.hamcrest.collection - package org.hamcrest.collection
+
+
Matchers of arrays and collections.
+
+
org.hamcrest.comparator - package org.hamcrest.comparator
+
 
+
org.hamcrest.core - package org.hamcrest.core
+
+
Fundamental matchers of objects and values, and composite matchers.
+
+
org.hamcrest.internal - package org.hamcrest.internal
+
 
+
org.hamcrest.io - package org.hamcrest.io
+
 
+
org.hamcrest.number - package org.hamcrest.number
+
+
Matchers that perform numeric comparisons.
+
+
org.hamcrest.object - package org.hamcrest.object
+
+
Matchers that inspect objects and classes.
+
+
org.hamcrest.text - package org.hamcrest.text
+
+
Matchers that perform text comparisons.
+
+
org.hamcrest.xml - package org.hamcrest.xml
+
+
Matchers of XML documents.
+
+
+ + + +

P

+
+
propertyDescriptorsFor(Object, Class<Object>) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns all the property descriptors for the class associated with the given object
+
+
PropertyMatcher(PropertyDescriptor, Object) - Constructor for class org.hamcrest.beans.SamePropertyValuesAs.PropertyMatcher
+
 
+
PropertyUtil - Class in org.hamcrest.beans
+
+
Utility class for accessing properties on JavaBean objects.
+
+
PropertyUtil() - Constructor for class org.hamcrest.beans.PropertyUtil
+
 
+
+ + + +

R

+
+
ReflectiveTypeFinder - Class in org.hamcrest.internal
+
 
+
ReflectiveTypeFinder(String, int, int) - Constructor for class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
remove() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
remove() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
+ + + +

S

+
+
sameInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
SamePropertyValuesAs<T> - Class in org.hamcrest.beans
+
 
+
SamePropertyValuesAs(T) - Constructor for class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
samePropertyValuesAs(T) - Static method in class org.hamcrest.beans.SamePropertyValuesAs
+
+
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.
+
+
samePropertyValuesAs(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
SamePropertyValuesAs.PropertyMatcher - Class in org.hamcrest.beans
+
 
+
SelfDescribing - Interface in org.hamcrest
+
+
The ability of an object to describe itself.
+
+
SelfDescribingValue<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValue(T) - Constructor for class org.hamcrest.internal.SelfDescribingValue
+
 
+
SelfDescribingValueIterator<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValueIterator(Iterator<T>) - Constructor for class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
startsWith(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
StringContains - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a substring.
+
+
StringContains(boolean, String) - Constructor for class org.hamcrest.core.StringContains
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringContainsInOrder - Class in org.hamcrest.text
+
 
+
StringContainsInOrder(Iterable<String>) - Constructor for class org.hamcrest.text.StringContainsInOrder
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
StringDescription() - Constructor for class org.hamcrest.StringDescription
+
 
+
StringDescription(Appendable) - Constructor for class org.hamcrest.StringDescription
+
 
+
StringEndsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a substring.
+
+
StringEndsWith(boolean, String) - Constructor for class org.hamcrest.core.StringEndsWith
+
 
+
StringStartsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a substring.
+
+
StringStartsWith(boolean, String) - Constructor for class org.hamcrest.core.StringStartsWith
+
 
+
stripSpace(String) - Method in class org.hamcrest.text.IsEqualIgnoringWhiteSpace
+
 
+
substring - Variable in class org.hamcrest.core.SubstringMatcher
+
 
+
SubstringMatcher - Class in org.hamcrest.core
+
 
+
SubstringMatcher(String, boolean, String) - Constructor for class org.hamcrest.core.SubstringMatcher
+
 
+
+ + + +

T

+
+
theInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
then(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
toString() - Method in class org.hamcrest.BaseMatcher
+
 
+
toString() - Method in class org.hamcrest.Description.NullDescription
+
 
+
toString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+
Return the description of a SelfDescribing object as a String.
+
+
toString() - Method in class org.hamcrest.StringDescription
+
+
Returns the description as a string.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.object.IsCompatibleType
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
TypeSafeDiagnosingMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+
+
TypeSafeDiagnosingMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher() - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type.
+
+
TypeSafeMatcher() - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
+ + + +

U

+
+
usingNaturalOrdering() - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparables.
+
+
+ + + +

_

+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in class org.hamcrest.BaseMatcher
+
+
Deprecated.
+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in interface org.hamcrest.Matcher
+
+
Deprecated. +
to make
+
+
+
+A B C D E F G H I L M N O P R S T U _ 
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.0.0.0/index.html b/docs/javadoc/2.0.0.0/index.html new file mode 100644 index 000000000..5f1c3bd33 --- /dev/null +++ b/docs/javadoc/2.0.0.0/index.html @@ -0,0 +1,74 @@ + + + + + +JavaHamcrest 2.0.0.0 API + + + + + + + + + +<noscript> +<div>JavaScript is disabled on your browser.</div> +</noscript> +<h2>Frame Alert</h2> +<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p> + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/BaseDescription.html b/docs/javadoc/2.0.0.0/org/hamcrest/BaseDescription.html new file mode 100644 index 000000000..2876d5160 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/BaseDescription.html @@ -0,0 +1,478 @@ + + + + + +BaseDescription (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseDescription
    • +
    +
  • +
+
+ +
+
+
    +
  • + + + + + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      BaseDescription() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethod and Description
      protected abstract voidappend(char c) +
      Append the char c to the description.
      +
      protected voidappend(java.lang.String str) +
      Append the String str to the description.
      +
      DescriptionappendDescriptionOf(SelfDescribing value) +
      Appends the description of a SelfDescribing value to this description.
      +
      DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) +
      Appends a list of SelfDescribing objects + to the description.
      +
      DescriptionappendText(java.lang.String text) +
      Appends some plain text to the description.
      +
      DescriptionappendValue(java.lang.Object value) +
      Appends an arbitrary value to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) +
      Appends a list of values to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) +
      Appends a list of values to the description.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseDescription

        +
        public BaseDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Append the String str to the description. + The default implementation passes every character to append(char). + Override in subclasses to provide an efficient implementation.
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected abstract void append(char c)
        +
        Append the char c to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/BaseMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/BaseMatcher.html new file mode 100644 index 000000000..f114ed360 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/BaseMatcher.html @@ -0,0 +1,358 @@ + + + + + +BaseMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseMatcher<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseMatcher<T>
    • +
    +
  • +
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseMatcher

        +
        public BaseMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Condition.Step.html b/docs/javadoc/2.0.0.0/org/hamcrest/Condition.Step.html new file mode 100644 index 000000000..7a37e95b6 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Condition.Step.html @@ -0,0 +1,227 @@ + + + + + +Condition.Step (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Condition.Step<I,O>

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    Condition<T>
    +
    +
    +
    +
    public static interface Condition.Step<I,O>
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Condition.html b/docs/javadoc/2.0.0.0/org/hamcrest/Condition.html new file mode 100644 index 000000000..a1d7ca203 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Condition.html @@ -0,0 +1,367 @@ + + + + + +Condition (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Condition<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Condition<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public abstract class Condition<T>
    +extends java.lang.Object
    +
    A Condition implements part of a multi-step match. We sometimes need to write matchers + that have a sequence of steps, where each step depends on the result of the previous + step and we can stop processing as soon as a step fails. These classes provide + infrastructure for writing such a sequence. + + Based on https://github.com/npryce/maybe-java
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NOT_MATCHED

        +
        public static final org.hamcrest.Condition.NotMatched<java.lang.Object> NOT_MATCHED
        +
      • +
      +
    • +
    + + +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/CoreMatchers.html b/docs/javadoc/2.0.0.0/org/hamcrest/CoreMatchers.html new file mode 100644 index 000000000..041713afa --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/CoreMatchers.html @@ -0,0 +1,1077 @@ + + + + + +CoreMatchers (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CoreMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.CoreMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class CoreMatchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      CoreMatchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static Matcher<java.lang.Object>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>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>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>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>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>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<T> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>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>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CoreMatchers

        +
        public CoreMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<T> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/CustomMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/CustomMatcher.html new file mode 100644 index 000000000..02725b490 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/CustomMatcher.html @@ -0,0 +1,324 @@ + + + + + +CustomMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched.
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomMatcher<T>
    +extends BaseMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomMatcher<String>("a non empty string") {
    +   public boolean matches(Object object) {
    +     return ((object instanceof String) && !((String) object).isEmpty();
    +   }
    + };
    + 
    +

    + This class is designed for scenarios where an anonymous inner class + matcher makes sense. It should not be used by API designers implementing + matchers.

    +
    +
    See Also:
    +
    for a type safe variant of this class that you probably + want to use.
    +
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomMatcher

        +
        public CustomMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/CustomTypeSafeMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..e617f4d41 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/CustomTypeSafeMatcher.html @@ -0,0 +1,327 @@ + + + + + +CustomTypeSafeMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomTypeSafeMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomTypeSafeMatcher<T>
    +extends TypeSafeMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
    +   public boolean matchesSafely(String string) {
    +     return !string.isEmpty();
    +   }
    +   public void describeMismatchSafely(String string, Description mismatchDescription) {
    +     mismatchDescription.appendText("was empty");
    +   }
    + };
    + 
    + This is a variant of CustomMatcher that first type checks + the argument being matched. By the time TypeSafeMatcher.matchesSafely(T) is + is called the argument is guaranteed to be non-null and of the correct + type.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomTypeSafeMatcher

        +
        public CustomTypeSafeMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Description.NullDescription.html b/docs/javadoc/2.0.0.0/org/hamcrest/Description.NullDescription.html new file mode 100644 index 000000000..119ab4b8f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Description.NullDescription.html @@ -0,0 +1,460 @@ + + + + + +Description.NullDescription (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Description.NullDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Description.NullDescription
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Description
    +
    +
    +
    Enclosing interface:
    +
    Description
    +
    +
    +
    +
    public static final class Description.NullDescription
    +extends java.lang.Object
    +implements Description
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullDescription

        +
        public NullDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Description.html b/docs/javadoc/2.0.0.0/org/hamcrest/Description.html new file mode 100644 index 000000000..e174cf5e5 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Description.html @@ -0,0 +1,392 @@ + + + + + +Description (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Description

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NONE

        +
        static final Description NONE
        +
        A description that consumes input but does nothing.
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        Description appendText(java.lang.String text)
        +
        Appends some plain text to the description.
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        Description appendValue(java.lang.Object value)
        +
        Appends an arbitrary value to the description.
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                T... values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                java.lang.Iterable<T> values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        Description appendList(java.lang.String start,
        +                       java.lang.String separator,
        +                       java.lang.String end,
        +                       java.lang.Iterable<? extends SelfDescribing> values)
        +
        Appends a list of SelfDescribing objects + to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/DiagnosingMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/DiagnosingMatcher.html new file mode 100644 index 000000000..119013bac --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/DiagnosingMatcher.html @@ -0,0 +1,365 @@ + + + + + +DiagnosingMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class DiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DiagnosingMatcher

        +
        public DiagnosingMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected abstract boolean matches(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/FeatureMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/FeatureMatcher.html new file mode 100644 index 000000000..65469d6ae --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/FeatureMatcher.html @@ -0,0 +1,381 @@ + + + + + +FeatureMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class FeatureMatcher<T,U>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FeatureMatcher

        +
        public FeatureMatcher(Matcher<? super U> subMatcher,
        +                      java.lang.String featureDescription,
        +                      java.lang.String featureName)
        +
        Constructor
        +
        +
        Parameters:
        +
        subMatcher - The matcher to apply to the feature
        +
        featureDescription - Descriptive text to use in describeTo
        +
        featureName - Identifying text for mismatch message
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected abstract U featureValueOf(T actual)
        +
        Implement this to extract the interesting feature.
        +
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Matcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/Matcher.html new file mode 100644 index 000000000..f8bb9ab8f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Matcher.html @@ -0,0 +1,322 @@ + + + + + +Matcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Matcher<T>

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        boolean matches(java.lang.Object item)
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        void describeMismatch(java.lang.Object item,
        +                      Description mismatchDescription)
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        _dont_implement_Matcher___instead_extend_BaseMatcher_

        +
        @Deprecated
        +void _dont_implement_Matcher___instead_extend_BaseMatcher_()
        +
        Deprecated. to make
        +
        This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors .
        +
        +
        See Also:
        +
        for reasons why., +BaseMatcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/MatcherAssert.html b/docs/javadoc/2.0.0.0/org/hamcrest/MatcherAssert.html new file mode 100644 index 000000000..54eb46b7f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/MatcherAssert.html @@ -0,0 +1,307 @@ + + + + + +MatcherAssert (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class MatcherAssert

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.MatcherAssert
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class MatcherAssert
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      MatcherAssert() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static voidassertThat(java.lang.String reason, + boolean assertion) 
      static <T> voidassertThat(java.lang.String reason, + T actual, + Matcher<? super T> matcher) 
      static <T> voidassertThat(T actual, + Matcher<? super T> matcher) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatcherAssert

        +
        public MatcherAssert()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(java.lang.String reason,
        +                                  T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + +
        +
      • +

        assertThat

        +
        public static void assertThat(java.lang.String reason,
        +                              boolean assertion)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/Matchers.html b/docs/javadoc/2.0.0.0/org/hamcrest/Matchers.html new file mode 100644 index 000000000..70a4e9746 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/Matchers.html @@ -0,0 +1,3302 @@ + + + + + +Matchers (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Matchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Matchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class Matchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Matchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(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(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(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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(int size) +
      Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>anEmptyMap() +
      Creates a matcher for Maps that matches when the size() method returns + zero.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static <T> AnyOf<T>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(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(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(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(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>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>anything(java.lang.String description) +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      static <T> IsArray<T>array(Matcher<? super T>... elementMatchers) +
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
      +
      static <E> Matcher<E[]>arrayContaining(E... items) +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
      +
      static <E> Matcher<E[]>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[]>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[]>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[]>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[]>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[]>arrayWithSize(int size) +
      Creates a matcher for arrays that matches when the length of the array + equals the specified size.
      +
      static <E> Matcher<E[]>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 Matcher<java.lang.String>blankOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
      +
      static Matcher<java.lang.String>blankString() +
      Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
      +
      static <LHS> CombinableMatcher.CombinableBothMatcher<LHS>both(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when both of the specified matchers match the examined object.
      +
      static Matcher<java.math.BigDecimal>closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) +
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
      +
      static Matcher<java.lang.Double>closeTo(double operand, + double error) +
      Creates a matcher of Doubles 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>
      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 <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables 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>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      static Matcher<java.lang.String>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>either(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when either of the specified matchers match the examined object.
      +
      static <E> Matcher<java.util.Collection<? extends E>>empty() +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<E[]>emptyArray() +
      Creates a matcher for arrays that matches when the length of the array + is zero.
      +
      static <E> Matcher<java.util.Collection<E>>emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>emptyIterable() +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static <E> Matcher<java.lang.Iterable<E>>emptyIterableOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static Matcher<java.lang.String>emptyOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + has zero length.
      +
      static Matcher<java.lang.String>emptyString() +
      Creates a matcher of String that matches when the examined string has zero length.
      +
      static Matcher<java.lang.String>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.String>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>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.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static Matcher<java.util.EventObject>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>eventFrom(java.lang.Object source) +
      Creates a matcher of EventObject that matches any EventObject + announced by source.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps 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<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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<T[]>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[]>hasItemInArray(T element) +
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      +
      static <T> Matcher<java.lang.Iterable<T>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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 <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static <T> Matcher<T>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>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 <E> Matcher<java.util.Collection<? extends E>>hasSize(int size) +
      Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
      +
      static <E> Matcher<java.util.Collection<? extends E>>hasSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <T> Matcher<T>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(java.lang.String expectedToString) +
      Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<T> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static Matcher<java.lang.String>isEmptyOrNullString() +
      Deprecated.  +
      use is(emptyOrNullString()) instead
      +
      +
      static Matcher<java.lang.String>isEmptyString() +
      Deprecated.  +
      use is(emptyString()) instead
      +
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      static <E> Matcher<java.lang.Iterable<E>>iterableWithSize(int size) +
      Creates a matcher for Iterables 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>>iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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.
      +
      static Matcher<java.lang.String>matchesPattern(java.util.regex.Pattern pattern) +
      Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
      +
      static Matcher<java.lang.String>matchesPattern(java.lang.String regex) +
      Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Double>notANumber() +
      Creates a matcher of Doubles that matches when an examined double is not a number.
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      static <T> Matcher<T>sameInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <T> Matcher<T>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.
      +
      static Matcher<java.lang.String>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static Matcher<java.lang.String>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, considering the order of their appearance.
      +
      static Matcher<java.lang.String>stringContainsInOrder(java.lang.String... substrings) +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <T> Matcher<java.lang.Class<?>>typeCompatibleWith(java.lang.Class<T> baseType) +
      Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Matchers

        +
        public Matchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(Matcher<? super T> first,
        +                                   Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(Matcher<T> first,
        +                                 Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<T> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        array

        +
        public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> 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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/SelfDescribing.html b/docs/javadoc/2.0.0.0/org/hamcrest/SelfDescribing.html new file mode 100644 index 000000000..5e13a62d5 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/SelfDescribing.html @@ -0,0 +1,237 @@ + + + + + +SelfDescribing (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface SelfDescribing

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        void describeTo(Description description)
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/StringDescription.html b/docs/javadoc/2.0.0.0/org/hamcrest/StringDescription.html new file mode 100644 index 000000000..ca36fac25 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/StringDescription.html @@ -0,0 +1,417 @@ + + + + + +StringDescription (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class StringDescription

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription()
        +
      • +
      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription(java.lang.Appendable out)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        toString

        +
        public static java.lang.String toString(SelfDescribing selfDescribing)
        +
        Return the description of a SelfDescribing object as a String.
        +
        +
        Parameters:
        +
        selfDescribing - The object to be described.
        +
        Returns:
        +
        The description of the object.
        +
        +
      • +
      + + + + + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Description copied from class: BaseDescription
        +
        Append the String str to the description. + The default implementation passes every character to BaseDescription.append(char). + Override in subclasses to provide an efficient implementation.
        +
        +
        Overrides:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(char c)
        +
        Description copied from class: BaseDescription
        +
        Append the char c to the description.
        +
        +
        Specified by:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        Returns the description as a string.
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeDiagnosingMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..97de9c8c6 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,423 @@ + + + + + +TypeSafeDiagnosingMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeDiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item,
        +                                         Description mismatchDescription)
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeMatcher.html new file mode 100644 index 000000000..661155551 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/TypeSafeMatcher.html @@ -0,0 +1,432 @@ + + + + + +TypeSafeMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item)
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        protected void describeMismatchSafely(T item,
        +                                      Description mismatchDescription)
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Methods made final to prevent accidental override. + If you need to override this, there's no point on extending TypeSafeMatcher. + Instead, extend the BaseMatcher.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasProperty.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasProperty.html new file mode 100644 index 000000000..6896019b2 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasProperty.html @@ -0,0 +1,384 @@ + + + + + +HasProperty (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasProperty<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasProperty<T>
    +extends TypeSafeMatcher<T>
    +
    A Matcher that checks that an object has a JavaBean property + with the specified name. If an error occurs during introspection + of the object then this is treated as a mismatch.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasProperty

        +
        public HasProperty(java.lang.String propertyName)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T obj)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasPropertyWithValue.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasPropertyWithValue.html new file mode 100644 index 000000000..d809cc0d7 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/HasPropertyWithValue.html @@ -0,0 +1,408 @@ + + + + + +HasPropertyWithValue (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasPropertyWithValue<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasPropertyWithValue<T>
    +extends TypeSafeDiagnosingMatcher<T>
    +

    Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher. This is useful for when objects + are created within code under test and passed to a mock object, and you wish + to assert that the created object has certain properties. +

    + +

    Example Usage

    + Consider the situation where we have a class representing a person, which + follows the basic JavaBean convention of having get() and possibly set() + methods for it's properties: +
    + public class Person {
    +   private String name;
    +   public Person(String person) {
    +     this.person = person;
    +   }
    +   public String getName() {
    +     return name;
    +   }
    + }
    + + And that these person objects are generated within a piece of code under test + (a class named PersonGenerator). This object is sent to one of our mock objects + which overrides the PersonGenerationListener interface: +
    + public interface PersonGenerationListener {
    +   public void personGenerated(Person person);
    + }
    + + In order to check that the code under test generates a person with name + "Iain" we would do the following: +
    + Mock personGenListenerMock = mock(PersonGenerationListener.class);
    + personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
    + PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy();
    + +

    If an exception is thrown by the getter method for a property, the property + does not exist, is not readable, or a reflection related exception is thrown + when trying to invoke it then this is treated as an evaluation failure and + the matches method will return false. +

    +

    This matcher class will also work with JavaBean objects that have explicit + bean descriptions via an associated BeanInfo description class. See the + JavaBeans specification for more information: + http://java.sun.com/products/javabeans/docs/index.html +

    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasPropertyWithValue

        +
        public HasPropertyWithValue(java.lang.String propertyName,
        +                            Matcher<?> valueMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/PropertyUtil.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/PropertyUtil.html new file mode 100644 index 000000000..5b7a5d795 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/PropertyUtil.html @@ -0,0 +1,354 @@ + + + + + +PropertyUtil (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class PropertyUtil

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.beans.PropertyUtil
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class PropertyUtil
    +extends java.lang.Object
    +
    Utility class for accessing properties on JavaBean objects. + See http://java.sun.com/products/javabeans/docs/index.html for + more information on JavaBeans.
    +
    +
    Since:
    +
    1.1.0
    +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static java.lang.Object[]NO_ARGUMENTS 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      PropertyUtil() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static java.beans.PropertyDescriptorgetPropertyDescriptor(java.lang.String propertyName, + java.lang.Object fromObj) +
      Returns the description of the property with the provided + name on the provided object's interface.
      +
      static java.beans.PropertyDescriptor[]propertyDescriptorsFor(java.lang.Object fromObj, + java.lang.Class<java.lang.Object> stopClass) +
      Returns all the property descriptors for the class associated with the given object
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_ARGUMENTS

        +
        public static final java.lang.Object[] NO_ARGUMENTS
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        PropertyUtil

        +
        public PropertyUtil()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getPropertyDescriptor

        +
        public static java.beans.PropertyDescriptor getPropertyDescriptor(java.lang.String propertyName,
        +                                                                  java.lang.Object fromObj)
        +                                                           throws java.lang.IllegalArgumentException
        +
        Returns the description of the property with the provided + name on the provided object's interface.
        +
        +
        Returns:
        +
        the descriptor of the property, or null if the property does not exist.
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      + + + +
        +
      • +

        propertyDescriptorsFor

        +
        public static java.beans.PropertyDescriptor[] propertyDescriptorsFor(java.lang.Object fromObj,
        +                                                                     java.lang.Class<java.lang.Object> stopClass)
        +                                                              throws java.lang.IllegalArgumentException
        +
        Returns all the property descriptors for the class associated with the given object
        +
        +
        Parameters:
        +
        fromObj - Use the class of this object
        +
        stopClass - Don't include any properties from this ancestor class upwards.
        +
        Returns:
        +
        Property descriptors
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html new file mode 100644 index 000000000..dc44dffde --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.PropertyMatcher.html @@ -0,0 +1,332 @@ + + + + + +SamePropertyValuesAs.PropertyMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class SamePropertyValuesAs.PropertyMatcher

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        PropertyMatcher

        +
        public PropertyMatcher(java.beans.PropertyDescriptor descriptor,
        +                       java.lang.Object expectedObject)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.html new file mode 100644 index 000000000..fd54cb160 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/SamePropertyValuesAs.html @@ -0,0 +1,382 @@ + + + + + +SamePropertyValuesAs (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class SamePropertyValuesAs<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SamePropertyValuesAs

        +
        public SamePropertyValuesAs(T expectedBean)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-frame.html new file mode 100644 index 000000000..1503ecc10 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.beans (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.beans

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-summary.html new file mode 100644 index 000000000..0ce56cec6 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-summary.html @@ -0,0 +1,173 @@ + + + + + +org.hamcrest.beans (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.beans

+
+
Matchers of Java Bean properties and their values.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.beans Description

+

Matchers of Java Bean properties and their values.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-tree.html new file mode 100644 index 000000000..6f03a02a6 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/beans/package-tree.html @@ -0,0 +1,155 @@ + + + + + +org.hamcrest.beans Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.beans

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArray.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArray.html new file mode 100644 index 000000000..1b1af9598 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArray.html @@ -0,0 +1,440 @@ + + + + + +IsArray (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArray<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArray<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matcher for array whose elements satisfy a sequence of matchers. + The array size must equal the number of element matchers.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArray

        +
        public IsArray(Matcher<? super T>[] elementMatchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] array)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] actual,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        descriptionStart

        +
        protected java.lang.String descriptionStart()
        +
        Returns the string that starts the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionSeparator

        +
        protected java.lang.String descriptionSeparator()
        +
        Returns the string that separates the elements in the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionEnd

        +
        protected java.lang.String descriptionEnd()
        +
        Returns the string that ends the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        array

        +
        public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContaining.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContaining.html new file mode 100644 index 000000000..516367b24 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContaining.html @@ -0,0 +1,409 @@ + + + + + +IsArrayContaining (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContaining<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArrayContaining<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matches if an array contains an item satisfying a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContaining

        +
        public IsArrayContaining(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] array)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..f5a785ab1 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html @@ -0,0 +1,464 @@ + + + + + +IsArrayContainingInAnyOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInAnyOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInAnyOrder

        +
        public IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInOrder.html new file mode 100644 index 000000000..71e3463b0 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayContainingInOrder.html @@ -0,0 +1,434 @@ + + + + + +IsArrayContainingInOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInOrder

        +
        public IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayWithSize.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayWithSize.html new file mode 100644 index 000000000..f2ca57980 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsArrayWithSize.html @@ -0,0 +1,392 @@ + + + + + +IsArrayWithSize (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<E[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArrayWithSize<E>
    +extends FeatureMatcher<E[],java.lang.Integer>
    +
    Matches if array size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayWithSize

        +
        public IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(E[] actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<E[],java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsCollectionWithSize.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsCollectionWithSize.html new file mode 100644 index 000000000..de69caf22 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsCollectionWithSize.html @@ -0,0 +1,370 @@ + + + + + +IsCollectionWithSize (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsCollectionWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsCollectionWithSize<E>
    +extends FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
    +
    Matches if collection size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionWithSize

        +
        public IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Collection<? extends E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyCollection.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyCollection.html new file mode 100644 index 000000000..ffcc083b4 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyCollection.html @@ -0,0 +1,398 @@ + + + + + +IsEmptyCollection (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyCollection<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyCollection<E>
    +extends TypeSafeMatcher<java.util.Collection<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyCollection

        +
        public IsEmptyCollection()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Collection<? extends E> item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Collection<? extends E> item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyIterable.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyIterable.html new file mode 100644 index 000000000..36d3b3caf --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsEmptyIterable.html @@ -0,0 +1,394 @@ + + + + + +IsEmptyIterable (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyIterable<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyIterable<E>
    +extends TypeSafeMatcher<java.lang.Iterable<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyIterable

        +
        public IsEmptyIterable()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends E> iterable)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Iterable<? extends E> iter,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIn.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIn.html new file mode 100644 index 000000000..b3c96d735 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIn.html @@ -0,0 +1,500 @@ + + + + + +IsIn (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIn<T>

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      IsIn(java.util.Collection<T> collection) 
      IsIn(T[] elements) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description buffer) +
      Generates a description of the object.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      booleanmatches(java.lang.Object o) +
      Evaluates the matcher for argument item.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIn

        +
        public IsIn(java.util.Collection<T> collection)
        +
      • +
      + + + + + +
        +
      • +

        IsIn

        +
        public IsIn(T[] elements)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description buffer)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        buffer - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        @Deprecated
        +public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..6f22ba8d3 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html @@ -0,0 +1,442 @@ + + + + + +IsIterableContainingInAnyOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInAnyOrder<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends T> items, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInAnyOrder

        +
        public IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends T> items,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInOrder.html new file mode 100644 index 000000000..4ce7f5d5f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInOrder.html @@ -0,0 +1,441 @@ + + + + + +IsIterableContainingInOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInOrder

        +
        public IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html new file mode 100644 index 000000000..4771346cf --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html @@ -0,0 +1,413 @@ + + + + + +IsIterableContainingInRelativeOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInRelativeOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInRelativeOrder

        +
        public IsIterableContainingInRelativeOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableWithSize.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableWithSize.html new file mode 100644 index 000000000..8a01d0b72 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsIterableWithSize.html @@ -0,0 +1,373 @@ + + + + + +IsIterableWithSize (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<E>>, SelfDescribing
    +
    +
    +
    +
    public class IsIterableWithSize<E>
    +extends FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableWithSize

        +
        public IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.lang.Iterable<E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapContaining.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapContaining.html new file mode 100644 index 000000000..230e408b3 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapContaining.html @@ -0,0 +1,515 @@ + + + + + +IsMapContaining (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapContaining<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public class IsMapContaining<K,V>
    +extends TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatchSafely(java.util.Map<? extends K,? extends V> map, + Description mismatchDescription) +
      Subclasses should override this.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
      +
      static <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      booleanmatchesSafely(java.util.Map<? extends K,? extends V> map) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapContaining

        +
        public IsMapContaining(Matcher<? super K> keyMatcher,
        +                       Matcher<? super V> valueMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Map<? extends K,? extends V> map)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Map<? extends K,? extends V> map,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapWithSize.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapWithSize.html new file mode 100644 index 000000000..e728e7a09 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/IsMapWithSize.html @@ -0,0 +1,390 @@ + + + + + +IsMapWithSize (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapWithSize<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public final class IsMapWithSize<K,V>
    +extends FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
    +
    Matches if map size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapWithSize

        +
        public IsMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Map<? extends K,? extends V> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-frame.html new file mode 100644 index 000000000..a7959e6ec --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-frame.html @@ -0,0 +1,34 @@ + + + + + +org.hamcrest.collection (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.collection

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-summary.html new file mode 100644 index 000000000..2e4fa2f94 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-summary.html @@ -0,0 +1,219 @@ + + + + + +org.hamcrest.collection (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.collection

+
+
Matchers of arrays and collections.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.collection Description

+

Matchers of arrays and collections.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-tree.html new file mode 100644 index 000000000..1969ec30f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/collection/package-tree.html @@ -0,0 +1,165 @@ + + + + + +org.hamcrest.collection Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.collection

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html new file mode 100644 index 000000000..5896a364c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html @@ -0,0 +1,406 @@ + + + + + +ComparatorMatcherBuilder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.comparator
+

Class ComparatorMatcherBuilder<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.comparator.ComparatorMatcherBuilder<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class ComparatorMatcherBuilder<T>
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> ComparatorMatcherBuilder<T>comparedBy(java.util.Comparator<T> comparator) +
      Creates a matcher factory for matchers of Comparatorss of T.
      +
      Matcher<T>comparesEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThan(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThan(T value) +
      Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      static <T extends java.lang.Comparable<T>>
      ComparatorMatcherBuilder<T>
      usingNaturalOrdering() +
      Creates a matcher factory for matchers of Comparables.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        usingNaturalOrdering

        +
        public static <T extends java.lang.Comparable<T>> ComparatorMatcherBuilder<T> usingNaturalOrdering()
        +
        Creates a matcher factory for matchers of Comparables. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
      • +
      + + + +
        +
      • +

        comparedBy

        +
        public static <T> ComparatorMatcherBuilder<T> comparedBy(java.util.Comparator<T> comparator)
        +
        Creates a matcher factory for matchers of Comparatorss of T. + For example: +
        assertThat(5, comparedBy(new Comparator<Integer>() {
        + public int compare(Integer o1, Integer o2) {
        + return -o1.compareTo(o2);
        + }
        + }).lessThan(4))
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public Matcher<T> comparesEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public Matcher<T> greaterThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(2, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public Matcher<T> greaterThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public Matcher<T> lessThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public Matcher<T> lessThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-frame.html new file mode 100644 index 000000000..2776c536d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.comparator (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.comparator

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-summary.html new file mode 100644 index 000000000..beb9a7273 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-summary.html @@ -0,0 +1,140 @@ + + + + + +org.hamcrest.comparator (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.comparator

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-tree.html new file mode 100644 index 000000000..914b91046 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/comparator/package-tree.html @@ -0,0 +1,135 @@ + + + + + +org.hamcrest.comparator Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.comparator

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/AllOf.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/AllOf.html new file mode 100644 index 000000000..bcffcf387 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/AllOf.html @@ -0,0 +1,365 @@ + + + + + +AllOf (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AllOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AllOf<T>
    +extends DiagnosingMatcher<T>
    +
    Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns false.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AllOf

        +
        public AllOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/AnyOf.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/AnyOf.html new file mode 100644 index 000000000..20856eda6 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/AnyOf.html @@ -0,0 +1,398 @@ + + + + + +AnyOf (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AnyOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AnyOf<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns true.
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      AnyOf(java.lang.Iterable<Matcher<? super T>> matchers) 
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AnyOf

        +
        public AnyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Specified by:
        +
        matches in interface Matcher<T>
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected boolean matches(java.lang.Object o,
        +                          boolean shortcut)
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description,
        +                       java.lang.String operator)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..82abfd659 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableBothMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableBothMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableBothMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..7e31ac30c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableEitherMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableEitherMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableEitherMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.html new file mode 100644 index 000000000..6309a2e7d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/CombinableMatcher.html @@ -0,0 +1,418 @@ + + + + + +CombinableMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CombinableMatcher

        +
        public CombinableMatcher(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + + + + + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/DescribedAs.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/DescribedAs.html new file mode 100644 index 000000000..cdc52121c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/DescribedAs.html @@ -0,0 +1,391 @@ + + + + + +DescribedAs (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class DescribedAs<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class DescribedAs<T>
    +extends BaseMatcher<T>
    +
    Provides a custom description to another matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DescribedAs

        +
        public DescribedAs(java.lang.String descriptionTemplate,
        +                   Matcher<T> matcher,
        +                   java.lang.Object[] values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/Every.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/Every.html new file mode 100644 index 000000000..c2dafdd85 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/Every.html @@ -0,0 +1,357 @@ + + + + + +Every (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Every<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Every

        +
        public Every(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends T> collection,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/Is.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/Is.html new file mode 100644 index 000000000..d756485ea --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/Is.html @@ -0,0 +1,426 @@ + + + + + +Is (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Is<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class Is<T>
    +extends BaseMatcher<T>
    +
    Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive. + + For example: assertThat(cheese, equalTo(smelly)) + vs. assertThat(cheese, is(equalTo(smelly)))
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Is(Matcher<T> matcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) +
      Generate a description of why the matcher has not accepted the item.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<T>is(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<T> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      booleanmatches(java.lang.Object arg) +
      Evaluates the matcher for argument item.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Is

        +
        public Is(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<T> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsAnything.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsAnything.html new file mode 100644 index 000000000..3d360634c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsAnything.html @@ -0,0 +1,376 @@ + + + + + +IsAnything (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsAnything<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsAnything<T>
    +extends BaseMatcher<T>
    +
    A matcher that always returns true.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything()
        +
      • +
      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything(java.lang.String message)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsCollectionContaining.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsCollectionContaining.html new file mode 100644 index 000000000..68612a323 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsCollectionContaining.html @@ -0,0 +1,445 @@ + + + + + +IsCollectionContaining (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsCollectionContaining<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? super T> collection, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionContaining

        +
        public IsCollectionContaining(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsEqual.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsEqual.html new file mode 100644 index 000000000..230728037 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsEqual.html @@ -0,0 +1,385 @@ + + + + + +IsEqual (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsEqual<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsEqual<T>
    +extends BaseMatcher<T>
    +
    Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsEqual(T equalArg) 
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsEqual

        +
        public IsEqual(T equalArg)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object actualValue)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        actualValue - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsInstanceOf.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsInstanceOf.html new file mode 100644 index 000000000..0a4d495a9 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsInstanceOf.html @@ -0,0 +1,386 @@ + + + + + +IsInstanceOf (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsInstanceOf

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Object>, SelfDescribing
    +
    +
    +
    +
    public class IsInstanceOf
    +extends DiagnosingMatcher<java.lang.Object>
    +
    Tests whether the value is an instance of a class. + Classes of basic types will be converted to the relevant "Object" classes
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsInstanceOf(java.lang.Class<?> expectedClass) +
      Creates a new instance of IsInstanceOf
      +
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<T>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.
      +
      protected booleanmatches(java.lang.Object item, + Description mismatch) 
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsInstanceOf

        +
        public IsInstanceOf(java.lang.Class<?> expectedClass)
        +
        Creates a new instance of IsInstanceOf
        +
        +
        Parameters:
        +
        expectedClass - The predicate evaluates to true for instances of this class + or one of its subclasses.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNot.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNot.html new file mode 100644 index 000000000..1fd050e0d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNot.html @@ -0,0 +1,376 @@ + + + + + +IsNot (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNot<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsNot<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical negation of a matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNot

        +
        public IsNot(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNull.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNull.html new file mode 100644 index 000000000..a42a1e881 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsNull.html @@ -0,0 +1,412 @@ + + + + + +IsNull (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNull<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNull

        +
        public IsNull()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/IsSame.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsSame.html new file mode 100644 index 000000000..ffc5fb725 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/IsSame.html @@ -0,0 +1,376 @@ + + + + + +IsSame (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsSame<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsSame<T>
    +extends BaseMatcher<T>
    +
    Is the value the same object as another value?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsSame

        +
        public IsSame(T object)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/StringContains.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringContains.html new file mode 100644 index 000000000..1b2154edd --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringContains.html @@ -0,0 +1,379 @@ + + + + + +StringContains (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringContains

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringContains
    +extends SubstringMatcher
    +
    Tests if the argument is a string that contains a substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContains

        +
        public StringContains(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/StringEndsWith.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringEndsWith.html new file mode 100644 index 000000000..f4a404826 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringEndsWith.html @@ -0,0 +1,379 @@ + + + + + +StringEndsWith (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringEndsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringEndsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that contains a substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringEndsWith

        +
        public StringEndsWith(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/StringStartsWith.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringStartsWith.html new file mode 100644 index 000000000..388619a8f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/StringStartsWith.html @@ -0,0 +1,385 @@ + + + + + +StringStartsWith (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringStartsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringStartsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that contains a substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringStartsWith

        +
        public StringStartsWith(boolean ignoringCase,
        +                        java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/SubstringMatcher.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/SubstringMatcher.html new file mode 100644 index 000000000..9514dc0f5 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/SubstringMatcher.html @@ -0,0 +1,425 @@ + + + + + +SubstringMatcher (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class SubstringMatcher

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        substring

        +
        protected final java.lang.String substring
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SubstringMatcher

        +
        protected SubstringMatcher(java.lang.String relationship,
        +                           boolean ignoringCase,
        +                           java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        converted

        +
        protected java.lang.String converted(java.lang.String arg)
        +
      • +
      + + + +
        +
      • +

        evalSubstringOf

        +
        protected abstract boolean evalSubstringOf(java.lang.String string)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-frame.html new file mode 100644 index 000000000..19d46e029 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-frame.html @@ -0,0 +1,38 @@ + + + + + +org.hamcrest.core (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.core

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-summary.html new file mode 100644 index 000000000..43e1b16fb --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-summary.html @@ -0,0 +1,249 @@ + + + + + +org.hamcrest.core (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.core

+
+
Fundamental matchers of objects and values, and composite matchers.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    AllOf<T> +
    Calculates the logical conjunction of multiple matchers.
    +
    AnyOf<T> +
    Calculates the logical disjunction of multiple matchers.
    +
    CombinableMatcher<T> 
    CombinableMatcher.CombinableBothMatcher<X> 
    CombinableMatcher.CombinableEitherMatcher<X> 
    DescribedAs<T> +
    Provides a custom description to another matcher.
    +
    Every<T> 
    Is<T> +
    Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
    +
    IsAnything<T> +
    A matcher that always returns true.
    +
    IsCollectionContaining<T> 
    IsEqual<T> +
    Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
    +
    IsInstanceOf +
    Tests whether the value is an instance of a class.
    +
    IsNot<T> +
    Calculates the logical negation of a matcher.
    +
    IsNull<T> +
    Is the value null?
    +
    IsSame<T> +
    Is the value the same object as another value?
    +
    StringContains +
    Tests if the argument is a string that contains a substring.
    +
    StringEndsWith +
    Tests if the argument is a string that contains a substring.
    +
    StringStartsWith +
    Tests if the argument is a string that contains a substring.
    +
    SubstringMatcher 
    +
  • +
+ + + +

Package org.hamcrest.core Description

+

Fundamental matchers of objects and values, and composite matchers.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/core/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-tree.html new file mode 100644 index 000000000..ab0956106 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/core/package-tree.html @@ -0,0 +1,172 @@ + + + + + +org.hamcrest.core Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.core

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/ArrayIterator.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/ArrayIterator.html new file mode 100644 index 000000000..cc78093e4 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/ArrayIterator.html @@ -0,0 +1,319 @@ + + + + + +ArrayIterator (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ArrayIterator

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ArrayIterator
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<java.lang.Object>
    +
    +
    +
    +
    public class ArrayIterator
    +extends java.lang.Object
    +implements java.util.Iterator<java.lang.Object>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ArrayIterator(java.lang.Object array) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      java.lang.Objectnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayIterator

        +
        public ArrayIterator(java.lang.Object array)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        next

        +
        public java.lang.Object next()
        +
        +
        Specified by:
        +
        next in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/NullSafety.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/NullSafety.html new file mode 100644 index 000000000..e9b8d65aa --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/NullSafety.html @@ -0,0 +1,269 @@ + + + + + +NullSafety (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class NullSafety

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.NullSafety
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class NullSafety
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      NullSafety() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> java.util.List<Matcher<? super E>>nullSafe(Matcher<? super E>[] itemMatchers) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullSafety

        +
        public NullSafety()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        nullSafe

        +
        public static <E> java.util.List<Matcher<? super E>> nullSafe(Matcher<? super E>[] itemMatchers)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/ReflectiveTypeFinder.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/ReflectiveTypeFinder.html new file mode 100644 index 000000000..82bafa0b5 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/ReflectiveTypeFinder.html @@ -0,0 +1,311 @@ + + + + + +ReflectiveTypeFinder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ReflectiveTypeFinder

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ReflectiveTypeFinder
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class ReflectiveTypeFinder
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ReflectiveTypeFinder(java.lang.String methodName, + int expectedNumberOfParameters, + int typedParameter) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      protected booleancanObtainExpectedTypeFrom(java.lang.reflect.Method method) 
      protected java.lang.Class<?>expectedTypeFrom(java.lang.reflect.Method method) 
      java.lang.Class<?>findExpectedType(java.lang.Class<?> fromClass) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ReflectiveTypeFinder

        +
        public ReflectiveTypeFinder(java.lang.String methodName,
        +                            int expectedNumberOfParameters,
        +                            int typedParameter)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        findExpectedType

        +
        public java.lang.Class<?> findExpectedType(java.lang.Class<?> fromClass)
        +
      • +
      + + + +
        +
      • +

        canObtainExpectedTypeFrom

        +
        protected boolean canObtainExpectedTypeFrom(java.lang.reflect.Method method)
        +
        +
        Parameters:
        +
        method - The method to examine.
        +
        Returns:
        +
        true if this method references the relevant type
        +
        +
      • +
      + + + +
        +
      • +

        expectedTypeFrom

        +
        protected java.lang.Class<?> expectedTypeFrom(java.lang.reflect.Method method)
        +
        +
        Parameters:
        +
        method - The method from which to extract
        +
        Returns:
        +
        The type we're looking for
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValue.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValue.html new file mode 100644 index 000000000..3ad1defaa --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValue.html @@ -0,0 +1,288 @@ + + + + + +SelfDescribingValue (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValue<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValue<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    SelfDescribing
    +
    +
    +
    +
    public class SelfDescribingValue<T>
    +extends java.lang.Object
    +implements SelfDescribing
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      SelfDescribingValue(T value) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SelfDescribingValue

        +
        public SelfDescribingValue(T value)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValueIterator.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValueIterator.html new file mode 100644 index 000000000..42424e8dc --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/SelfDescribingValueIterator.html @@ -0,0 +1,319 @@ + + + + + +SelfDescribingValueIterator (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValueIterator<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValueIterator<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<SelfDescribing>
    +
    +
    +
    +
    public class SelfDescribingValueIterator<T>
    +extends java.lang.Object
    +implements java.util.Iterator<SelfDescribing>
    +
  • +
+
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      SelfDescribingnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SelfDescribingValueIterator

        +
        public SelfDescribingValueIterator(java.util.Iterator<T> values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      + + + + + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-frame.html new file mode 100644 index 000000000..505ca1659 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.internal (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.internal

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-summary.html new file mode 100644 index 000000000..fd11a7ab1 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-summary.html @@ -0,0 +1,156 @@ + + + + + +org.hamcrest.internal (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.internal

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-tree.html new file mode 100644 index 000000000..afb392a2e --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/internal/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.internal Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.internal

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.FileStatus.html b/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.FileStatus.html new file mode 100644 index 000000000..c8578482d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.FileStatus.html @@ -0,0 +1,223 @@ + + + + + +FileMatchers.FileStatus (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Interface FileMatchers.FileStatus

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    FileMatchers
    +
    +
    +
    +
    public static interface FileMatchers.FileStatus
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        check

        +
        boolean check(java.io.File actual)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.html b/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.html new file mode 100644 index 000000000..c5a3825ba --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/io/FileMatchers.html @@ -0,0 +1,493 @@ + + + + + +FileMatchers (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Class FileMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.io.FileMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class FileMatchers
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FileMatchers

        +
        public FileMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        anExistingDirectory

        +
        public static Matcher<java.io.File> anExistingDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFileOrDirectory

        +
        public static Matcher<java.io.File> anExistingFileOrDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFile

        +
        public static Matcher<java.io.File> anExistingFile()
        +
      • +
      + + + +
        +
      • +

        aReadableFile

        +
        public static Matcher<java.io.File> aReadableFile()
        +
      • +
      + + + +
        +
      • +

        aWritableFile

        +
        public static Matcher<java.io.File> aWritableFile()
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(long size)
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(Matcher<java.lang.Long> expected)
        +
      • +
      + + + +
        +
      • +

        aFileNamed

        +
        public static Matcher<java.io.File> aFileNamed(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithCanonicalPath

        +
        public static Matcher<java.io.File> aFileWithCanonicalPath(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithAbsolutePath

        +
        public static Matcher<java.io.File> aFileWithAbsolutePath(Matcher<java.lang.String> expected)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/io/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-frame.html new file mode 100644 index 000000000..96efe59a9 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.io (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.io

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/io/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-summary.html new file mode 100644 index 000000000..b89df8d02 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-summary.html @@ -0,0 +1,155 @@ + + + + + +org.hamcrest.io (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.io

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/io/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-tree.html new file mode 100644 index 000000000..9f021fff4 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/io/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.io Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.io

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/BigDecimalCloseTo.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/BigDecimalCloseTo.html new file mode 100644 index 000000000..9961d07ca --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/BigDecimalCloseTo.html @@ -0,0 +1,383 @@ + + + + + +BigDecimalCloseTo (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class BigDecimalCloseTo

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BigDecimalCloseTo

        +
        public BigDecimalCloseTo(java.math.BigDecimal value,
        +                         java.math.BigDecimal error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.math.BigDecimal item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.math.BigDecimal item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/IsCloseTo.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/IsCloseTo.html new file mode 100644 index 000000000..bf2f3da52 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/IsCloseTo.html @@ -0,0 +1,384 @@ + + + + + +IsCloseTo (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsCloseTo

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public class IsCloseTo
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number equal to a value within some range of + acceptable error?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCloseTo

        +
        public IsCloseTo(double value,
        +                 double error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/IsNaN.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/IsNaN.html new file mode 100644 index 000000000..6a8b45d3d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/IsNaN.html @@ -0,0 +1,338 @@ + + + + + +IsNaN (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsNaN

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public final class IsNaN
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number actually not a number (NaN)?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/OrderingComparison.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/OrderingComparison.html new file mode 100644 index 000000000..bdd070693 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/OrderingComparison.html @@ -0,0 +1,366 @@ + + + + + +OrderingComparison (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class OrderingComparison

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.number.OrderingComparison
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class OrderingComparison
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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>
      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>
      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>
      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.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-frame.html new file mode 100644 index 000000000..1a76762b3 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.number (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.number

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-summary.html new file mode 100644 index 000000000..e4062aa7b --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-summary.html @@ -0,0 +1,166 @@ + + + + + +org.hamcrest.number (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.number

+
+
Matchers that perform numeric comparisons.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    BigDecimalCloseTo 
    IsCloseTo +
    Is the value a number equal to a value within some range of + acceptable error?
    +
    IsNaN +
    Is the value a number actually not a number (NaN)?
    +
    OrderingComparison 
    +
  • +
+ + + +

Package org.hamcrest.number Description

+

Matchers that perform numeric comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/number/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-tree.html new file mode 100644 index 000000000..cdd89dc5f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/number/package-tree.html @@ -0,0 +1,146 @@ + + + + + +org.hamcrest.number Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.number

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/HasToString.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/HasToString.html new file mode 100644 index 000000000..ef0a08436 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/HasToString.html @@ -0,0 +1,371 @@ + + + + + +HasToString (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class HasToString<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasToString

        +
        public HasToString(Matcher<? super java.lang.String> toStringMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.String featureValueOf(T actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<T,java.lang.String>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/IsCompatibleType.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/IsCompatibleType.html new file mode 100644 index 000000000..760dea516 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/IsCompatibleType.html @@ -0,0 +1,377 @@ + + + + + +IsCompatibleType (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsCompatibleType<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCompatibleType

        +
        public IsCompatibleType(java.lang.Class<T> type)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Class<?> cls)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Class<?> cls,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/IsEventFrom.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/IsEventFrom.html new file mode 100644 index 000000000..60544da18 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/IsEventFrom.html @@ -0,0 +1,385 @@ + + + + + +IsEventFrom (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsEventFrom

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.EventObject>, SelfDescribing
    +
    +
    +
    +
    public class IsEventFrom
    +extends TypeSafeDiagnosingMatcher<java.util.EventObject>
    +
    Tests if the value is an event announced by a specific object.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEventFrom

        +
        public IsEventFrom(java.lang.Class<?> eventClass,
        +                   java.lang.Object source)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.EventObject item,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.util.EventObject>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-frame.html new file mode 100644 index 000000000..d350cd907 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-frame.html @@ -0,0 +1,22 @@ + + + + + +org.hamcrest.object (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.object

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-summary.html new file mode 100644 index 000000000..5375a99db --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-summary.html @@ -0,0 +1,159 @@ + + + + + +org.hamcrest.object (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.object

+
+
Matchers that inspect objects and classes.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasToString<T> 
    IsCompatibleType<T> 
    IsEventFrom +
    Tests if the value is an event announced by a specific object.
    +
    +
  • +
+ + + +

Package org.hamcrest.object Description

+

Matchers that inspect objects and classes.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/object/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-tree.html new file mode 100644 index 000000000..be365e290 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/object/package-tree.html @@ -0,0 +1,153 @@ + + + + + +org.hamcrest.object Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.object

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/package-frame.html new file mode 100644 index 000000000..bbbad77c8 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/package-frame.html @@ -0,0 +1,40 @@ + + + + + +org.hamcrest (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/package-summary.html new file mode 100644 index 000000000..b04272f6d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/package-summary.html @@ -0,0 +1,247 @@ + + + + + +org.hamcrest (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/package-tree.html new file mode 100644 index 000000000..ff799c21d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/package-tree.html @@ -0,0 +1,170 @@ + + + + + +org.hamcrest Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/IsBlankString.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsBlankString.html new file mode 100644 index 000000000..611e6ac5c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsBlankString.html @@ -0,0 +1,336 @@ + + + + + +IsBlankString (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsBlankString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsBlankString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches blank Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEmptyString.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEmptyString.html new file mode 100644 index 000000000..d89eb071f --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEmptyString.html @@ -0,0 +1,379 @@ + + + + + +IsEmptyString (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEmptyString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsEmptyString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches empty Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringCase.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringCase.html new file mode 100644 index 000000000..1cb976a6a --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringCase.html @@ -0,0 +1,378 @@ + + + + + +IsEqualIgnoringCase (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualIgnoringCase

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualIgnoringCase
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, regardless of the case.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualIgnoringCase

        +
        public IsEqualIgnoringCase(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html new file mode 100644 index 000000000..93d1b74d5 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/IsEqualIgnoringWhiteSpace.html @@ -0,0 +1,396 @@ + + + + + +IsEqualIgnoringWhiteSpace (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualIgnoringWhiteSpace

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualIgnoringWhiteSpace
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, ignoring any changes in whitespace.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualIgnoringWhiteSpace

        +
        public IsEqualIgnoringWhiteSpace(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stripSpace

        +
        public java.lang.String stripSpace(java.lang.String toBeStripped)
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> 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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/MatchesPattern.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/MatchesPattern.html new file mode 100644 index 000000000..429857869 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/MatchesPattern.html @@ -0,0 +1,365 @@ + + + + + +MatchesPattern (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class MatchesPattern

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatchesPattern

        +
        public MatchesPattern(java.util.regex.Pattern pattern)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/StringContainsInOrder.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/StringContainsInOrder.html new file mode 100644 index 000000000..6b85765be --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/StringContainsInOrder.html @@ -0,0 +1,403 @@ + + + + + +StringContainsInOrder (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class StringContainsInOrder

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContainsInOrder

        +
        public StringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String s)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-frame.html new file mode 100644 index 000000000..3b2d0b9ae --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-frame.html @@ -0,0 +1,25 @@ + + + + + +org.hamcrest.text (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.text

+ + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-summary.html new file mode 100644 index 000000000..448ba4d9c --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-summary.html @@ -0,0 +1,177 @@ + + + + + +org.hamcrest.text (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.text

+
+
Matchers that perform text comparisons.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.text Description

+

Matchers that perform text comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/text/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-tree.html new file mode 100644 index 000000000..d3c5a678d --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/text/package-tree.html @@ -0,0 +1,148 @@ + + + + + +org.hamcrest.text Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.text

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/xml/HasXPath.html b/docs/javadoc/2.0.0.0/org/hamcrest/xml/HasXPath.html new file mode 100644 index 000000000..9800eb444 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/xml/HasXPath.html @@ -0,0 +1,509 @@ + + + + + +HasXPath (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + + +
+
org.hamcrest.xml
+

Class HasXPath

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<org.w3c.dom.Node>, SelfDescribing
    +
    +
    +
    +
    public class HasXPath
    +extends TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
    +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static javax.xml.namespace.NamespaceContextNO_NAMESPACE_CONTEXT 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      HasXPath(java.lang.String xPathExpression, + Matcher<java.lang.String> valueMatcher) 
      HasXPath(java.lang.String xPathExpression, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      booleanmatchesSafely(org.w3c.dom.Node item, + Description mismatch) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_NAMESPACE_CONTEXT

        +
        public static final javax.xml.namespace.NamespaceContext NO_NAMESPACE_CONTEXT
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                javax.xml.namespace.NamespaceContext namespaceContext,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        namespaceContext - Resolves XML namespace prefixes in the XPath expression
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(org.w3c.dom.Node item,
        +                             Description mismatch)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-frame.html b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-frame.html new file mode 100644 index 000000000..704d957b1 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.xml (JavaHamcrest 2.0.0.0 API) + + + + + +

org.hamcrest.xml

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-summary.html b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-summary.html new file mode 100644 index 000000000..25b4a6c06 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-summary.html @@ -0,0 +1,151 @@ + + + + + +org.hamcrest.xml (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Package org.hamcrest.xml

+
+
Matchers of XML documents.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasXPath +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
    +
  • +
+ + + +

Package org.hamcrest.xml Description

+

Matchers of XML documents.

+
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-tree.html b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-tree.html new file mode 100644 index 000000000..e506f9082 --- /dev/null +++ b/docs/javadoc/2.0.0.0/org/hamcrest/xml/package-tree.html @@ -0,0 +1,143 @@ + + + + + +org.hamcrest.xml Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.xml

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.0.0.0/overview-frame.html b/docs/javadoc/2.0.0.0/overview-frame.html new file mode 100644 index 000000000..af4d3f566 --- /dev/null +++ b/docs/javadoc/2.0.0.0/overview-frame.html @@ -0,0 +1,31 @@ + + + + + +Overview List (JavaHamcrest 2.0.0.0 API) + + + + + + + +

 

+ + diff --git a/docs/javadoc/2.0.0.0/overview-summary.html b/docs/javadoc/2.0.0.0/overview-summary.html new file mode 100644 index 000000000..c7a7ccb8d --- /dev/null +++ b/docs/javadoc/2.0.0.0/overview-summary.html @@ -0,0 +1,190 @@ + + + + + +Overview (JavaHamcrest 2.0.0.0 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

JavaHamcrest 2.0.0.0 API

+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Packages 
PackageDescription
org.hamcrest 
org.hamcrest.beans +
Matchers of Java Bean properties and their values.
+
org.hamcrest.collection +
Matchers of arrays and collections.
+
org.hamcrest.comparator 
org.hamcrest.core +
Fundamental matchers of objects and values, and composite matchers.
+
org.hamcrest.internal 
org.hamcrest.io 
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.
+
+
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.0.0.0/overview-tree.html b/docs/javadoc/2.0.0.0/overview-tree.html new file mode 100644 index 000000000..2362e5985 --- /dev/null +++ b/docs/javadoc/2.0.0.0/overview-tree.html @@ -0,0 +1,250 @@ + + + + + +Class Hierarchy (JavaHamcrest 2.0.0.0 API) + + + + + + + + +
+ + + + + + + +
+ + + +
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.0.0.0/package-list b/docs/javadoc/2.0.0.0/package-list new file mode 100644 index 000000000..37d7af536 --- /dev/null +++ b/docs/javadoc/2.0.0.0/package-list @@ -0,0 +1,11 @@ +org.hamcrest +org.hamcrest.beans +org.hamcrest.collection +org.hamcrest.comparator +org.hamcrest.core +org.hamcrest.internal +org.hamcrest.io +org.hamcrest.number +org.hamcrest.object +org.hamcrest.text +org.hamcrest.xml diff --git a/docs/javadoc/2.0.0.0/script.js b/docs/javadoc/2.0.0.0/script.js new file mode 100644 index 000000000..b34635693 --- /dev/null +++ b/docs/javadoc/2.0.0.0/script.js @@ -0,0 +1,30 @@ +function show(type) +{ + count = 0; + for (var key in methods) { + var row = document.getElementById(key); + if ((methods[key] & type) != 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) +{ + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} diff --git a/docs/javadoc/2.0.0.0/stylesheet.css b/docs/javadoc/2.0.0.0/stylesheet.css new file mode 100644 index 000000000..cebb4fd8d --- /dev/null +++ b/docs/javadoc/2.0.0.0/stylesheet.css @@ -0,0 +1,574 @@ +/* Javadoc style sheet */ +/* +Overall document style +*/ + +@import url('resources/fonts/dejavu.css'); + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a:hover, a:focus { + text-decoration:none; + color:#bb7a2a; +} +a:active { + text-decoration:none; + color:#4A6782; +} +a[name] { + color:#353833; +} +a[name]:hover { + text-decoration:none; + color:#353833; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} +/* +Document title and Copyright styles +*/ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* +Navigation bar styles +*/ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.subNavList li{ + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* +Page header and footer styles +*/ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexHeader { + margin:10px; + position:relative; +} +.indexHeader span{ + margin-right:15px; +} +.indexHeader h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* +Heading styles +*/ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* +Page layout container styles +*/ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Sans Mono',monospace; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* +List styles +*/ +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* +Table styles +*/ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary { + width:100%; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited { + color:#FFFFFF; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; + +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td { + text-align:left; + padding:0px 0px 12px 10px; + width:100%; +} +th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th, +td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{ + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colLast, th.colOne, .constantsSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + white-space:nowrap; + font-size:13px; +} +td.colLast, th.colLast { + font-size:13px; +} +td.colOne, th.colOne { + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.overviewSummary td.colOne, .overviewSummary th.colOne, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colOne, .memberSummary th.colOne, +.typeSummary td.colFirst{ + width:25%; + vertical-align:top; +} +td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor { + background-color:#FFFFFF; +} +.rowColor { + background-color:#EEEEEF; +} +/* +Content styles +*/ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} + +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} + +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} + +td.colLast div { + padding-top:0px; +} + + +td.colLast a { + padding-bottom:3px; +} +/* +Formatting effect styles +*/ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink, +.overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel, +.seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} + +div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} + +div.contentContainer ul.blockList li.blockList h2{ + padding-bottom:0px; +} diff --git a/docs/javadoc/2.1/allclasses-frame.html b/docs/javadoc/2.1/allclasses-frame.html new file mode 100644 index 000000000..e92aacf72 --- /dev/null +++ b/docs/javadoc/2.1/allclasses-frame.html @@ -0,0 +1,102 @@ + + + + + +All Classes (Hamcrest 2.1 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.1/allclasses-noframe.html b/docs/javadoc/2.1/allclasses-noframe.html new file mode 100644 index 000000000..f19f045f0 --- /dev/null +++ b/docs/javadoc/2.1/allclasses-noframe.html @@ -0,0 +1,102 @@ + + + + + +All Classes (Hamcrest 2.1 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.1/constant-values.html b/docs/javadoc/2.1/constant-values.html new file mode 100644 index 000000000..cba88bac3 --- /dev/null +++ b/docs/javadoc/2.1/constant-values.html @@ -0,0 +1,122 @@ + + + + + +Constant Field Values (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Constant Field Values

+

Contents

+
+ + + + + + diff --git a/docs/javadoc/2.1/deprecated-list.html b/docs/javadoc/2.1/deprecated-list.html new file mode 100644 index 000000000..98c50cd48 --- /dev/null +++ b/docs/javadoc/2.1/deprecated-list.html @@ -0,0 +1,290 @@ + + + + + +Deprecated List (Hamcrest 2.1 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

Deprecated API

+

Contents

+ +
+
+ + + + + + + +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.1/help-doc.html b/docs/javadoc/2.1/help-doc.html new file mode 100644 index 000000000..09176b9b3 --- /dev/null +++ b/docs/javadoc/2.1/help-doc.html @@ -0,0 +1,223 @@ + + + + + +API Help (Hamcrest 2.1 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

How This API Document Is Organized

+
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+
+
+
    +
  • +

    Overview

    +

    The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

    +
  • +
  • +

    Package

    +

    Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:

    +
      +
    • Interfaces (italic)
    • +
    • Classes
    • +
    • Enums
    • +
    • Exceptions
    • +
    • Errors
    • +
    • Annotation Types
    • +
    +
  • +
  • +

    Class/Interface

    +

    Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:

    +
      +
    • Class inheritance diagram
    • +
    • Direct Subclasses
    • +
    • All Known Subinterfaces
    • +
    • All Known Implementing Classes
    • +
    • Class/interface declaration
    • +
    • Class/interface description
    • +
    +
      +
    • Nested Class Summary
    • +
    • Field Summary
    • +
    • Constructor Summary
    • +
    • Method Summary
    • +
    +
      +
    • Field Detail
    • +
    • Constructor Detail
    • +
    • Method Detail
    • +
    +

    Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.

    +
  • +
  • +

    Annotation Type

    +

    Each annotation type has its own separate page with the following sections:

    +
      +
    • Annotation Type declaration
    • +
    • Annotation Type description
    • +
    • Required Element Summary
    • +
    • Optional Element Summary
    • +
    • Element Detail
    • +
    +
  • +
  • +

    Enum

    +

    Each enum has its own separate page with the following sections:

    +
      +
    • Enum declaration
    • +
    • Enum description
    • +
    • Enum Constant Summary
    • +
    • Enum Constant Detail
    • +
    +
  • +
  • +

    Tree (Class Hierarchy)

    +

    There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.

    +
      +
    • When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
    • +
    • When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
    • +
    +
  • +
  • +

    Deprecated API

    +

    The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.

    +
  • +
  • +

    Index

    +

    The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.

    +
  • +
  • +

    Prev/Next

    +

    These links take you to the next or previous class, interface, package, or related page.

    +
  • +
  • +

    Frames/No Frames

    +

    These links show and hide the HTML frames. All pages are available with or without frames.

    +
  • +
  • +

    All Classes

    +

    The All Classes link shows all classes and interfaces except non-static nested types.

    +
  • +
  • +

    Serialized Form

    +

    Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.

    +
  • +
  • +

    Constant Field Values

    +

    The Constant Field Values page lists the static final fields and their values.

    +
  • +
+This help file applies to API documentation generated using the standard doclet.
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.1/index-all.html b/docs/javadoc/2.1/index-all.html new file mode 100644 index 000000000..552cf0090 --- /dev/null +++ b/docs/javadoc/2.1/index-all.html @@ -0,0 +1,2768 @@ + + + + + +Index (Hamcrest 2.1 API) + + + + + + + + +
+ + + + + + + +
+ + +
A B C D E F G H I L M N O P R S T U _  + + +

A

+
+
aFileNamed(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithAbsolutePath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithCanonicalPath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(long) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(Matcher<Long>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
AllOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical conjunction of multiple matchers.
+
+
AllOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AllOf
+
 
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
and(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
and(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
and(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
anEmptyMap() - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anEmptyMap() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anExistingDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFileOrDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
any(Class<T>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
AnyOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical disjunction of multiple matchers.
+
+
AnyOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AnyOf
+
 
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anything() - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
append(String) - Method in class org.hamcrest.BaseDescription
+
+
Append the String str to the description.
+
+
append(char) - Method in class org.hamcrest.BaseDescription
+
+
Append the char c to the description.
+
+
append(String) - Method in class org.hamcrest.StringDescription
+
 
+
append(char) - Method in class org.hamcrest.StringDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.BaseDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in interface org.hamcrest.Description
+
+
Appends the description of a SelfDescribing value to this description.
+
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in interface org.hamcrest.Description
+
+
Appends a list of SelfDescribing objects + to the description.
+
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendText(String) - Method in class org.hamcrest.BaseDescription
+
 
+
appendText(String) - Method in interface org.hamcrest.Description
+
+
Appends some plain text to the description.
+
+
appendText(String) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValue(Object) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValue(Object) - Method in interface org.hamcrest.Description
+
+
Appends an arbitrary value to the description.
+
+
appendValue(Object) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, T...) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, Iterable<T>) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
apply(I, Description) - Method in interface org.hamcrest.Condition.Step
+
 
+
aReadableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsArray
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
ArrayAsIterableMatcher<E> - Class in org.hamcrest.collection
+
 
+
ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher<Iterable<? extends E>>, Collection<Matcher<? super E>>, String) - Constructor for class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. +
As of version 2.1, use ArrayMatching.arrayContaining(List).
+
+
+
arrayContaining(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
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.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
ArrayIterator - Class in org.hamcrest.internal
+
 
+
ArrayIterator(Object) - Constructor for class org.hamcrest.internal.ArrayIterator
+
 
+
ArrayMatching - Class in org.hamcrest.collection
+
 
+
ArrayMatching() - Constructor for class org.hamcrest.collection.ArrayMatching
+
 
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
asEqualMatchers(E[]) - Static method in class org.hamcrest.collection.ArrayMatching
+
 
+
assertThat(T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, boolean) - Static method in class org.hamcrest.MatcherAssert
+
 
+
asString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+ +
+
aWritableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
+ + + +

B

+
+
BaseDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
BaseDescription() - Constructor for class org.hamcrest.BaseDescription
+
 
+
BaseMatcher<T> - Class in org.hamcrest
+
+
BaseClass for all Matcher implementations.
+
+
BaseMatcher() - Constructor for class org.hamcrest.BaseMatcher
+
 
+
BigDecimalCloseTo - Class in org.hamcrest.number
+
 
+
BigDecimalCloseTo(BigDecimal, BigDecimal) - Constructor for class org.hamcrest.number.BigDecimalCloseTo
+
 
+
blankOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankOrNullString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
+ + + +

C

+
+
CAN_READ - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
CAN_WRITE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
CharSequenceLength - Class in org.hamcrest.text
+
 
+
CharSequenceLength(Matcher<? super Integer>) - Constructor for class org.hamcrest.text.CharSequenceLength
+
 
+
check(File) - Method in interface org.hamcrest.io.FileMatchers.FileStatus
+
 
+
closeTo(double, double) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.number.BigDecimalCloseTo
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(double, double) - Static method in class org.hamcrest.number.IsCloseTo
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
CombinableBothMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
CombinableEitherMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
CombinableMatcher<T> - Class in org.hamcrest.core
+
 
+
CombinableMatcher(Matcher<? super T>) - Constructor for class org.hamcrest.core.CombinableMatcher
+
 
+
CombinableMatcher.CombinableBothMatcher<X> - Class in org.hamcrest.core
+
 
+
CombinableMatcher.CombinableEitherMatcher<X> - Class in org.hamcrest.core
+
 
+
ComparatorMatcherBuilder<T> - Class in org.hamcrest.comparator
+
 
+
comparedBy(Comparator<T>) - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparatorss of T.
+
+
comparesEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
Condition<T> - Class in org.hamcrest
+
+
A Condition implements part of a multi-step match.
+
+
Condition.Step<I,O> - Interface in org.hamcrest
+
 
+
contains(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsString(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
converted(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
CoreMatchers - Class in org.hamcrest
+
 
+
CoreMatchers() - Constructor for class org.hamcrest.CoreMatchers
+
 
+
CustomMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomMatcher(String) - Constructor for class org.hamcrest.CustomMatcher
+
 
+
CustomTypeSafeMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomTypeSafeMatcher(String) - Constructor for class org.hamcrest.CustomTypeSafeMatcher
+
 
+
+ + + +

D

+
+
DescribedAs<T> - Class in org.hamcrest.core
+
+
Provides a custom description to another matcher.
+
+
DescribedAs(String, Matcher<T>, Object[]) - Constructor for class org.hamcrest.core.DescribedAs
+
 
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.core.DescribedAs
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.CoreMatchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.Matchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.BaseMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.Is
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in interface org.hamcrest.Matcher
+
+
Generate a description of why the matcher has not accepted the item.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeMismatchSafely(Collection<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeMismatchSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeMismatchSafely(Map<? extends K, ? extends V>, Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeMismatchSafely(BigDecimal, Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeMismatchSafely(Class<?>, Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should override this.
+
+
describeTo(Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIn
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AllOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AnyOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Every
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Is
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsAnything
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.core.IsEqual
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNot
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNull
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsSame
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomTypeSafeMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.internal.SelfDescribingValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
describeTo(Description) - Method in interface org.hamcrest.SelfDescribing
+
+
Generates a description of the object.
+
+
describeTo(Description) - Method in class org.hamcrest.text.IsBlankString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
Description - Interface in org.hamcrest
+
+
A description of a Matcher.
+
+
Description.NullDescription - Class in org.hamcrest
+
 
+
descriptionEnd() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that ends the description.
+
+
descriptionSeparator() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that separates the elements in the description.
+
+
descriptionStart() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that starts the description.
+
+
DiagnosingMatcher<T> - Class in org.hamcrest
+
+
TODO(ngd): Document.
+
+
DiagnosingMatcher() - Constructor for class org.hamcrest.DiagnosingMatcher
+
 
+
+ + + +

E

+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
empty() - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
empty() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyArray() - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyArray() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyIterable() - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterable() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
emptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
endsWith(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
equalTo(T) - Static method in class org.hamcrest.core.IsEqual
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.text.IsEqualIgnoringCase
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+ +
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+ +
+
equalToObject(Object) - Static method in class org.hamcrest.core.IsEqual
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringContains
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringEndsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringStartsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
Every<T> - Class in org.hamcrest.core
+
 
+
Every(Matcher<? super T>) - Constructor for class org.hamcrest.core.Every
+
 
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.core.Every
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
EXISTS - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
+ + + +

F

+
+
FeatureMatcher<T,U> - Class in org.hamcrest
+
+
Supporting class for matching a feature of an object.
+
+
FeatureMatcher(Matcher<? super U>, String, String) - Constructor for class org.hamcrest.FeatureMatcher
+
+
Constructor
+
+
featureValueOf(E[]) - Method in class org.hamcrest.collection.IsArrayWithSize
+
 
+
featureValueOf(Collection<? extends E>) - Method in class org.hamcrest.collection.IsCollectionWithSize
+
 
+
featureValueOf(Iterable<E>) - Method in class org.hamcrest.collection.IsIterableWithSize
+
 
+
featureValueOf(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapWithSize
+
 
+
featureValueOf(T) - Method in class org.hamcrest.FeatureMatcher
+
+
Implement this to extract the interesting feature.
+
+
featureValueOf(T) - Method in class org.hamcrest.object.HasToString
+
 
+
featureValueOf(CharSequence) - Method in class org.hamcrest.text.CharSequenceLength
+
 
+
FileMatchers - Class in org.hamcrest.io
+
 
+
FileMatchers() - Constructor for class org.hamcrest.io.FileMatchers
+
 
+
FileMatchers.FileStatus - Interface in org.hamcrest.io
+
 
+
findExpectedType(Class<?>) - Method in class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
+ + + +

G

+
+
getPropertyDescriptor(String, Object) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns the description of the property with the provided + name on the provided object's interface.
+
+
greaterThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
greaterThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

H

+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
HasEqualValues<T> - Class in org.hamcrest.object
+
 
+
HasEqualValues(T) - Constructor for class org.hamcrest.object.HasEqualValues
+
 
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. +
As of version 2.1, use IsIterableContaining.hasItem(Object).
+
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
HasItemInArray<T> - Class in org.hamcrest.collection
+
+
Matches if an array contains an item satisfying a nested matcher.
+
+
HasItemInArray(Matcher<? super T>) - Constructor for class org.hamcrest.collection.HasItemInArray
+
 
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasLength(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
+
+
hasLength(int) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasLength(Matcher<? super Integer>) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasNext() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
hasNext() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
HasProperty<T> - Class in org.hamcrest.beans
+
+
A Matcher that checks that an object has a JavaBean property + with the specified name.
+
+
HasProperty(String) - Constructor for class org.hamcrest.beans.HasProperty
+
 
+
hasProperty(String) - Static method in class org.hamcrest.beans.HasProperty
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasProperty(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasPropertyAtPath(String, Matcher<T>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher.
+
+
HasPropertyWithValue<T> - Class in org.hamcrest.beans
+
+
Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+
+
HasPropertyWithValue(String, Matcher<?>) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
 
+
HasPropertyWithValue(String, Matcher<?>, String) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
 
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
HasToString<T> - Class in org.hamcrest.object
+
 
+
HasToString(Matcher<? super String>) - Constructor for class org.hamcrest.object.HasToString
+
 
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
HasXPath - Class in org.hamcrest.xml
+
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+
HasXPath(String, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
HasXPath(String, NamespaceContext, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
+ + + +

I

+
+
in(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
in(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
Is<T> - Class in org.hamcrest.core
+
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+
+
Is(Matcher<T>) - Constructor for class org.hamcrest.core.Is
+
 
+
is(Matcher<T>) - Static method in class org.hamcrest.core.Is
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
IS_DIRECTORY - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
IS_FILE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
isA(Class<?>) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
IsAnything<T> - Class in org.hamcrest.core
+
+
A matcher that always returns true.
+
+
IsAnything() - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsAnything(String) - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsArray<T> - Class in org.hamcrest.collection
+
+
Matcher for array whose elements satisfy a sequence of matchers.
+
+
IsArray(Matcher<? super T>[]) - Constructor for class org.hamcrest.collection.IsArray
+
 
+
IsArrayContainingInAnyOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
IsArrayContainingInOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
IsArrayWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if array size satisfies a nested matcher.
+
+
IsArrayWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsArrayWithSize
+
 
+
IsBlankString - Class in org.hamcrest.text
+
+
Matches blank Strings (and null).
+
+
IsCloseTo - Class in org.hamcrest.number
+
+
Is the value a number equal to a value within some range of + acceptable error?
+
+
IsCloseTo(double, double) - Constructor for class org.hamcrest.number.IsCloseTo
+
 
+
IsCollectionContaining<T> - Class in org.hamcrest.core
+
+
Deprecated. +
As of release 2.1, replaced by IsIterableContaining.
+
+
+
IsCollectionContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
IsCollectionWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if collection size satisfies a nested matcher.
+
+
IsCollectionWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsCollectionWithSize
+
 
+
IsCompatibleType<T> - Class in org.hamcrest.object
+
 
+
IsCompatibleType(Class<T>) - Constructor for class org.hamcrest.object.IsCompatibleType
+
 
+
IsEmptyCollection<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyCollection() - Constructor for class org.hamcrest.collection.IsEmptyCollection
+
 
+
IsEmptyIterable<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyIterable() - Constructor for class org.hamcrest.collection.IsEmptyIterable
+
 
+
isEmptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEmptyString - Class in org.hamcrest.text
+
+
Matches empty Strings (and null).
+
+
isEmptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEqual<T> - Class in org.hamcrest.core
+
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+
+
IsEqual(T) - Constructor for class org.hamcrest.core.IsEqual
+
 
+
IsEqualCompressingWhiteSpace - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, compressing any changes in whitespace.
+
+
IsEqualCompressingWhiteSpace(String) - Constructor for class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
IsEqualIgnoringCase - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, regardless of the case.
+
+
IsEqualIgnoringCase(String) - Constructor for class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
IsEventFrom - Class in org.hamcrest.object
+
+
Tests if the value is an event announced by a specific object.
+
+
IsEventFrom(Class<?>, Object) - Constructor for class org.hamcrest.object.IsEventFrom
+
 
+
IsIn<T> - Class in org.hamcrest.collection
+
 
+
IsIn(Collection<T>) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
IsIn(T[]) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
isIn(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
IsInstanceOf - Class in org.hamcrest.core
+
+
Tests whether the value is an instance of a class.
+
+
IsInstanceOf(Class<?>) - Constructor for class org.hamcrest.core.IsInstanceOf
+
+
Creates a new instance of IsInstanceOf
+
+
IsIterableContaining<T> - Class in org.hamcrest.core
+
 
+
IsIterableContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsIterableContaining
+
 
+
IsIterableContainingInAnyOrder<T> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInAnyOrder(Collection<Matcher<? super T>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
IsIterableContainingInOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
IsIterableContainingInRelativeOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInRelativeOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
IsIterableWithSize<E> - Class in org.hamcrest.collection
+
 
+
IsIterableWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsIterableWithSize
+
 
+
IsMapContaining<K,V> - Class in org.hamcrest.collection
+
 
+
IsMapContaining(Matcher<? super K>, Matcher<? super V>) - Constructor for class org.hamcrest.collection.IsMapContaining
+
 
+
IsMapWithSize<K,V> - Class in org.hamcrest.collection
+
+
Matches if map size satisfies a nested matcher.
+
+
IsMapWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsMapWithSize
+
 
+
IsNaN - Class in org.hamcrest.number
+
+
Is the value a number actually not a number (NaN)?
+
+
IsNot<T> - Class in org.hamcrest.core
+
+
Calculates the logical negation of a matcher.
+
+
IsNot(Matcher<T>) - Constructor for class org.hamcrest.core.IsNot
+
 
+
isNotNull(Object, Description) - Static method in class org.hamcrest.BaseMatcher
+
+
Useful null-check method.
+
+
IsNull<T> - Class in org.hamcrest.core
+
+
Is the value null?
+
+
IsNull() - Constructor for class org.hamcrest.core.IsNull
+
 
+
isOneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
isOneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
IsSame<T> - Class in org.hamcrest.core
+
+
Is the value the same object as another value?
+
+
IsSame(T) - Constructor for class org.hamcrest.core.IsSame
+
 
+
iterableMatcher - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
+ + + +

L

+
+
lessThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
lessThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

M

+
+
matched(T, Description) - Static method in class org.hamcrest.Condition
+
 
+
Matcher<T> - Interface in org.hamcrest
+
+
+ A matcher over acceptable values.
+
+
MatcherAssert - Class in org.hamcrest
+
 
+
MatcherAssert() - Constructor for class org.hamcrest.MatcherAssert
+
 
+
matchers - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
Matchers - Class in org.hamcrest
+
 
+
Matchers() - Constructor for class org.hamcrest.Matchers
+
 
+
matches(Object, Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
matches(Object) - Method in class org.hamcrest.collection.IsIn
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.AllOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.AnyOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.DescribedAs
+
 
+
matches(Object) - Method in class org.hamcrest.core.Is
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsAnything
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsEqual
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNot
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNull
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsSame
+
 
+
matches(Object) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object) - Method in interface org.hamcrest.Matcher
+
+
Evaluates the matcher for argument item.
+
+
matches(Object) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
matches(Object) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Methods made final to prevent accidental override.
+
+
matchesPattern(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
MatchesPattern - Class in org.hamcrest.text
+
 
+
MatchesPattern(Pattern) - Constructor for class org.hamcrest.text.MatchesPattern
+
 
+
matchesPattern(Pattern) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified Pattern.
+
+
matchesRegex(String) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified regex.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a Pattern.
+
+
matchesRegex(String) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a regex.
+
+
matchesSafely(T) - Method in class org.hamcrest.beans.HasProperty
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.IsArray
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
matchesSafely(Collection<? extends E>) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
matchesSafely(Iterable<? extends E>) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
matchesSafely(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.core.Every
+
 
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
matchesSafely(String, Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
matchesSafely(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
matchesSafely(BigDecimal) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsNaN
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
matchesSafely(Class<?>) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
matchesSafely(EventObject, Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsBlankString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(T) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(Node, Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
matching(Matcher<T>, String) - Method in class org.hamcrest.Condition
+
 
+
matching(Matcher<T>) - Method in class org.hamcrest.Condition
+
 
+
+ + + +

N

+
+
next() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
next() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
NO_ARGUMENTS - Static variable in class org.hamcrest.beans.PropertyUtil
+
 
+
NO_NAMESPACE_CONTEXT - Static variable in class org.hamcrest.xml.HasXPath
+
 
+
NONE - Static variable in interface org.hamcrest.Description
+
+
A description that consumes input but does nothing.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.core.IsNot
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.core.IsNot
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
NOT_MATCHED - Static variable in class org.hamcrest.Condition
+
 
+
notANumber() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notANumber() - Static method in class org.hamcrest.number.IsNaN
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notMatched() - Static method in class org.hamcrest.Condition
+
 
+
notNullValue() - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
NullDescription() - Constructor for class org.hamcrest.Description.NullDescription
+
 
+
nullSafe(Matcher<? super E>[]) - Static method in class org.hamcrest.internal.NullSafety
+
 
+
NullSafety - Class in org.hamcrest.internal
+
 
+
NullSafety() - Constructor for class org.hamcrest.internal.NullSafety
+
 
+
nullValue() - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
+ + + +

O

+
+
oneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
oneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
or(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
or(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
OrderingComparison - Class in org.hamcrest.number
+
 
+
org.hamcrest - package org.hamcrest
+
 
+
org.hamcrest.beans - package org.hamcrest.beans
+
+
Matchers of Java Bean properties and their values.
+
+
org.hamcrest.collection - package org.hamcrest.collection
+
+
Matchers of arrays and collections.
+
+
org.hamcrest.comparator - package org.hamcrest.comparator
+
 
+
org.hamcrest.core - package org.hamcrest.core
+
+
Fundamental matchers of objects and values, and composite matchers.
+
+
org.hamcrest.internal - package org.hamcrest.internal
+
 
+
org.hamcrest.io - package org.hamcrest.io
+
 
+
org.hamcrest.number - package org.hamcrest.number
+
+
Matchers that perform numeric comparisons.
+
+
org.hamcrest.object - package org.hamcrest.object
+
+
Matchers that inspect objects and classes.
+
+
org.hamcrest.text - package org.hamcrest.text
+
+
Matchers that perform text comparisons.
+
+
org.hamcrest.xml - package org.hamcrest.xml
+
+
Matchers of XML documents.
+
+
+ + + +

P

+
+
propertyDescriptorsFor(Object, Class<Object>) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns all the property descriptors for the class associated with the given object
+
+
PropertyUtil - Class in org.hamcrest.beans
+
+
Utility class for accessing properties on JavaBean objects.
+
+
PropertyUtil() - Constructor for class org.hamcrest.beans.PropertyUtil
+
 
+
+ + + +

R

+
+
ReflectiveTypeFinder - Class in org.hamcrest.internal
+
 
+
ReflectiveTypeFinder(String, int, int) - Constructor for class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
remove() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
remove() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
+ + + +

S

+
+
sameInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
SamePropertyValuesAs<T> - Class in org.hamcrest.beans
+
 
+
SamePropertyValuesAs(T, List<String>) - Constructor for class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.beans.SamePropertyValuesAs
+
+
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.
+
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
SelfDescribing - Interface in org.hamcrest
+
+
The ability of an object to describe itself.
+
+
SelfDescribingValue<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValue(T) - Constructor for class org.hamcrest.internal.SelfDescribingValue
+
 
+
SelfDescribingValueIterator<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValueIterator(Iterator<T>) - Constructor for class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
startsWith(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
StringContains - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a specific substring.
+
+
StringContains(boolean, String) - Constructor for class org.hamcrest.core.StringContains
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringContainsInOrder - Class in org.hamcrest.text
+
 
+
StringContainsInOrder(Iterable<String>) - Constructor for class org.hamcrest.text.StringContainsInOrder
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
StringDescription() - Constructor for class org.hamcrest.StringDescription
+
 
+
StringDescription(Appendable) - Constructor for class org.hamcrest.StringDescription
+
 
+
StringEndsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that ends with a specific substring.
+
+
StringEndsWith(boolean, String) - Constructor for class org.hamcrest.core.StringEndsWith
+
 
+
StringRegularExpression - Class in org.hamcrest.core
+
 
+
StringRegularExpression(Pattern) - Constructor for class org.hamcrest.core.StringRegularExpression
+
 
+
StringStartsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that starts with a specific substring.
+
+
StringStartsWith(boolean, String) - Constructor for class org.hamcrest.core.StringStartsWith
+
 
+
stripSpaces(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
substring - Variable in class org.hamcrest.core.SubstringMatcher
+
 
+
SubstringMatcher - Class in org.hamcrest.core
+
 
+
SubstringMatcher(String, boolean, String) - Constructor for class org.hamcrest.core.SubstringMatcher
+
 
+
+ + + +

T

+
+
theInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
then(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
toString() - Method in class org.hamcrest.BaseMatcher
+
 
+
toString() - Method in class org.hamcrest.Description.NullDescription
+
 
+
toString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+
Return the description of a SelfDescribing object as a String.
+
+
toString() - Method in class org.hamcrest.StringDescription
+
+
Returns the description as a string.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.object.IsCompatibleType
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
TypeSafeDiagnosingMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+
+
TypeSafeDiagnosingMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher() - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type.
+
+
TypeSafeMatcher() - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
+ + + +

U

+
+
usingNaturalOrdering() - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparables.
+
+
+ + + +

_

+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in class org.hamcrest.BaseMatcher
+
+
Deprecated.
+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in interface org.hamcrest.Matcher
+
+
Deprecated. +
to make
+
+
+
+A B C D E F G H I L M N O P R S T U _ 
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.1/index.html b/docs/javadoc/2.1/index.html new file mode 100644 index 000000000..ca5d01e68 --- /dev/null +++ b/docs/javadoc/2.1/index.html @@ -0,0 +1,75 @@ + + + + + +Hamcrest 2.1 API + + + + + + + + + +<noscript> +<div>JavaScript is disabled on your browser.</div> +</noscript> +<h2>Frame Alert</h2> +<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p> + + + diff --git a/docs/javadoc/2.1/org/hamcrest/BaseDescription.html b/docs/javadoc/2.1/org/hamcrest/BaseDescription.html new file mode 100644 index 000000000..9ce91dc24 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/BaseDescription.html @@ -0,0 +1,479 @@ + + + + + +BaseDescription (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseDescription
    • +
    +
  • +
+
+ +
+
+
    +
  • + + + + + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      BaseDescription() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethod and Description
      protected abstract voidappend(char c) +
      Append the char c to the description.
      +
      protected voidappend(java.lang.String str) +
      Append the String str to the description.
      +
      DescriptionappendDescriptionOf(SelfDescribing value) +
      Appends the description of a SelfDescribing value to this description.
      +
      DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) +
      Appends a list of SelfDescribing objects + to the description.
      +
      DescriptionappendText(java.lang.String text) +
      Appends some plain text to the description.
      +
      DescriptionappendValue(java.lang.Object value) +
      Appends an arbitrary value to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) +
      Appends a list of values to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) +
      Appends a list of values to the description.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseDescription

        +
        public BaseDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        @SafeVarargs
        +public final <T> Description appendValueList(java.lang.String start,
        +                                                          java.lang.String separator,
        +                                                          java.lang.String end,
        +                                                          T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Append the String str to the description. + The default implementation passes every character to append(char). + Override in subclasses to provide an efficient implementation.
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected abstract void append(char c)
        +
        Append the char c to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/BaseMatcher.html b/docs/javadoc/2.1/org/hamcrest/BaseMatcher.html new file mode 100644 index 000000000..21313a578 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/BaseMatcher.html @@ -0,0 +1,383 @@ + + + + + +BaseMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseMatcher<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseMatcher<T>
    • +
    +
  • +
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseMatcher

        +
        public BaseMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      + + + +
        +
      • +

        isNotNull

        +
        protected static boolean isNotNull(java.lang.Object actual,
        +                                   Description mismatch)
        +
        Useful null-check method. Writes a mismatch description if the actual object is null
        +
        +
        Parameters:
        +
        actual - the object to check
        +
        mismatch - where to write the mismatch description, if any
        +
        Returns:
        +
        false iff the actual object is null
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Condition.Step.html b/docs/javadoc/2.1/org/hamcrest/Condition.Step.html new file mode 100644 index 000000000..17f805232 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Condition.Step.html @@ -0,0 +1,227 @@ + + + + + +Condition.Step (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Condition.Step<I,O>

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    Condition<T>
    +
    +
    +
    +
    public static interface Condition.Step<I,O>
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Condition.html b/docs/javadoc/2.1/org/hamcrest/Condition.html new file mode 100644 index 000000000..eae1e968e --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Condition.html @@ -0,0 +1,367 @@ + + + + + +Condition (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Condition<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Condition<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public abstract class Condition<T>
    +extends java.lang.Object
    +
    A Condition implements part of a multi-step match. We sometimes need to write matchers + that have a sequence of steps, where each step depends on the result of the previous + step and we can stop processing as soon as a step fails. These classes provide + infrastructure for writing such a sequence. + + Based on https://github.com/npryce/maybe-java
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NOT_MATCHED

        +
        public static final org.hamcrest.Condition.NotMatched<java.lang.Object> NOT_MATCHED
        +
      • +
      +
    • +
    + + +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/CoreMatchers.html b/docs/javadoc/2.1/org/hamcrest/CoreMatchers.html new file mode 100644 index 000000000..a2ad61d6d --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/CoreMatchers.html @@ -0,0 +1,1077 @@ + + + + + +CoreMatchers (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CoreMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.CoreMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class CoreMatchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      CoreMatchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static Matcher<java.lang.Object>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>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>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>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>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>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<T> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>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>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CoreMatchers

        +
        public CoreMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<T> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/CustomMatcher.html b/docs/javadoc/2.1/org/hamcrest/CustomMatcher.html new file mode 100644 index 000000000..d08d8c2a6 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/CustomMatcher.html @@ -0,0 +1,324 @@ + + + + + +CustomMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched.
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomMatcher<T>
    +extends BaseMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomMatcher<String>("a non empty string") {
    +   public boolean matches(Object object) {
    +     return ((object instanceof String) && !((String) object).isEmpty();
    +   }
    + };
    + 
    +

    + This class is designed for scenarios where an anonymous inner class + matcher makes sense. It should not be used by API designers implementing + matchers.

    +
    +
    See Also:
    +
    for a type safe variant of this class that you probably + want to use.
    +
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomMatcher

        +
        public CustomMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/CustomTypeSafeMatcher.html b/docs/javadoc/2.1/org/hamcrest/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..93ac03d2c --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/CustomTypeSafeMatcher.html @@ -0,0 +1,327 @@ + + + + + +CustomTypeSafeMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomTypeSafeMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomTypeSafeMatcher<T>
    +extends TypeSafeMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
    +   public boolean matchesSafely(String string) {
    +     return !string.isEmpty();
    +   }
    +   public void describeMismatchSafely(String string, Description mismatchDescription) {
    +     mismatchDescription.appendText("was empty");
    +   }
    + };
    + 
    + This is a variant of CustomMatcher that first type checks + the argument being matched. By the time TypeSafeMatcher.matchesSafely(T) is + is called the argument is guaranteed to be non-null and of the correct + type.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomTypeSafeMatcher

        +
        public CustomTypeSafeMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Description.NullDescription.html b/docs/javadoc/2.1/org/hamcrest/Description.NullDescription.html new file mode 100644 index 000000000..3ecb79b7f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Description.NullDescription.html @@ -0,0 +1,460 @@ + + + + + +Description.NullDescription (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Description.NullDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Description.NullDescription
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Description
    +
    +
    +
    Enclosing interface:
    +
    Description
    +
    +
    +
    +
    public static final class Description.NullDescription
    +extends java.lang.Object
    +implements Description
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullDescription

        +
        public NullDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Description.html b/docs/javadoc/2.1/org/hamcrest/Description.html new file mode 100644 index 000000000..91237e7d3 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Description.html @@ -0,0 +1,392 @@ + + + + + +Description (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Description

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NONE

        +
        static final Description NONE
        +
        A description that consumes input but does nothing.
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        Description appendText(java.lang.String text)
        +
        Appends some plain text to the description.
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        Description appendValue(java.lang.Object value)
        +
        Appends an arbitrary value to the description.
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                T... values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                java.lang.Iterable<T> values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        Description appendList(java.lang.String start,
        +                       java.lang.String separator,
        +                       java.lang.String end,
        +                       java.lang.Iterable<? extends SelfDescribing> values)
        +
        Appends a list of SelfDescribing objects + to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/DiagnosingMatcher.html b/docs/javadoc/2.1/org/hamcrest/DiagnosingMatcher.html new file mode 100644 index 000000000..1986de88b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/DiagnosingMatcher.html @@ -0,0 +1,365 @@ + + + + + +DiagnosingMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class DiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DiagnosingMatcher

        +
        public DiagnosingMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected abstract boolean matches(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/FeatureMatcher.html b/docs/javadoc/2.1/org/hamcrest/FeatureMatcher.html new file mode 100644 index 000000000..318e0cad3 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/FeatureMatcher.html @@ -0,0 +1,381 @@ + + + + + +FeatureMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class FeatureMatcher<T,U>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FeatureMatcher

        +
        public FeatureMatcher(Matcher<? super U> subMatcher,
        +                      java.lang.String featureDescription,
        +                      java.lang.String featureName)
        +
        Constructor
        +
        +
        Parameters:
        +
        subMatcher - The matcher to apply to the feature
        +
        featureDescription - Descriptive text to use in describeTo
        +
        featureName - Identifying text for mismatch message
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected abstract U featureValueOf(T actual)
        +
        Implement this to extract the interesting feature.
        +
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Matcher.html b/docs/javadoc/2.1/org/hamcrest/Matcher.html new file mode 100644 index 000000000..0eaa13e7d --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Matcher.html @@ -0,0 +1,328 @@ + + + + + +Matcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Matcher<T>

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        boolean matches(java.lang.Object actual)
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        actual - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        void describeMismatch(java.lang.Object actual,
        +                      Description mismatchDescription)
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Parameters:
        +
        actual - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        _dont_implement_Matcher___instead_extend_BaseMatcher_

        +
        @Deprecated
        +void _dont_implement_Matcher___instead_extend_BaseMatcher_()
        +
        Deprecated. to make
        +
        This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors .
        +
        +
        See Also:
        +
        for reasons why., +BaseMatcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/MatcherAssert.html b/docs/javadoc/2.1/org/hamcrest/MatcherAssert.html new file mode 100644 index 000000000..4c753c08a --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/MatcherAssert.html @@ -0,0 +1,307 @@ + + + + + +MatcherAssert (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class MatcherAssert

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.MatcherAssert
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class MatcherAssert
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      MatcherAssert() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static voidassertThat(java.lang.String reason, + boolean assertion) 
      static <T> voidassertThat(java.lang.String reason, + T actual, + Matcher<? super T> matcher) 
      static <T> voidassertThat(T actual, + Matcher<? super T> matcher) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatcherAssert

        +
        public MatcherAssert()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(java.lang.String reason,
        +                                  T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + +
        +
      • +

        assertThat

        +
        public static void assertThat(java.lang.String reason,
        +                              boolean assertion)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/Matchers.html b/docs/javadoc/2.1/org/hamcrest/Matchers.html new file mode 100644 index 000000000..3ce516b27 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/Matchers.html @@ -0,0 +1,3426 @@ + + + + + +Matchers (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Matchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Matchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class Matchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Matchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(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(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(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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(int size) +
      Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>anEmptyMap() +
      Creates a matcher for Maps that matches when the size() method returns + zero.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static <T> AnyOf<T>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(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(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(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(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>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>anything(java.lang.String description) +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      static <T> IsArray<T>array(Matcher<? super T>... elementMatchers) +
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
      +
      static <E> Matcher<E[]>arrayContaining(E... items) +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
      +
      static <E> Matcher<E[]>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[]>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[]>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[]>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[]>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[]>arrayWithSize(int size) +
      Creates a matcher for arrays that matches when the length of the array + equals the specified size.
      +
      static <E> Matcher<E[]>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 Matcher<java.lang.String>blankOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
      +
      static Matcher<java.lang.String>blankString() +
      Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
      +
      static <LHS> CombinableMatcher.CombinableBothMatcher<LHS>both(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when both of the specified matchers match the examined object.
      +
      static Matcher<java.math.BigDecimal>closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) +
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
      +
      static Matcher<java.lang.Double>closeTo(double operand, + double error) +
      Creates a matcher of Doubles 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>
      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 <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables 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>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      static Matcher<java.lang.String>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>either(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when either of the specified matchers match the examined object.
      +
      static <E> Matcher<java.util.Collection<? extends E>>empty() +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<E[]>emptyArray() +
      Creates a matcher for arrays that matches when the length of the array + is zero.
      +
      static <E> Matcher<java.util.Collection<E>>emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>emptyIterable() +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static <E> Matcher<java.lang.Iterable<E>>emptyIterableOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static Matcher<java.lang.String>emptyOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + has zero length.
      +
      static Matcher<java.lang.String>emptyString() +
      Creates a matcher of String that matches when the examined string has zero length.
      +
      static Matcher<java.lang.String>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.String>equalToCompressingWhiteSpace(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>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>equalToIgnoringWhiteSpace(java.lang.String expectedString) + +
      static Matcher<java.lang.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static Matcher<java.util.EventObject>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>eventFrom(java.lang.Object source) +
      Creates a matcher of EventObject that matches any EventObject + announced by source.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps 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<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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<T[]>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[]>hasItemInArray(T element) +
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      +
      static <T> Matcher<java.lang.Iterable<T>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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 <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static Matcher<java.lang.CharSequence>hasLength(int length) +
      Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
      +
      static <T> Matcher<T>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>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 <E> Matcher<java.util.Collection<? extends E>>hasSize(int size) +
      Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
      +
      static <E> Matcher<java.util.Collection<? extends E>>hasSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <T> Matcher<T>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(java.lang.String expectedToString) +
      Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<?> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static Matcher<java.lang.String>isEmptyOrNullString() +
      Deprecated.  +
      use is(emptyOrNullString()) instead
      +
      +
      static Matcher<java.lang.String>isEmptyString() +
      Deprecated.  +
      use is(emptyString()) instead
      +
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      static <E> Matcher<java.lang.Iterable<E>>iterableWithSize(int size) +
      Creates a matcher for Iterables 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>>iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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.
      +
      static Matcher<java.lang.String>matchesPattern(java.util.regex.Pattern pattern) +
      Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
      +
      static Matcher<java.lang.String>matchesPattern(java.lang.String regex) +
      Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
      +
      static Matcher<java.lang.String>matchesRegex(java.util.regex.Pattern pattern) +
      Validate a string with a Pattern.
      +
      static Matcher<java.lang.String>matchesRegex(java.lang.String regex) +
      Validate a string with a regex.
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Double>notANumber() +
      Creates a matcher of Doubles that matches when an examined double is not a number.
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      static <T> Matcher<T>sameInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <B> Matcher<B>samePropertyValuesAs(B expectedBean, + java.lang.String... ignoredProperties) +
      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.
      +
      static Matcher<java.lang.String>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static Matcher<java.lang.String>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, considering the order of their appearance.
      +
      static Matcher<java.lang.String>stringContainsInOrder(java.lang.String... substrings) +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <T> Matcher<java.lang.Class<?>>typeCompatibleWith(java.lang.Class<T> baseType) +
      Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Matchers

        +
        public Matchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(Matcher<? super T> first,
        +                                   Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(Matcher<T> first,
        +                                 Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenized description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<?> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWithIgnoringCase("My"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWithIgnoringCase("note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.util.regex.Pattern pattern)
        +
        Validate a string with a Pattern. + +
        + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
        + 
        +
        +
        Parameters:
        +
        pattern - the pattern to be used.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.lang.String regex)
        +
        Validate a string with a regex. + +
        + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
        + 
        +
        +
        Parameters:
        +
        regex - The regex to be used for the validation.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        array

        +
        @SafeVarargs
        +public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString)
        + +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToCompressingWhiteSpace

        +
        public static Matcher<java.lang.String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(int length)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument. + For example: + +
        + assertThat("text", length(4))
        + 
        +
        +
        Parameters:
        +
        length - the expected length of the string
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <B> Matcher<B> samePropertyValuesAs(B expectedBean,
        +                                                  java.lang.String... ignoredProperties)
        +
        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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example
        age
        rather than method names such as
        getAge
        . + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        ignoredProperties - do not check any of these named properties.
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/SelfDescribing.html b/docs/javadoc/2.1/org/hamcrest/SelfDescribing.html new file mode 100644 index 000000000..8af333cdf --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/SelfDescribing.html @@ -0,0 +1,237 @@ + + + + + +SelfDescribing (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface SelfDescribing

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        void describeTo(Description description)
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/StringDescription.html b/docs/javadoc/2.1/org/hamcrest/StringDescription.html new file mode 100644 index 000000000..4f7859f00 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/StringDescription.html @@ -0,0 +1,417 @@ + + + + + +StringDescription (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class StringDescription

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription()
        +
      • +
      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription(java.lang.Appendable out)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        toString

        +
        public static java.lang.String toString(SelfDescribing selfDescribing)
        +
        Return the description of a SelfDescribing object as a String.
        +
        +
        Parameters:
        +
        selfDescribing - The object to be described.
        +
        Returns:
        +
        The description of the object.
        +
        +
      • +
      + + + + + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Description copied from class: BaseDescription
        +
        Append the String str to the description. + The default implementation passes every character to BaseDescription.append(char). + Override in subclasses to provide an efficient implementation.
        +
        +
        Overrides:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(char c)
        +
        Description copied from class: BaseDescription
        +
        Append the char c to the description.
        +
        +
        Specified by:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        Returns the description as a string.
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/TypeSafeDiagnosingMatcher.html b/docs/javadoc/2.1/org/hamcrest/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..2a0c4bd65 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,423 @@ + + + + + +TypeSafeDiagnosingMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeDiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item,
        +                                         Description mismatchDescription)
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/TypeSafeMatcher.html b/docs/javadoc/2.1/org/hamcrest/TypeSafeMatcher.html new file mode 100644 index 000000000..c706dbb29 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/TypeSafeMatcher.html @@ -0,0 +1,432 @@ + + + + + +TypeSafeMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item)
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        protected void describeMismatchSafely(T item,
        +                                      Description mismatchDescription)
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Methods made final to prevent accidental override. + If you need to override this, there's no point on extending TypeSafeMatcher. + Instead, extend the BaseMatcher.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/HasProperty.html b/docs/javadoc/2.1/org/hamcrest/beans/HasProperty.html new file mode 100644 index 000000000..4d9183b5b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/HasProperty.html @@ -0,0 +1,384 @@ + + + + + +HasProperty (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasProperty<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasProperty<T>
    +extends TypeSafeMatcher<T>
    +
    A Matcher that checks that an object has a JavaBean property + with the specified name. If an error occurs during introspection + of the object then this is treated as a mismatch.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasProperty

        +
        public HasProperty(java.lang.String propertyName)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T obj)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/HasPropertyWithValue.html b/docs/javadoc/2.1/org/hamcrest/beans/HasPropertyWithValue.html new file mode 100644 index 000000000..49edb6b55 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/HasPropertyWithValue.html @@ -0,0 +1,455 @@ + + + + + +HasPropertyWithValue (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasPropertyWithValue<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasPropertyWithValue<T>
    +extends TypeSafeDiagnosingMatcher<T>
    +

    Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher. This is useful for when objects + are created within code under test and passed to a mock object, and you wish + to assert that the created object has certain properties. +

    + +

    Example Usage

    + Consider the situation where we have a class representing a person, which + follows the basic JavaBean convention of having get() and possibly set() + methods for it's properties: +
    + public class Person {
    +   private String name;
    +   public Person(String person) {
    +     this.person = person;
    +   }
    +   public String getName() {
    +     return name;
    +   }
    + }
    + + And that these person objects are generated within a piece of code under test + (a class named PersonGenerator). This object is sent to one of our mock objects + which overrides the PersonGenerationListener interface: +
    + public interface PersonGenerationListener {
    +   public void personGenerated(Person person);
    + }
    + + In order to check that the code under test generates a person with name + "Iain" we would do the following: +
    + Mock personGenListenerMock = mock(PersonGenerationListener.class);
    + personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
    + PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy();
    + +

    If an exception is thrown by the getter method for a property, the property + does not exist, is not readable, or a reflection related exception is thrown + when trying to invoke it then this is treated as an evaluation failure and + the matches method will return false. +

    +

    This matcher class will also work with JavaBean objects that have explicit + bean descriptions via an associated BeanInfo description class. See the + JavaBeans specification for more information: + http://java.sun.com/products/javabeans/docs/index.html +

    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasPropertyWithValue

        +
        public HasPropertyWithValue(java.lang.String propertyName,
        +                            Matcher<?> valueMatcher)
        +
      • +
      + + + +
        +
      • +

        HasPropertyWithValue

        +
        public HasPropertyWithValue(java.lang.String propertyName,
        +                            Matcher<?> valueMatcher,
        +                            java.lang.String messageFormat)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      + + + +
        +
      • +

        hasPropertyAtPath

        +
        public static <T> Matcher<T> hasPropertyAtPath(java.lang.String path,
        +                                               Matcher<T> valueMatcher)
        +
        Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher. + For example: +
        assertThat(myBean, hasProperty("foo.bar.baz", equalTo("a property value"))
        +
        +
        Parameters:
        +
        path - the dot-separated path from the examined object to the JavaBean property
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/PropertyUtil.html b/docs/javadoc/2.1/org/hamcrest/beans/PropertyUtil.html new file mode 100644 index 000000000..48dd62c16 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/PropertyUtil.html @@ -0,0 +1,354 @@ + + + + + +PropertyUtil (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class PropertyUtil

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.beans.PropertyUtil
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class PropertyUtil
    +extends java.lang.Object
    +
    Utility class for accessing properties on JavaBean objects. + See http://java.sun.com/products/javabeans/docs/index.html for + more information on JavaBeans.
    +
    +
    Since:
    +
    1.1.0
    +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static java.lang.Object[]NO_ARGUMENTS 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      PropertyUtil() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static java.beans.PropertyDescriptorgetPropertyDescriptor(java.lang.String propertyName, + java.lang.Object fromObj) +
      Returns the description of the property with the provided + name on the provided object's interface.
      +
      static java.beans.PropertyDescriptor[]propertyDescriptorsFor(java.lang.Object fromObj, + java.lang.Class<java.lang.Object> stopClass) +
      Returns all the property descriptors for the class associated with the given object
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_ARGUMENTS

        +
        public static final java.lang.Object[] NO_ARGUMENTS
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        PropertyUtil

        +
        public PropertyUtil()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getPropertyDescriptor

        +
        public static java.beans.PropertyDescriptor getPropertyDescriptor(java.lang.String propertyName,
        +                                                                  java.lang.Object fromObj)
        +                                                           throws java.lang.IllegalArgumentException
        +
        Returns the description of the property with the provided + name on the provided object's interface.
        +
        +
        Returns:
        +
        the descriptor of the property, or null if the property does not exist.
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      + + + +
        +
      • +

        propertyDescriptorsFor

        +
        public static java.beans.PropertyDescriptor[] propertyDescriptorsFor(java.lang.Object fromObj,
        +                                                                     java.lang.Class<java.lang.Object> stopClass)
        +                                                              throws java.lang.IllegalArgumentException
        +
        Returns all the property descriptors for the class associated with the given object
        +
        +
        Parameters:
        +
        fromObj - Use the class of this object
        +
        stopClass - Don't include any properties from this ancestor class upwards.
        +
        Returns:
        +
        Property descriptors
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/SamePropertyValuesAs.html b/docs/javadoc/2.1/org/hamcrest/beans/SamePropertyValuesAs.html new file mode 100644 index 000000000..18887364a --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/SamePropertyValuesAs.html @@ -0,0 +1,364 @@ + + + + + +SamePropertyValuesAs (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class SamePropertyValuesAs<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SamePropertyValuesAs

        +
        public SamePropertyValuesAs(T expectedBean,
        +                            java.util.List<java.lang.String> ignoredProperties)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <B> Matcher<B> samePropertyValuesAs(B expectedBean,
        +                                                  java.lang.String... ignoredProperties)
        +
        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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example
        age
        rather than method names such as
        getAge
        . + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        ignoredProperties - do not check any of these named properties.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/package-frame.html b/docs/javadoc/2.1/org/hamcrest/beans/package-frame.html new file mode 100644 index 000000000..05a47fe23 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.beans (Hamcrest 2.1 API) + + + + + +

org.hamcrest.beans

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/package-summary.html b/docs/javadoc/2.1/org/hamcrest/beans/package-summary.html new file mode 100644 index 000000000..61addd3fd --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/package-summary.html @@ -0,0 +1,169 @@ + + + + + +org.hamcrest.beans (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.beans

+
+
Matchers of Java Bean properties and their values.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasProperty<T> +
    A Matcher that checks that an object has a JavaBean property + with the specified name.
    +
    HasPropertyWithValue<T> +
    Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
    +
    PropertyUtil +
    Utility class for accessing properties on JavaBean objects.
    +
    SamePropertyValuesAs<T> 
    +
  • +
+ + + +

Package org.hamcrest.beans Description

+

Matchers of Java Bean properties and their values.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/beans/package-tree.html b/docs/javadoc/2.1/org/hamcrest/beans/package-tree.html new file mode 100644 index 000000000..0fd46d7f0 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/beans/package-tree.html @@ -0,0 +1,154 @@ + + + + + +org.hamcrest.beans Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.beans

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/ArrayAsIterableMatcher.html b/docs/javadoc/2.1/org/hamcrest/collection/ArrayAsIterableMatcher.html new file mode 100644 index 000000000..fa643785f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/ArrayAsIterableMatcher.html @@ -0,0 +1,410 @@ + + + + + +ArrayAsIterableMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class ArrayAsIterableMatcher<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + + + + + +
        +
      • +

        matchers

        +
        protected final java.util.Collection<Matcher<? super E>> matchers
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayAsIterableMatcher

        +
        public ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>> iterableMatcher,
        +                              java.util.Collection<Matcher<? super E>> matchers,
        +                              java.lang.String message)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/ArrayMatching.html b/docs/javadoc/2.1/org/hamcrest/collection/ArrayMatching.html new file mode 100644 index 000000000..d13acda73 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/ArrayMatching.html @@ -0,0 +1,510 @@ + + + + + +ArrayMatching (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class ArrayMatching

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.collection.ArrayMatching
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class ArrayMatching
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ArrayMatching() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<E[]>arrayContaining(E... items) +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
      +
      static <E> Matcher<E[]>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[]>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[]>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[]>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[]>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> java.util.List<Matcher<? super E>>asEqualMatchers(E[] items) 
      static <T> Matcher<T[]>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[]>hasItemInArray(T element) +
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayMatching

        +
        public ArrayMatching()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        asEqualMatchers

        +
        public static <E> java.util.List<Matcher<? super E>> asEqualMatchers(E[] items)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/HasItemInArray.html b/docs/javadoc/2.1/org/hamcrest/collection/HasItemInArray.html new file mode 100644 index 000000000..4a218c2d4 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/HasItemInArray.html @@ -0,0 +1,358 @@ + + + + + +HasItemInArray (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class HasItemInArray<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class HasItemInArray<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matches if an array contains an item satisfying a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasItemInArray

        +
        public HasItemInArray(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] actual)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] actual,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsArray.html b/docs/javadoc/2.1/org/hamcrest/collection/IsArray.html new file mode 100644 index 000000000..187cd20fc --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsArray.html @@ -0,0 +1,440 @@ + + + + + +IsArray (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArray<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArray<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matcher for array whose elements satisfy a sequence of matchers. + The array size must equal the number of element matchers.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArray

        +
        public IsArray(Matcher<? super T>[] elementMatchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] array)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] actual,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        descriptionStart

        +
        protected java.lang.String descriptionStart()
        +
        Returns the string that starts the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionSeparator

        +
        protected java.lang.String descriptionSeparator()
        +
        Returns the string that separates the elements in the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionEnd

        +
        protected java.lang.String descriptionEnd()
        +
        Returns the string that ends the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        array

        +
        public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInAnyOrder.html b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..5aa413e69 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInAnyOrder.html @@ -0,0 +1,471 @@ + + + + + +IsArrayContainingInAnyOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInAnyOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInAnyOrder

        +
        public IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Matcher[]).
        +
        Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Collection).
        +
        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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(E... items)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Object[]).
        +
        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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInOrder.html b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInOrder.html new file mode 100644 index 000000000..c3de3b6c5 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayContainingInOrder.html @@ -0,0 +1,455 @@ + + + + + +IsArrayContainingInOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInOrder

        +
        public IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(Object[]).
        +
        Creates a matcher for arrays that matcheswhen each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(Matcher[]).
        +
        Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers. For a positive match, the examined array + must be of the same length as the number of specified matchers. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(List).
        +
        Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers. For a positive match, the examined array + must be of the same length as the specified list of matchers. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsArrayWithSize.html b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayWithSize.html new file mode 100644 index 000000000..be0dfaa12 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsArrayWithSize.html @@ -0,0 +1,392 @@ + + + + + +IsArrayWithSize (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<E[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArrayWithSize<E>
    +extends FeatureMatcher<E[],java.lang.Integer>
    +
    Matches if array size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayWithSize

        +
        public IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(E[] actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<E[],java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsCollectionWithSize.html b/docs/javadoc/2.1/org/hamcrest/collection/IsCollectionWithSize.html new file mode 100644 index 000000000..20bf914af --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsCollectionWithSize.html @@ -0,0 +1,370 @@ + + + + + +IsCollectionWithSize (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsCollectionWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsCollectionWithSize<E>
    +extends FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
    +
    Matches if collection size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionWithSize

        +
        public IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Collection<? extends E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyCollection.html b/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyCollection.html new file mode 100644 index 000000000..76cd806f9 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyCollection.html @@ -0,0 +1,398 @@ + + + + + +IsEmptyCollection (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyCollection<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyCollection<E>
    +extends TypeSafeMatcher<java.util.Collection<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyCollection

        +
        public IsEmptyCollection()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Collection<? extends E> item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Collection<? extends E> item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyIterable.html b/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyIterable.html new file mode 100644 index 000000000..2506d3560 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsEmptyIterable.html @@ -0,0 +1,394 @@ + + + + + +IsEmptyIterable (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyIterable<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyIterable<E>
    +extends TypeSafeMatcher<java.lang.Iterable<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyIterable

        +
        public IsEmptyIterable()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends E> iterable)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Iterable<? extends E> iter,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsIn.html b/docs/javadoc/2.1/org/hamcrest/collection/IsIn.html new file mode 100644 index 000000000..df90881e0 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsIn.html @@ -0,0 +1,502 @@ + + + + + +IsIn (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIn<T>

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      IsIn(java.util.Collection<T> collection) 
      IsIn(T[] elements) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description buffer) +
      Generates a description of the object.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      booleanmatches(java.lang.Object o) +
      Evaluates the matcher for argument item.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIn

        +
        public IsIn(java.util.Collection<T> collection)
        +
      • +
      + + + + + +
        +
      • +

        IsIn

        +
        public IsIn(T[] elements)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description buffer)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        buffer - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        @SafeVarargs
        + @Deprecated
        +public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInAnyOrder.html b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..d99e96715 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInAnyOrder.html @@ -0,0 +1,444 @@ + + + + + +IsIterableContainingInAnyOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInAnyOrder<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends T> items, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInAnyOrder

        +
        public IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends T> items,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInOrder.html b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInOrder.html new file mode 100644 index 000000000..c1b141cee --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInOrder.html @@ -0,0 +1,443 @@ + + + + + +IsIterableContainingInOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInOrder

        +
        public IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html new file mode 100644 index 000000000..d103639e7 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html @@ -0,0 +1,415 @@ + + + + + +IsIterableContainingInRelativeOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInRelativeOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInRelativeOrder

        +
        public IsIterableContainingInRelativeOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsIterableWithSize.html b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableWithSize.html new file mode 100644 index 000000000..557c86ee8 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsIterableWithSize.html @@ -0,0 +1,373 @@ + + + + + +IsIterableWithSize (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<E>>, SelfDescribing
    +
    +
    +
    +
    public class IsIterableWithSize<E>
    +extends FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableWithSize

        +
        public IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.lang.Iterable<E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsMapContaining.html b/docs/javadoc/2.1/org/hamcrest/collection/IsMapContaining.html new file mode 100644 index 000000000..7893d426d --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsMapContaining.html @@ -0,0 +1,515 @@ + + + + + +IsMapContaining (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapContaining<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public class IsMapContaining<K,V>
    +extends TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatchSafely(java.util.Map<? extends K,? extends V> map, + Description mismatchDescription) +
      Subclasses should override this.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
      +
      static <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      booleanmatchesSafely(java.util.Map<? extends K,? extends V> map) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapContaining

        +
        public IsMapContaining(Matcher<? super K> keyMatcher,
        +                       Matcher<? super V> valueMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Map<? extends K,? extends V> map)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Map<? extends K,? extends V> map,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/IsMapWithSize.html b/docs/javadoc/2.1/org/hamcrest/collection/IsMapWithSize.html new file mode 100644 index 000000000..d09f40f26 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/IsMapWithSize.html @@ -0,0 +1,390 @@ + + + + + +IsMapWithSize (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapWithSize<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public final class IsMapWithSize<K,V>
    +extends FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
    +
    Matches if map size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapWithSize

        +
        public IsMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Map<? extends K,? extends V> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/package-frame.html b/docs/javadoc/2.1/org/hamcrest/collection/package-frame.html new file mode 100644 index 000000000..8dd61c00b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/package-frame.html @@ -0,0 +1,36 @@ + + + + + +org.hamcrest.collection (Hamcrest 2.1 API) + + + + + +

org.hamcrest.collection

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/package-summary.html b/docs/javadoc/2.1/org/hamcrest/collection/package-summary.html new file mode 100644 index 000000000..58bb8071e --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/package-summary.html @@ -0,0 +1,231 @@ + + + + + +org.hamcrest.collection (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.collection

+
+
Matchers of arrays and collections.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.collection Description

+

Matchers of arrays and collections.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/collection/package-tree.html b/docs/javadoc/2.1/org/hamcrest/collection/package-tree.html new file mode 100644 index 000000000..fb5b615ec --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/collection/package-tree.html @@ -0,0 +1,167 @@ + + + + + +org.hamcrest.collection Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.collection

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/comparator/ComparatorMatcherBuilder.html b/docs/javadoc/2.1/org/hamcrest/comparator/ComparatorMatcherBuilder.html new file mode 100644 index 000000000..f551bf287 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/comparator/ComparatorMatcherBuilder.html @@ -0,0 +1,406 @@ + + + + + +ComparatorMatcherBuilder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.comparator
+

Class ComparatorMatcherBuilder<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.comparator.ComparatorMatcherBuilder<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class ComparatorMatcherBuilder<T>
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> ComparatorMatcherBuilder<T>comparedBy(java.util.Comparator<T> comparator) +
      Creates a matcher factory for matchers of Comparatorss of T.
      +
      Matcher<T>comparesEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThan(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThan(T value) +
      Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      static <T extends java.lang.Comparable<T>>
      ComparatorMatcherBuilder<T>
      usingNaturalOrdering() +
      Creates a matcher factory for matchers of Comparables.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        usingNaturalOrdering

        +
        public static <T extends java.lang.Comparable<T>> ComparatorMatcherBuilder<T> usingNaturalOrdering()
        +
        Creates a matcher factory for matchers of Comparables. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
      • +
      + + + +
        +
      • +

        comparedBy

        +
        public static <T> ComparatorMatcherBuilder<T> comparedBy(java.util.Comparator<T> comparator)
        +
        Creates a matcher factory for matchers of Comparatorss of T. + For example: +
        assertThat(5, comparedBy(new Comparator<Integer>() {
        + public int compare(Integer o1, Integer o2) {
        + return -o1.compareTo(o2);
        + }
        + }).lessThan(4))
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public Matcher<T> comparesEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public Matcher<T> greaterThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(2, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public Matcher<T> greaterThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public Matcher<T> lessThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public Matcher<T> lessThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/comparator/package-frame.html b/docs/javadoc/2.1/org/hamcrest/comparator/package-frame.html new file mode 100644 index 000000000..b23c1bc0c --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/comparator/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.comparator (Hamcrest 2.1 API) + + + + + +

org.hamcrest.comparator

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.1/org/hamcrest/comparator/package-summary.html b/docs/javadoc/2.1/org/hamcrest/comparator/package-summary.html new file mode 100644 index 000000000..61dbc6fd9 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/comparator/package-summary.html @@ -0,0 +1,140 @@ + + + + + +org.hamcrest.comparator (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.comparator

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/comparator/package-tree.html b/docs/javadoc/2.1/org/hamcrest/comparator/package-tree.html new file mode 100644 index 000000000..0a82c5a99 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/comparator/package-tree.html @@ -0,0 +1,135 @@ + + + + + +org.hamcrest.comparator Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.comparator

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/AllOf.html b/docs/javadoc/2.1/org/hamcrest/core/AllOf.html new file mode 100644 index 000000000..ce900763f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/AllOf.html @@ -0,0 +1,365 @@ + + + + + +AllOf (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AllOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AllOf<T>
    +extends DiagnosingMatcher<T>
    +
    Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns false.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AllOf

        +
        public AllOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/AnyOf.html b/docs/javadoc/2.1/org/hamcrest/core/AnyOf.html new file mode 100644 index 000000000..05504133a --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/AnyOf.html @@ -0,0 +1,398 @@ + + + + + +AnyOf (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AnyOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AnyOf<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns true.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AnyOf

        +
        public AnyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Specified by:
        +
        matches in interface Matcher<T>
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected boolean matches(java.lang.Object o,
        +                          boolean shortcut)
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description,
        +                       java.lang.String operator)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..19c1d1144 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableBothMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableBothMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableBothMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..5a746a14f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableEitherMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableEitherMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableEitherMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.html b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.html new file mode 100644 index 000000000..ced51fa51 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/CombinableMatcher.html @@ -0,0 +1,418 @@ + + + + + +CombinableMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CombinableMatcher

        +
        public CombinableMatcher(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + + + + + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/DescribedAs.html b/docs/javadoc/2.1/org/hamcrest/core/DescribedAs.html new file mode 100644 index 000000000..cdef4babc --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/DescribedAs.html @@ -0,0 +1,391 @@ + + + + + +DescribedAs (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class DescribedAs<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class DescribedAs<T>
    +extends BaseMatcher<T>
    +
    Provides a custom description to another matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DescribedAs

        +
        public DescribedAs(java.lang.String descriptionTemplate,
        +                   Matcher<T> matcher,
        +                   java.lang.Object[] values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/Every.html b/docs/javadoc/2.1/org/hamcrest/core/Every.html new file mode 100644 index 000000000..08be73626 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/Every.html @@ -0,0 +1,357 @@ + + + + + +Every (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Every<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Every

        +
        public Every(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends T> collection,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/Is.html b/docs/javadoc/2.1/org/hamcrest/core/Is.html new file mode 100644 index 000000000..600f3f209 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/Is.html @@ -0,0 +1,426 @@ + + + + + +Is (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Is<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class Is<T>
    +extends BaseMatcher<T>
    +
    Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive. + + For example: assertThat(cheese, equalTo(smelly)) + vs. assertThat(cheese, is(equalTo(smelly)))
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Is(Matcher<T> matcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) +
      Generate a description of why the matcher has not accepted the item.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<T>is(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<?> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      booleanmatches(java.lang.Object arg) +
      Evaluates the matcher for argument item.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Is

        +
        public Is(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<?> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsAnything.html b/docs/javadoc/2.1/org/hamcrest/core/IsAnything.html new file mode 100644 index 000000000..55e5dda02 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsAnything.html @@ -0,0 +1,376 @@ + + + + + +IsAnything (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsAnything<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsAnything<T>
    +extends BaseMatcher<T>
    +
    A matcher that always returns true.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything()
        +
      • +
      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything(java.lang.String message)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsCollectionContaining.html b/docs/javadoc/2.1/org/hamcrest/core/IsCollectionContaining.html new file mode 100644 index 000000000..47f159722 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsCollectionContaining.html @@ -0,0 +1,460 @@ + + + + + +IsCollectionContaining (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsCollectionContaining<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionContaining

        +
        public IsCollectionContaining(Matcher<? super T> elementMatcher)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
        +                                Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItem(Matcher).
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItem(Object).
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItems(Matcher[])}.
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItems(Object[])}.
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsEqual.html b/docs/javadoc/2.1/org/hamcrest/core/IsEqual.html new file mode 100644 index 000000000..c00181ac7 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsEqual.html @@ -0,0 +1,385 @@ + + + + + +IsEqual (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsEqual<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsEqual<T>
    +extends BaseMatcher<T>
    +
    Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsEqual(T equalArg) 
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsEqual

        +
        public IsEqual(T equalArg)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object actualValue)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        actualValue - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsInstanceOf.html b/docs/javadoc/2.1/org/hamcrest/core/IsInstanceOf.html new file mode 100644 index 000000000..86b91c4fe --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsInstanceOf.html @@ -0,0 +1,386 @@ + + + + + +IsInstanceOf (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsInstanceOf

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Object>, SelfDescribing
    +
    +
    +
    +
    public class IsInstanceOf
    +extends DiagnosingMatcher<java.lang.Object>
    +
    Tests whether the value is an instance of a class. + Classes of basic types will be converted to the relevant "Object" classes
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsInstanceOf(java.lang.Class<?> expectedClass) +
      Creates a new instance of IsInstanceOf
      +
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsInstanceOf

        +
        public IsInstanceOf(java.lang.Class<?> expectedClass)
        +
        Creates a new instance of IsInstanceOf
        +
        +
        Parameters:
        +
        expectedClass - The predicate evaluates to true for instances of this class + or one of its subclasses.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsIterableContaining.html b/docs/javadoc/2.1/org/hamcrest/core/IsIterableContaining.html new file mode 100644 index 000000000..b43769056 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsIterableContaining.html @@ -0,0 +1,445 @@ + + + + + +IsIterableContaining (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsIterableContaining<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? super T> collection, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContaining

        +
        public IsIterableContaining(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsNot.html b/docs/javadoc/2.1/org/hamcrest/core/IsNot.html new file mode 100644 index 000000000..b0e3f0ebb --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsNot.html @@ -0,0 +1,376 @@ + + + + + +IsNot (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNot<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsNot<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical negation of a matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNot

        +
        public IsNot(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsNull.html b/docs/javadoc/2.1/org/hamcrest/core/IsNull.html new file mode 100644 index 000000000..f332959d8 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsNull.html @@ -0,0 +1,412 @@ + + + + + +IsNull (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNull<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNull

        +
        public IsNull()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/IsSame.html b/docs/javadoc/2.1/org/hamcrest/core/IsSame.html new file mode 100644 index 000000000..e0d2c3cff --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/IsSame.html @@ -0,0 +1,376 @@ + + + + + +IsSame (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsSame<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsSame<T>
    +extends BaseMatcher<T>
    +
    Is the value the same object as another value?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsSame

        +
        public IsSame(T object)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/StringContains.html b/docs/javadoc/2.1/org/hamcrest/core/StringContains.html new file mode 100644 index 000000000..b82ef677c --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/StringContains.html @@ -0,0 +1,379 @@ + + + + + +StringContains (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringContains

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringContains
    +extends SubstringMatcher
    +
    Tests if the argument is a string that contains a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContains

        +
        public StringContains(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/StringEndsWith.html b/docs/javadoc/2.1/org/hamcrest/core/StringEndsWith.html new file mode 100644 index 000000000..f652125c3 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/StringEndsWith.html @@ -0,0 +1,379 @@ + + + + + +StringEndsWith (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringEndsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringEndsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that ends with a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringEndsWith

        +
        public StringEndsWith(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWithIgnoringCase("note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/StringRegularExpression.html b/docs/javadoc/2.1/org/hamcrest/core/StringRegularExpression.html new file mode 100644 index 000000000..9b5b6f1ff --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/StringRegularExpression.html @@ -0,0 +1,385 @@ + + + + + +StringRegularExpression (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringRegularExpression

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringRegularExpression

        +
        protected StringRegularExpression(java.util.regex.Pattern pattern)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.String actual,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.util.regex.Pattern pattern)
        +
        Creates a matcher that checks if the examined string matches a specified Pattern. + +
        + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
        + 
        +
        +
        Parameters:
        +
        pattern - the pattern to be used.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.lang.String regex)
        +
        Creates a matcher that checks if the examined string matches a specified regex. + +
        + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
        + 
        +
        +
        Parameters:
        +
        regex - The regex to be used for the validation.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/StringStartsWith.html b/docs/javadoc/2.1/org/hamcrest/core/StringStartsWith.html new file mode 100644 index 000000000..fd0207c51 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/StringStartsWith.html @@ -0,0 +1,385 @@ + + + + + +StringStartsWith (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringStartsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringStartsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that starts with a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringStartsWith

        +
        public StringStartsWith(boolean ignoringCase,
        +                        java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWithIgnoringCase("My"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/SubstringMatcher.html b/docs/javadoc/2.1/org/hamcrest/core/SubstringMatcher.html new file mode 100644 index 000000000..022ca4cde --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/SubstringMatcher.html @@ -0,0 +1,425 @@ + + + + + +SubstringMatcher (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class SubstringMatcher

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        substring

        +
        protected final java.lang.String substring
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SubstringMatcher

        +
        protected SubstringMatcher(java.lang.String relationship,
        +                           boolean ignoringCase,
        +                           java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        converted

        +
        protected java.lang.String converted(java.lang.String arg)
        +
      • +
      + + + +
        +
      • +

        evalSubstringOf

        +
        protected abstract boolean evalSubstringOf(java.lang.String string)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/package-frame.html b/docs/javadoc/2.1/org/hamcrest/core/package-frame.html new file mode 100644 index 000000000..105337202 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/package-frame.html @@ -0,0 +1,40 @@ + + + + + +org.hamcrest.core (Hamcrest 2.1 API) + + + + + +

org.hamcrest.core

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/package-summary.html b/docs/javadoc/2.1/org/hamcrest/core/package-summary.html new file mode 100644 index 000000000..0cecbd404 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/package-summary.html @@ -0,0 +1,259 @@ + + + + + +org.hamcrest.core (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.core

+
+
Fundamental matchers of objects and values, and composite matchers.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.core Description

+

Fundamental matchers of objects and values, and composite matchers.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/core/package-tree.html b/docs/javadoc/2.1/org/hamcrest/core/package-tree.html new file mode 100644 index 000000000..84b923750 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/core/package-tree.html @@ -0,0 +1,174 @@ + + + + + +org.hamcrest.core Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.core

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/ArrayIterator.html b/docs/javadoc/2.1/org/hamcrest/internal/ArrayIterator.html new file mode 100644 index 000000000..43839f5d5 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/ArrayIterator.html @@ -0,0 +1,319 @@ + + + + + +ArrayIterator (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ArrayIterator

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ArrayIterator
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<java.lang.Object>
    +
    +
    +
    +
    public class ArrayIterator
    +extends java.lang.Object
    +implements java.util.Iterator<java.lang.Object>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ArrayIterator(java.lang.Object array) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      java.lang.Objectnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayIterator

        +
        public ArrayIterator(java.lang.Object array)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        next

        +
        public java.lang.Object next()
        +
        +
        Specified by:
        +
        next in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/NullSafety.html b/docs/javadoc/2.1/org/hamcrest/internal/NullSafety.html new file mode 100644 index 000000000..7a1bd85b1 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/NullSafety.html @@ -0,0 +1,269 @@ + + + + + +NullSafety (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class NullSafety

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.NullSafety
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class NullSafety
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      NullSafety() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> java.util.List<Matcher<? super E>>nullSafe(Matcher<? super E>[] itemMatchers) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullSafety

        +
        public NullSafety()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        nullSafe

        +
        public static <E> java.util.List<Matcher<? super E>> nullSafe(Matcher<? super E>[] itemMatchers)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/ReflectiveTypeFinder.html b/docs/javadoc/2.1/org/hamcrest/internal/ReflectiveTypeFinder.html new file mode 100644 index 000000000..edfc1bea9 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/ReflectiveTypeFinder.html @@ -0,0 +1,273 @@ + + + + + +ReflectiveTypeFinder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ReflectiveTypeFinder

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ReflectiveTypeFinder
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class ReflectiveTypeFinder
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ReflectiveTypeFinder(java.lang.String methodName, + int expectedNumberOfParameters, + int typedParameter) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      java.lang.Class<?>findExpectedType(java.lang.Class<?> fromClass) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ReflectiveTypeFinder

        +
        public ReflectiveTypeFinder(java.lang.String methodName,
        +                            int expectedNumberOfParameters,
        +                            int typedParameter)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        findExpectedType

        +
        public java.lang.Class<?> findExpectedType(java.lang.Class<?> fromClass)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValue.html b/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValue.html new file mode 100644 index 000000000..0e54cc640 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValue.html @@ -0,0 +1,288 @@ + + + + + +SelfDescribingValue (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValue<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValue<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    SelfDescribing
    +
    +
    +
    +
    public class SelfDescribingValue<T>
    +extends java.lang.Object
    +implements SelfDescribing
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      SelfDescribingValue(T value) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SelfDescribingValue

        +
        public SelfDescribingValue(T value)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValueIterator.html b/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValueIterator.html new file mode 100644 index 000000000..597ebe2cd --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/SelfDescribingValueIterator.html @@ -0,0 +1,319 @@ + + + + + +SelfDescribingValueIterator (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValueIterator<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValueIterator<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<SelfDescribing>
    +
    +
    +
    +
    public class SelfDescribingValueIterator<T>
    +extends java.lang.Object
    +implements java.util.Iterator<SelfDescribing>
    +
  • +
+
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      SelfDescribingnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SelfDescribingValueIterator

        +
        public SelfDescribingValueIterator(java.util.Iterator<T> values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      + + + + + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/package-frame.html b/docs/javadoc/2.1/org/hamcrest/internal/package-frame.html new file mode 100644 index 000000000..19e4b4bf2 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.internal (Hamcrest 2.1 API) + + + + + +

org.hamcrest.internal

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/package-summary.html b/docs/javadoc/2.1/org/hamcrest/internal/package-summary.html new file mode 100644 index 000000000..268b1d433 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/package-summary.html @@ -0,0 +1,156 @@ + + + + + +org.hamcrest.internal (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.internal

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/internal/package-tree.html b/docs/javadoc/2.1/org/hamcrest/internal/package-tree.html new file mode 100644 index 000000000..00cedc327 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/internal/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.internal Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.internal

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.FileStatus.html b/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.FileStatus.html new file mode 100644 index 000000000..bb31eb703 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.FileStatus.html @@ -0,0 +1,223 @@ + + + + + +FileMatchers.FileStatus (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Interface FileMatchers.FileStatus

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    FileMatchers
    +
    +
    +
    +
    public static interface FileMatchers.FileStatus
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        check

        +
        boolean check(java.io.File actual)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.html b/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.html new file mode 100644 index 000000000..71c7ba196 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/io/FileMatchers.html @@ -0,0 +1,493 @@ + + + + + +FileMatchers (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Class FileMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.io.FileMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class FileMatchers
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FileMatchers

        +
        public FileMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        anExistingDirectory

        +
        public static Matcher<java.io.File> anExistingDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFileOrDirectory

        +
        public static Matcher<java.io.File> anExistingFileOrDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFile

        +
        public static Matcher<java.io.File> anExistingFile()
        +
      • +
      + + + +
        +
      • +

        aReadableFile

        +
        public static Matcher<java.io.File> aReadableFile()
        +
      • +
      + + + +
        +
      • +

        aWritableFile

        +
        public static Matcher<java.io.File> aWritableFile()
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(long size)
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(Matcher<java.lang.Long> expected)
        +
      • +
      + + + +
        +
      • +

        aFileNamed

        +
        public static Matcher<java.io.File> aFileNamed(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithCanonicalPath

        +
        public static Matcher<java.io.File> aFileWithCanonicalPath(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithAbsolutePath

        +
        public static Matcher<java.io.File> aFileWithAbsolutePath(Matcher<java.lang.String> expected)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/io/package-frame.html b/docs/javadoc/2.1/org/hamcrest/io/package-frame.html new file mode 100644 index 000000000..a2504313b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/io/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.io (Hamcrest 2.1 API) + + + + + +

org.hamcrest.io

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/docs/javadoc/2.1/org/hamcrest/io/package-summary.html b/docs/javadoc/2.1/org/hamcrest/io/package-summary.html new file mode 100644 index 000000000..aff3ef38b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/io/package-summary.html @@ -0,0 +1,155 @@ + + + + + +org.hamcrest.io (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.io

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/io/package-tree.html b/docs/javadoc/2.1/org/hamcrest/io/package-tree.html new file mode 100644 index 000000000..c83081a66 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/io/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.io Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.io

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/BigDecimalCloseTo.html b/docs/javadoc/2.1/org/hamcrest/number/BigDecimalCloseTo.html new file mode 100644 index 000000000..148fbca79 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/BigDecimalCloseTo.html @@ -0,0 +1,383 @@ + + + + + +BigDecimalCloseTo (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class BigDecimalCloseTo

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BigDecimalCloseTo

        +
        public BigDecimalCloseTo(java.math.BigDecimal value,
        +                         java.math.BigDecimal error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.math.BigDecimal item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.math.BigDecimal item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/IsCloseTo.html b/docs/javadoc/2.1/org/hamcrest/number/IsCloseTo.html new file mode 100644 index 000000000..d71914062 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/IsCloseTo.html @@ -0,0 +1,384 @@ + + + + + +IsCloseTo (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsCloseTo

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public class IsCloseTo
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number equal to a value within some range of + acceptable error?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCloseTo

        +
        public IsCloseTo(double value,
        +                 double error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/IsNaN.html b/docs/javadoc/2.1/org/hamcrest/number/IsNaN.html new file mode 100644 index 000000000..c564e3790 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/IsNaN.html @@ -0,0 +1,338 @@ + + + + + +IsNaN (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsNaN

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public final class IsNaN
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number actually not a number (NaN)?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/OrderingComparison.html b/docs/javadoc/2.1/org/hamcrest/number/OrderingComparison.html new file mode 100644 index 000000000..b8077df28 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/OrderingComparison.html @@ -0,0 +1,366 @@ + + + + + +OrderingComparison (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class OrderingComparison

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.number.OrderingComparison
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class OrderingComparison
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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>
      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>
      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>
      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.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/package-frame.html b/docs/javadoc/2.1/org/hamcrest/number/package-frame.html new file mode 100644 index 000000000..a9a663402 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.number (Hamcrest 2.1 API) + + + + + +

org.hamcrest.number

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/package-summary.html b/docs/javadoc/2.1/org/hamcrest/number/package-summary.html new file mode 100644 index 000000000..48d8ca043 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/package-summary.html @@ -0,0 +1,166 @@ + + + + + +org.hamcrest.number (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.number

+
+
Matchers that perform numeric comparisons.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    BigDecimalCloseTo 
    IsCloseTo +
    Is the value a number equal to a value within some range of + acceptable error?
    +
    IsNaN +
    Is the value a number actually not a number (NaN)?
    +
    OrderingComparison 
    +
  • +
+ + + +

Package org.hamcrest.number Description

+

Matchers that perform numeric comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/number/package-tree.html b/docs/javadoc/2.1/org/hamcrest/number/package-tree.html new file mode 100644 index 000000000..ef89e9796 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/number/package-tree.html @@ -0,0 +1,146 @@ + + + + + +org.hamcrest.number Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.number

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/HasEqualValues.html b/docs/javadoc/2.1/org/hamcrest/object/HasEqualValues.html new file mode 100644 index 000000000..5d2f8931f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/HasEqualValues.html @@ -0,0 +1,335 @@ + + + + + +HasEqualValues (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class HasEqualValues<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        HasEqualValues

        +
        public HasEqualValues(T expectedObject)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/HasToString.html b/docs/javadoc/2.1/org/hamcrest/object/HasToString.html new file mode 100644 index 000000000..e51e5fa9a --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/HasToString.html @@ -0,0 +1,371 @@ + + + + + +HasToString (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class HasToString<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasToString

        +
        public HasToString(Matcher<? super java.lang.String> toStringMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.String featureValueOf(T actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<T,java.lang.String>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/IsCompatibleType.html b/docs/javadoc/2.1/org/hamcrest/object/IsCompatibleType.html new file mode 100644 index 000000000..7ded8d846 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/IsCompatibleType.html @@ -0,0 +1,377 @@ + + + + + +IsCompatibleType (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsCompatibleType<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCompatibleType

        +
        public IsCompatibleType(java.lang.Class<T> type)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Class<?> cls)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Class<?> cls,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/IsEventFrom.html b/docs/javadoc/2.1/org/hamcrest/object/IsEventFrom.html new file mode 100644 index 000000000..4e6b36d5e --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/IsEventFrom.html @@ -0,0 +1,385 @@ + + + + + +IsEventFrom (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsEventFrom

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.EventObject>, SelfDescribing
    +
    +
    +
    +
    public class IsEventFrom
    +extends TypeSafeDiagnosingMatcher<java.util.EventObject>
    +
    Tests if the value is an event announced by a specific object.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEventFrom

        +
        public IsEventFrom(java.lang.Class<?> eventClass,
        +                   java.lang.Object source)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.EventObject item,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.util.EventObject>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/package-frame.html b/docs/javadoc/2.1/org/hamcrest/object/package-frame.html new file mode 100644 index 000000000..523ee94f3 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.object (Hamcrest 2.1 API) + + + + + +

org.hamcrest.object

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/package-summary.html b/docs/javadoc/2.1/org/hamcrest/object/package-summary.html new file mode 100644 index 000000000..af28ff1ad --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/package-summary.html @@ -0,0 +1,163 @@ + + + + + +org.hamcrest.object (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.object

+
+
Matchers that inspect objects and classes.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.object Description

+

Matchers that inspect objects and classes.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/object/package-tree.html b/docs/javadoc/2.1/org/hamcrest/object/package-tree.html new file mode 100644 index 000000000..6eb556656 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/object/package-tree.html @@ -0,0 +1,154 @@ + + + + + +org.hamcrest.object Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.object

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/package-frame.html b/docs/javadoc/2.1/org/hamcrest/package-frame.html new file mode 100644 index 000000000..9dd2400fd --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/package-frame.html @@ -0,0 +1,40 @@ + + + + + +org.hamcrest (Hamcrest 2.1 API) + + + + + +

org.hamcrest

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/package-summary.html b/docs/javadoc/2.1/org/hamcrest/package-summary.html new file mode 100644 index 000000000..e530297c6 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/package-summary.html @@ -0,0 +1,247 @@ + + + + + +org.hamcrest (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/package-tree.html b/docs/javadoc/2.1/org/hamcrest/package-tree.html new file mode 100644 index 000000000..f79b22a0b --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/package-tree.html @@ -0,0 +1,170 @@ + + + + + +org.hamcrest Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/CharSequenceLength.html b/docs/javadoc/2.1/org/hamcrest/text/CharSequenceLength.html new file mode 100644 index 000000000..32731cea0 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/CharSequenceLength.html @@ -0,0 +1,377 @@ + + + + + +CharSequenceLength (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class CharSequenceLength

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.CharSequence>, SelfDescribing
    +
    +
    +
    +
    public class CharSequenceLength
    +extends FeatureMatcher<java.lang.CharSequence,java.lang.Integer>
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CharSequenceLength

        +
        public CharSequenceLength(Matcher<? super java.lang.Integer> lengthMatcher)
        +
        +
        Parameters:
        +
        lengthMatcher - The matcher to apply to the feature
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.lang.CharSequence actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.lang.CharSequence,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(int length)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
        + assertThat("text", hasLength(4))
        + 
        +
        +
        Parameters:
        +
        length - the expected length of the string
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(Matcher<? super java.lang.Integer> lengthMatcher)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
        + assertThat("text", hasLength(lessThan(4)))
        + 
        +
        +
        Parameters:
        +
        lengthMatcher - the expected length of the string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/IsBlankString.html b/docs/javadoc/2.1/org/hamcrest/text/IsBlankString.html new file mode 100644 index 000000000..216197bcf --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/IsBlankString.html @@ -0,0 +1,336 @@ + + + + + +IsBlankString (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsBlankString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsBlankString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches blank Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/IsEmptyString.html b/docs/javadoc/2.1/org/hamcrest/text/IsEmptyString.html new file mode 100644 index 000000000..d809bd495 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/IsEmptyString.html @@ -0,0 +1,379 @@ + + + + + +IsEmptyString (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEmptyString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsEmptyString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches empty Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/IsEqualCompressingWhiteSpace.html b/docs/javadoc/2.1/org/hamcrest/text/IsEqualCompressingWhiteSpace.html new file mode 100644 index 000000000..af17d82fc --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/IsEqualCompressingWhiteSpace.html @@ -0,0 +1,418 @@ + + + + + +IsEqualCompressingWhiteSpace (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualCompressingWhiteSpace

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualCompressingWhiteSpace
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, compressing any changes in whitespace.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualCompressingWhiteSpace

        +
        public IsEqualCompressingWhiteSpace(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stripSpaces

        +
        public java.lang.String stripSpaces(java.lang.String toBeStripped)
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString)
        + +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToCompressingWhiteSpace

        +
        public static Matcher<java.lang.String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToCompressingWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/IsEqualIgnoringCase.html b/docs/javadoc/2.1/org/hamcrest/text/IsEqualIgnoringCase.html new file mode 100644 index 000000000..89fcb922a --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/IsEqualIgnoringCase.html @@ -0,0 +1,378 @@ + + + + + +IsEqualIgnoringCase (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualIgnoringCase

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualIgnoringCase
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, regardless of the case.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualIgnoringCase

        +
        public IsEqualIgnoringCase(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/MatchesPattern.html b/docs/javadoc/2.1/org/hamcrest/text/MatchesPattern.html new file mode 100644 index 000000000..783163fe3 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/MatchesPattern.html @@ -0,0 +1,365 @@ + + + + + +MatchesPattern (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class MatchesPattern

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatchesPattern

        +
        public MatchesPattern(java.util.regex.Pattern pattern)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/StringContainsInOrder.html b/docs/javadoc/2.1/org/hamcrest/text/StringContainsInOrder.html new file mode 100644 index 000000000..af1d298e7 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/StringContainsInOrder.html @@ -0,0 +1,403 @@ + + + + + +StringContainsInOrder (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class StringContainsInOrder

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContainsInOrder

        +
        public StringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String s)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/package-frame.html b/docs/javadoc/2.1/org/hamcrest/text/package-frame.html new file mode 100644 index 000000000..e31627a39 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/package-frame.html @@ -0,0 +1,26 @@ + + + + + +org.hamcrest.text (Hamcrest 2.1 API) + + + + + +

org.hamcrest.text

+ + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/package-summary.html b/docs/javadoc/2.1/org/hamcrest/text/package-summary.html new file mode 100644 index 000000000..9e7ebbda4 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/package-summary.html @@ -0,0 +1,181 @@ + + + + + +org.hamcrest.text (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.text

+
+
Matchers that perform text comparisons.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.text Description

+

Matchers that perform text comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/text/package-tree.html b/docs/javadoc/2.1/org/hamcrest/text/package-tree.html new file mode 100644 index 000000000..8b6ef8b13 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/text/package-tree.html @@ -0,0 +1,157 @@ + + + + + +org.hamcrest.text Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.text

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/xml/HasXPath.html b/docs/javadoc/2.1/org/hamcrest/xml/HasXPath.html new file mode 100644 index 000000000..4897d416f --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/xml/HasXPath.html @@ -0,0 +1,509 @@ + + + + + +HasXPath (Hamcrest 2.1 API) + + + + + + + + + + + + +
+
org.hamcrest.xml
+

Class HasXPath

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<org.w3c.dom.Node>, SelfDescribing
    +
    +
    +
    +
    public class HasXPath
    +extends TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
    +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static javax.xml.namespace.NamespaceContextNO_NAMESPACE_CONTEXT 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      HasXPath(java.lang.String xPathExpression, + Matcher<java.lang.String> valueMatcher) 
      HasXPath(java.lang.String xPathExpression, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      booleanmatchesSafely(org.w3c.dom.Node item, + Description mismatch) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_NAMESPACE_CONTEXT

        +
        public static final javax.xml.namespace.NamespaceContext NO_NAMESPACE_CONTEXT
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                javax.xml.namespace.NamespaceContext namespaceContext,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        namespaceContext - Resolves XML namespace prefixes in the XPath expression
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(org.w3c.dom.Node item,
        +                             Description mismatch)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/xml/package-frame.html b/docs/javadoc/2.1/org/hamcrest/xml/package-frame.html new file mode 100644 index 000000000..d558d8ae4 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/xml/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.xml (Hamcrest 2.1 API) + + + + + +

org.hamcrest.xml

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.1/org/hamcrest/xml/package-summary.html b/docs/javadoc/2.1/org/hamcrest/xml/package-summary.html new file mode 100644 index 000000000..a68fd9d64 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/xml/package-summary.html @@ -0,0 +1,151 @@ + + + + + +org.hamcrest.xml (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Package org.hamcrest.xml

+
+
Matchers of XML documents.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasXPath +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
    +
  • +
+ + + +

Package org.hamcrest.xml Description

+

Matchers of XML documents.

+
+ + + + + + diff --git a/docs/javadoc/2.1/org/hamcrest/xml/package-tree.html b/docs/javadoc/2.1/org/hamcrest/xml/package-tree.html new file mode 100644 index 000000000..f0eba0813 --- /dev/null +++ b/docs/javadoc/2.1/org/hamcrest/xml/package-tree.html @@ -0,0 +1,143 @@ + + + + + +org.hamcrest.xml Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.xml

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.1/overview-frame.html b/docs/javadoc/2.1/overview-frame.html new file mode 100644 index 000000000..9cbe8e610 --- /dev/null +++ b/docs/javadoc/2.1/overview-frame.html @@ -0,0 +1,31 @@ + + + + + +Overview List (Hamcrest 2.1 API) + + + + + + + +

 

+ + diff --git a/docs/javadoc/2.1/overview-summary.html b/docs/javadoc/2.1/overview-summary.html new file mode 100644 index 000000000..ce4b1d80a --- /dev/null +++ b/docs/javadoc/2.1/overview-summary.html @@ -0,0 +1,190 @@ + + + + + +Overview (Hamcrest 2.1 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

Hamcrest 2.1 API

+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Packages 
PackageDescription
org.hamcrest 
org.hamcrest.beans +
Matchers of Java Bean properties and their values.
+
org.hamcrest.collection +
Matchers of arrays and collections.
+
org.hamcrest.comparator 
org.hamcrest.core +
Fundamental matchers of objects and values, and composite matchers.
+
org.hamcrest.internal 
org.hamcrest.io 
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.
+
+
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.1/overview-tree.html b/docs/javadoc/2.1/overview-tree.html new file mode 100644 index 000000000..046142039 --- /dev/null +++ b/docs/javadoc/2.1/overview-tree.html @@ -0,0 +1,255 @@ + + + + + +Class Hierarchy (Hamcrest 2.1 API) + + + + + + + + +
+ + + + + + + +
+ + + +
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.1/package-list b/docs/javadoc/2.1/package-list new file mode 100644 index 000000000..37d7af536 --- /dev/null +++ b/docs/javadoc/2.1/package-list @@ -0,0 +1,11 @@ +org.hamcrest +org.hamcrest.beans +org.hamcrest.collection +org.hamcrest.comparator +org.hamcrest.core +org.hamcrest.internal +org.hamcrest.io +org.hamcrest.number +org.hamcrest.object +org.hamcrest.text +org.hamcrest.xml diff --git a/docs/javadoc/2.1/script.js b/docs/javadoc/2.1/script.js new file mode 100644 index 000000000..b34635693 --- /dev/null +++ b/docs/javadoc/2.1/script.js @@ -0,0 +1,30 @@ +function show(type) +{ + count = 0; + for (var key in methods) { + var row = document.getElementById(key); + if ((methods[key] & type) != 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) +{ + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} diff --git a/docs/javadoc/2.1/stylesheet.css b/docs/javadoc/2.1/stylesheet.css new file mode 100644 index 000000000..98055b22d --- /dev/null +++ b/docs/javadoc/2.1/stylesheet.css @@ -0,0 +1,574 @@ +/* Javadoc style sheet */ +/* +Overall document style +*/ + +@import url('resources/fonts/dejavu.css'); + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a:hover, a:focus { + text-decoration:none; + color:#bb7a2a; +} +a:active { + text-decoration:none; + color:#4A6782; +} +a[name] { + color:#353833; +} +a[name]:hover { + text-decoration:none; + color:#353833; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} +/* +Document title and Copyright styles +*/ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* +Navigation bar styles +*/ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.subNavList li{ + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* +Page header and footer styles +*/ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexHeader { + margin:10px; + position:relative; +} +.indexHeader span{ + margin-right:15px; +} +.indexHeader h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* +Heading styles +*/ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* +Page layout container styles +*/ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Sans Mono',monospace; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* +List styles +*/ +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* +Table styles +*/ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary { + width:100%; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited { + color:#FFFFFF; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; + +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th, +td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{ + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colLast, th.colOne, .constantsSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + white-space:nowrap; + font-size:13px; +} +td.colLast, th.colLast { + font-size:13px; +} +td.colOne, th.colOne { + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.useSummary td.colFirst, .useSummary th.colFirst, +.overviewSummary td.colOne, .overviewSummary th.colOne, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colOne, .memberSummary th.colOne, +.typeSummary td.colFirst{ + width:25%; + vertical-align:top; +} +td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor { + background-color:#FFFFFF; +} +.rowColor { + background-color:#EEEEEF; +} +/* +Content styles +*/ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} + +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} + +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} + +td.colLast div { + padding-top:0px; +} + + +td.colLast a { + padding-bottom:3px; +} +/* +Formatting effect styles +*/ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink, +.overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel, +.seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} + +div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} + +div.contentContainer ul.blockList li.blockList h2{ + padding-bottom:0px; +} diff --git a/docs/javadoc/2.2/allclasses-frame.html b/docs/javadoc/2.2/allclasses-frame.html new file mode 100644 index 000000000..5145c2e43 --- /dev/null +++ b/docs/javadoc/2.2/allclasses-frame.html @@ -0,0 +1,102 @@ + + + + + +All Classes (Hamcrest 2.2 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.2/allclasses-noframe.html b/docs/javadoc/2.2/allclasses-noframe.html new file mode 100644 index 000000000..1afaf835c --- /dev/null +++ b/docs/javadoc/2.2/allclasses-noframe.html @@ -0,0 +1,102 @@ + + + + + +All Classes (Hamcrest 2.2 API) + + + + + +

All Classes

+ + + diff --git a/docs/javadoc/2.2/constant-values.html b/docs/javadoc/2.2/constant-values.html new file mode 100644 index 000000000..55453fb28 --- /dev/null +++ b/docs/javadoc/2.2/constant-values.html @@ -0,0 +1,122 @@ + + + + + +Constant Field Values (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Constant Field Values

+

Contents

+
+ + + + + + diff --git a/docs/javadoc/2.2/deprecated-list.html b/docs/javadoc/2.2/deprecated-list.html new file mode 100644 index 000000000..702c30dc5 --- /dev/null +++ b/docs/javadoc/2.2/deprecated-list.html @@ -0,0 +1,290 @@ + + + + + +Deprecated List (Hamcrest 2.2 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

Deprecated API

+

Contents

+ +
+
+ + + + + + + +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.2/help-doc.html b/docs/javadoc/2.2/help-doc.html new file mode 100644 index 000000000..65cd5957e --- /dev/null +++ b/docs/javadoc/2.2/help-doc.html @@ -0,0 +1,223 @@ + + + + + +API Help (Hamcrest 2.2 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

How This API Document Is Organized

+
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+
+
+
    +
  • +

    Overview

    +

    The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

    +
  • +
  • +

    Package

    +

    Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:

    +
      +
    • Interfaces (italic)
    • +
    • Classes
    • +
    • Enums
    • +
    • Exceptions
    • +
    • Errors
    • +
    • Annotation Types
    • +
    +
  • +
  • +

    Class/Interface

    +

    Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:

    +
      +
    • Class inheritance diagram
    • +
    • Direct Subclasses
    • +
    • All Known Subinterfaces
    • +
    • All Known Implementing Classes
    • +
    • Class/interface declaration
    • +
    • Class/interface description
    • +
    +
      +
    • Nested Class Summary
    • +
    • Field Summary
    • +
    • Constructor Summary
    • +
    • Method Summary
    • +
    +
      +
    • Field Detail
    • +
    • Constructor Detail
    • +
    • Method Detail
    • +
    +

    Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.

    +
  • +
  • +

    Annotation Type

    +

    Each annotation type has its own separate page with the following sections:

    +
      +
    • Annotation Type declaration
    • +
    • Annotation Type description
    • +
    • Required Element Summary
    • +
    • Optional Element Summary
    • +
    • Element Detail
    • +
    +
  • +
  • +

    Enum

    +

    Each enum has its own separate page with the following sections:

    +
      +
    • Enum declaration
    • +
    • Enum description
    • +
    • Enum Constant Summary
    • +
    • Enum Constant Detail
    • +
    +
  • +
  • +

    Tree (Class Hierarchy)

    +

    There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.

    +
      +
    • When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
    • +
    • When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
    • +
    +
  • +
  • +

    Deprecated API

    +

    The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.

    +
  • +
  • +

    Index

    +

    The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.

    +
  • +
  • +

    Prev/Next

    +

    These links take you to the next or previous class, interface, package, or related page.

    +
  • +
  • +

    Frames/No Frames

    +

    These links show and hide the HTML frames. All pages are available with or without frames.

    +
  • +
  • +

    All Classes

    +

    The All Classes link shows all classes and interfaces except non-static nested types.

    +
  • +
  • +

    Serialized Form

    +

    Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.

    +
  • +
  • +

    Constant Field Values

    +

    The Constant Field Values page lists the static final fields and their values.

    +
  • +
+This help file applies to API documentation generated using the standard doclet.
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.2/index-all.html b/docs/javadoc/2.2/index-all.html new file mode 100644 index 000000000..df11b0034 --- /dev/null +++ b/docs/javadoc/2.2/index-all.html @@ -0,0 +1,2778 @@ + + + + + +Index (Hamcrest 2.2 API) + + + + + + + + +
+ + + + + + + +
+ + +
A B C D E F G H I L M N O P R S T U _  + + +

A

+
+
aFileNamed(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithAbsolutePath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithCanonicalPath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(long) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
aFileWithSize(Matcher<Long>) - Static method in class org.hamcrest.io.FileMatchers
+
 
+
AllOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical conjunction of multiple matchers.
+
+
AllOf(Matcher<? super T>...) - Constructor for class org.hamcrest.core.AllOf
+
 
+
AllOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AllOf
+
 
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
and(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
and(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
and(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
anEmptyMap() - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anEmptyMap() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anExistingDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
anExistingFileOrDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
any(Class<T>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
AnyOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical disjunction of multiple matchers.
+
+
AnyOf(Matcher<? super T>...) - Constructor for class org.hamcrest.core.AnyOf
+
 
+
AnyOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AnyOf
+
 
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anything() - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
append(String) - Method in class org.hamcrest.BaseDescription
+
+
Append the String str to the description.
+
+
append(char) - Method in class org.hamcrest.BaseDescription
+
+
Append the char c to the description.
+
+
append(String) - Method in class org.hamcrest.StringDescription
+
 
+
append(char) - Method in class org.hamcrest.StringDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.BaseDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in interface org.hamcrest.Description
+
+
Appends the description of a SelfDescribing value to this description.
+
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in interface org.hamcrest.Description
+
+
Appends a list of SelfDescribing objects + to the description.
+
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendText(String) - Method in class org.hamcrest.BaseDescription
+
 
+
appendText(String) - Method in interface org.hamcrest.Description
+
+
Appends some plain text to the description.
+
+
appendText(String) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValue(Object) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValue(Object) - Method in interface org.hamcrest.Description
+
+
Appends an arbitrary value to the description.
+
+
appendValue(Object) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, T...) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, Iterable<T>) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
apply(I, Description) - Method in interface org.hamcrest.Condition.Step
+
 
+
aReadableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsArray
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
ArrayAsIterableMatcher<E> - Class in org.hamcrest.collection
+
 
+
ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher<Iterable<? extends E>>, Collection<Matcher<? super E>>, String) - Constructor for class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. +
As of version 2.1, use ArrayMatching.arrayContaining(List).
+
+
+
arrayContaining(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
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.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
+ 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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
ArrayIterator - Class in org.hamcrest.internal
+
 
+
ArrayIterator(Object) - Constructor for class org.hamcrest.internal.ArrayIterator
+
 
+
ArrayMatching - Class in org.hamcrest.collection
+
 
+
ArrayMatching() - Constructor for class org.hamcrest.collection.ArrayMatching
+
 
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
asEqualMatchers(E[]) - Static method in class org.hamcrest.collection.ArrayMatching
+
 
+
assertThat(T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
 
+
assertThat(String, boolean) - Static method in class org.hamcrest.MatcherAssert
+
 
+
asString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+ +
+
aWritableFile() - Static method in class org.hamcrest.io.FileMatchers
+
 
+
+ + + +

B

+
+
BaseDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
BaseDescription() - Constructor for class org.hamcrest.BaseDescription
+
 
+
BaseMatcher<T> - Class in org.hamcrest
+
+
BaseClass for all Matcher implementations.
+
+
BaseMatcher() - Constructor for class org.hamcrest.BaseMatcher
+
 
+
BigDecimalCloseTo - Class in org.hamcrest.number
+
 
+
BigDecimalCloseTo(BigDecimal, BigDecimal) - Constructor for class org.hamcrest.number.BigDecimalCloseTo
+
 
+
blankOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankOrNullString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
+ + + +

C

+
+
CAN_READ - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
CAN_WRITE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
CharSequenceLength - Class in org.hamcrest.text
+
 
+
CharSequenceLength(Matcher<? super Integer>) - Constructor for class org.hamcrest.text.CharSequenceLength
+
 
+
check(File) - Method in interface org.hamcrest.io.FileMatchers.FileStatus
+
 
+
closeTo(double, double) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.number.BigDecimalCloseTo
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(double, double) - Static method in class org.hamcrest.number.IsCloseTo
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
CombinableBothMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
 
+
CombinableEitherMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
CombinableMatcher<T> - Class in org.hamcrest.core
+
 
+
CombinableMatcher(Matcher<? super T>) - Constructor for class org.hamcrest.core.CombinableMatcher
+
 
+
CombinableMatcher.CombinableBothMatcher<X> - Class in org.hamcrest.core
+
 
+
CombinableMatcher.CombinableEitherMatcher<X> - Class in org.hamcrest.core
+
 
+
ComparatorMatcherBuilder<T> - Class in org.hamcrest.comparator
+
 
+
comparedBy(Comparator<T>) - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparatorss of T.
+
+
comparesEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
Condition<T> - Class in org.hamcrest
+
+
A Condition implements part of a multi-step match.
+
+
Condition.Step<I,O> - Interface in org.hamcrest
+
 
+
contains(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsString(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
converted(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
CoreMatchers - Class in org.hamcrest
+
 
+
CoreMatchers() - Constructor for class org.hamcrest.CoreMatchers
+
 
+
CustomMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomMatcher(String) - Constructor for class org.hamcrest.CustomMatcher
+
 
+
CustomTypeSafeMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomTypeSafeMatcher(String) - Constructor for class org.hamcrest.CustomTypeSafeMatcher
+
 
+
+ + + +

D

+
+
DescribedAs<T> - Class in org.hamcrest.core
+
+
Provides a custom description to another matcher.
+
+
DescribedAs(String, Matcher<T>, Object[]) - Constructor for class org.hamcrest.core.DescribedAs
+
 
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.core.DescribedAs
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.CoreMatchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.Matchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.BaseMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.Is
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in interface org.hamcrest.Matcher
+
+
Generate a description of why the matcher has not accepted the item.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeMismatchSafely(Collection<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeMismatchSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeMismatchSafely(Map<? extends K, ? extends V>, Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeMismatchSafely(BigDecimal, Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeMismatchSafely(Class<?>, Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should override this.
+
+
describeTo(Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIn
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AllOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AnyOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Every
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Is
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsAnything
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.core.IsEqual
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNot
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNull
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsSame
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomTypeSafeMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.internal.SelfDescribingValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
describeTo(Description) - Method in interface org.hamcrest.SelfDescribing
+
+
Generates a description of the object.
+
+
describeTo(Description) - Method in class org.hamcrest.text.IsBlankString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
Description - Interface in org.hamcrest
+
+
A description of a Matcher.
+
+
Description.NullDescription - Class in org.hamcrest
+
 
+
descriptionEnd() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that ends the description.
+
+
descriptionSeparator() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that separates the elements in the description.
+
+
descriptionStart() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that starts the description.
+
+
DiagnosingMatcher<T> - Class in org.hamcrest
+
+
TODO(ngd): Document.
+
+
DiagnosingMatcher() - Constructor for class org.hamcrest.DiagnosingMatcher
+
 
+
+ + + +

E

+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
empty() - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
empty() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyArray() - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyArray() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyIterable() - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterable() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
emptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
endsWith(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
equalTo(T) - Static method in class org.hamcrest.core.IsEqual
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.text.IsEqualIgnoringCase
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+ +
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+ +
+
equalToObject(Object) - Static method in class org.hamcrest.core.IsEqual
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringContains
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringEndsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringStartsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
Every<T> - Class in org.hamcrest.core
+
 
+
Every(Matcher<? super T>) - Constructor for class org.hamcrest.core.Every
+
 
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.core.Every
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
EXISTS - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
+ + + +

F

+
+
FeatureMatcher<T,U> - Class in org.hamcrest
+
+
Supporting class for matching a feature of an object.
+
+
FeatureMatcher(Matcher<? super U>, String, String) - Constructor for class org.hamcrest.FeatureMatcher
+
+
Constructor
+
+
featureValueOf(E[]) - Method in class org.hamcrest.collection.IsArrayWithSize
+
 
+
featureValueOf(Collection<? extends E>) - Method in class org.hamcrest.collection.IsCollectionWithSize
+
 
+
featureValueOf(Iterable<E>) - Method in class org.hamcrest.collection.IsIterableWithSize
+
 
+
featureValueOf(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapWithSize
+
 
+
featureValueOf(T) - Method in class org.hamcrest.FeatureMatcher
+
+
Implement this to extract the interesting feature.
+
+
featureValueOf(T) - Method in class org.hamcrest.object.HasToString
+
 
+
featureValueOf(CharSequence) - Method in class org.hamcrest.text.CharSequenceLength
+
 
+
FileMatchers - Class in org.hamcrest.io
+
 
+
FileMatchers() - Constructor for class org.hamcrest.io.FileMatchers
+
 
+
FileMatchers.FileStatus - Interface in org.hamcrest.io
+
 
+
findExpectedType(Class<?>) - Method in class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
+ + + +

G

+
+
getPropertyDescriptor(String, Object) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns the description of the property with the provided + name on the provided object's interface.
+
+
greaterThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
greaterThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

H

+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
HasEqualValues<T> - Class in org.hamcrest.object
+
 
+
HasEqualValues(T) - Constructor for class org.hamcrest.object.HasEqualValues
+
 
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. +
As of version 2.1, use IsIterableContaining.hasItem(Object).
+
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
HasItemInArray<T> - Class in org.hamcrest.collection
+
+
Matches if an array contains an item satisfying a nested matcher.
+
+
HasItemInArray(Matcher<? super T>) - Constructor for class org.hamcrest.collection.HasItemInArray
+
 
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(K) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasLength(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
+
+
hasLength(int) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasLength(Matcher<? super Integer>) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasNext() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
hasNext() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
HasProperty<T> - Class in org.hamcrest.beans
+
+
A Matcher that checks that an object has a JavaBean property + with the specified name.
+
+
HasProperty(String) - Constructor for class org.hamcrest.beans.HasProperty
+
 
+
hasProperty(String) - Static method in class org.hamcrest.beans.HasProperty
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasProperty(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasPropertyAtPath(String, Matcher<T>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher.
+
+
HasPropertyWithValue<T> - Class in org.hamcrest.beans
+
+
Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
+
+
HasPropertyWithValue(String, Matcher<?>) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
 
+
HasPropertyWithValue(String, Matcher<?>, String) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
 
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
HasToString<T> - Class in org.hamcrest.object
+
 
+
HasToString(Matcher<? super String>) - Constructor for class org.hamcrest.object.HasToString
+
 
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
HasXPath - Class in org.hamcrest.xml
+
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+
HasXPath(String, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
HasXPath(String, NamespaceContext, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
 
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
+ + + +

I

+
+
in(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
in(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
Is<T> - Class in org.hamcrest.core
+
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+
+
Is(Matcher<T>) - Constructor for class org.hamcrest.core.Is
+
 
+
is(Matcher<T>) - Static method in class org.hamcrest.core.Is
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
IS_DIRECTORY - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
IS_FILE - Static variable in class org.hamcrest.io.FileMatchers
+
 
+
isA(Class<?>) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
IsAnything<T> - Class in org.hamcrest.core
+
+
A matcher that always returns true.
+
+
IsAnything() - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsAnything(String) - Constructor for class org.hamcrest.core.IsAnything
+
 
+
IsArray<T> - Class in org.hamcrest.collection
+
+
Matcher for array whose elements satisfy a sequence of matchers.
+
+
IsArray(Matcher<? super T>[]) - Constructor for class org.hamcrest.collection.IsArray
+
 
+
IsArrayContainingInAnyOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
IsArrayContainingInOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
IsArrayWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if array size satisfies a nested matcher.
+
+
IsArrayWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsArrayWithSize
+
 
+
IsBlankString - Class in org.hamcrest.text
+
+
Matches blank Strings (and null).
+
+
IsCloseTo - Class in org.hamcrest.number
+
+
Is the value a number equal to a value within some range of + acceptable error?
+
+
IsCloseTo(double, double) - Constructor for class org.hamcrest.number.IsCloseTo
+
 
+
IsCollectionContaining<T> - Class in org.hamcrest.core
+
+
Deprecated. +
As of release 2.1, replaced by IsIterableContaining.
+
+
+
IsCollectionContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
IsCollectionWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if collection size satisfies a nested matcher.
+
+
IsCollectionWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsCollectionWithSize
+
 
+
IsCompatibleType<T> - Class in org.hamcrest.object
+
 
+
IsCompatibleType(Class<T>) - Constructor for class org.hamcrest.object.IsCompatibleType
+
 
+
IsEmptyCollection<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyCollection() - Constructor for class org.hamcrest.collection.IsEmptyCollection
+
 
+
IsEmptyIterable<E> - Class in org.hamcrest.collection
+
+
Tests if collection is empty.
+
+
IsEmptyIterable() - Constructor for class org.hamcrest.collection.IsEmptyIterable
+
 
+
isEmptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEmptyString - Class in org.hamcrest.text
+
+
Matches empty Strings (and null).
+
+
isEmptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEqual<T> - Class in org.hamcrest.core
+
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
+
+
IsEqual(T) - Constructor for class org.hamcrest.core.IsEqual
+
 
+
IsEqualCompressingWhiteSpace - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, compressing any changes in whitespace.
+
+
IsEqualCompressingWhiteSpace(String) - Constructor for class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
IsEqualIgnoringCase - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, regardless of the case.
+
+
IsEqualIgnoringCase(String) - Constructor for class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
IsEventFrom - Class in org.hamcrest.object
+
+
Tests if the value is an event announced by a specific object.
+
+
IsEventFrom(Class<?>, Object) - Constructor for class org.hamcrest.object.IsEventFrom
+
 
+
IsIn<T> - Class in org.hamcrest.collection
+
 
+
IsIn(Collection<T>) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
IsIn(T[]) - Constructor for class org.hamcrest.collection.IsIn
+
 
+
isIn(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
IsInstanceOf - Class in org.hamcrest.core
+
+
Tests whether the value is an instance of a class.
+
+
IsInstanceOf(Class<?>) - Constructor for class org.hamcrest.core.IsInstanceOf
+
+
Creates a new instance of IsInstanceOf
+
+
IsIterableContaining<T> - Class in org.hamcrest.core
+
 
+
IsIterableContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsIterableContaining
+
 
+
IsIterableContainingInAnyOrder<T> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInAnyOrder(Collection<Matcher<? super T>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
IsIterableContainingInOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
IsIterableContainingInRelativeOrder<E> - Class in org.hamcrest.collection
+
 
+
IsIterableContainingInRelativeOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
IsIterableWithSize<E> - Class in org.hamcrest.collection
+
 
+
IsIterableWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsIterableWithSize
+
 
+
IsMapContaining<K,V> - Class in org.hamcrest.collection
+
 
+
IsMapContaining(Matcher<? super K>, Matcher<? super V>) - Constructor for class org.hamcrest.collection.IsMapContaining
+
 
+
IsMapWithSize<K,V> - Class in org.hamcrest.collection
+
+
Matches if map size satisfies a nested matcher.
+
+
IsMapWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsMapWithSize
+
 
+
IsNaN - Class in org.hamcrest.number
+
+
Is the value a number actually not a number (NaN)?
+
+
IsNot<T> - Class in org.hamcrest.core
+
+
Calculates the logical negation of a matcher.
+
+
IsNot(Matcher<T>) - Constructor for class org.hamcrest.core.IsNot
+
 
+
isNotNull(Object, Description) - Static method in class org.hamcrest.BaseMatcher
+
+
Useful null-check method.
+
+
IsNull<T> - Class in org.hamcrest.core
+
+
Is the value null?
+
+
IsNull() - Constructor for class org.hamcrest.core.IsNull
+
 
+
isOneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
isOneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
IsSame<T> - Class in org.hamcrest.core
+
+
Is the value the same object as another value?
+
+
IsSame(T) - Constructor for class org.hamcrest.core.IsSame
+
 
+
iterableMatcher - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
+ + + +

L

+
+
lessThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
lessThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+ + + +

M

+
+
matched(T, Description) - Static method in class org.hamcrest.Condition
+
 
+
Matcher<T> - Interface in org.hamcrest
+
+
+ A matcher over acceptable values.
+
+
MatcherAssert - Class in org.hamcrest
+
 
+
MatcherAssert() - Constructor for class org.hamcrest.MatcherAssert
+
 
+
matchers - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
Matchers - Class in org.hamcrest
+
 
+
Matchers() - Constructor for class org.hamcrest.Matchers
+
 
+
matches(Object, Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
matches(Object) - Method in class org.hamcrest.collection.IsIn
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.AllOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.AnyOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.DescribedAs
+
 
+
matches(Object) - Method in class org.hamcrest.core.Is
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsAnything
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsEqual
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNot
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNull
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsSame
+
 
+
matches(Object) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object) - Method in interface org.hamcrest.Matcher
+
+
Evaluates the matcher for argument item.
+
+
matches(Object) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
matches(Object) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Methods made final to prevent accidental override.
+
+
matchesPattern(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
MatchesPattern - Class in org.hamcrest.text
+
 
+
MatchesPattern(Pattern) - Constructor for class org.hamcrest.text.MatchesPattern
+
 
+
matchesPattern(Pattern) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified Pattern.
+
+
matchesRegex(String) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified regex.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a Pattern.
+
+
matchesRegex(String) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a regex.
+
+
matchesSafely(T) - Method in class org.hamcrest.beans.HasProperty
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.IsArray
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
matchesSafely(Collection<? extends E>) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
matchesSafely(Iterable<? extends E>) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
matchesSafely(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.core.Every
+
 
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
matchesSafely(String, Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
matchesSafely(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
matchesSafely(BigDecimal) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsNaN
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
matchesSafely(Class<?>) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
matchesSafely(EventObject, Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsBlankString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(T) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Subclasses should implement this.
+
+
matchesSafely(Node, Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
matching(Matcher<T>, String) - Method in class org.hamcrest.Condition
+
 
+
matching(Matcher<T>) - Method in class org.hamcrest.Condition
+
 
+
+ + + +

N

+
+
next() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
next() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
NO_ARGUMENTS - Static variable in class org.hamcrest.beans.PropertyUtil
+
 
+
NO_NAMESPACE_CONTEXT - Static variable in class org.hamcrest.xml.HasXPath
+
 
+
NONE - Static variable in interface org.hamcrest.Description
+
+
A description that consumes input but does nothing.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.core.IsNot
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.core.IsNot
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
NOT_MATCHED - Static variable in class org.hamcrest.Condition
+
 
+
notANumber() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notANumber() - Static method in class org.hamcrest.number.IsNaN
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notMatched() - Static method in class org.hamcrest.Condition
+
 
+
notNullValue() - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue() - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
NullDescription() - Constructor for class org.hamcrest.Description.NullDescription
+
 
+
nullSafe(Matcher<? super E>[]) - Static method in class org.hamcrest.internal.NullSafety
+
 
+
NullSafety - Class in org.hamcrest.internal
+
 
+
NullSafety() - Constructor for class org.hamcrest.internal.NullSafety
+
 
+
nullValue() - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
+ + + +

O

+
+
oneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
oneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
or(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
 
+
or(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
OrderingComparison - Class in org.hamcrest.number
+
 
+
org.hamcrest - package org.hamcrest
+
 
+
org.hamcrest.beans - package org.hamcrest.beans
+
+
Matchers of Java Bean properties and their values.
+
+
org.hamcrest.collection - package org.hamcrest.collection
+
+
Matchers of arrays and collections.
+
+
org.hamcrest.comparator - package org.hamcrest.comparator
+
 
+
org.hamcrest.core - package org.hamcrest.core
+
+
Fundamental matchers of objects and values, and composite matchers.
+
+
org.hamcrest.internal - package org.hamcrest.internal
+
 
+
org.hamcrest.io - package org.hamcrest.io
+
 
+
org.hamcrest.number - package org.hamcrest.number
+
+
Matchers that perform numeric comparisons.
+
+
org.hamcrest.object - package org.hamcrest.object
+
+
Matchers that inspect objects and classes.
+
+
org.hamcrest.text - package org.hamcrest.text
+
+
Matchers that perform text comparisons.
+
+
org.hamcrest.xml - package org.hamcrest.xml
+
+
Matchers of XML documents.
+
+
+ + + +

P

+
+
propertyDescriptorsFor(Object, Class<Object>) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns all the property descriptors for the class associated with the given object
+
+
PropertyUtil - Class in org.hamcrest.beans
+
+
Utility class for accessing properties on JavaBean objects.
+
+
PropertyUtil() - Constructor for class org.hamcrest.beans.PropertyUtil
+
 
+
+ + + +

R

+
+
ReflectiveTypeFinder - Class in org.hamcrest.internal
+
 
+
ReflectiveTypeFinder(String, int, int) - Constructor for class org.hamcrest.internal.ReflectiveTypeFinder
+
 
+
remove() - Method in class org.hamcrest.internal.ArrayIterator
+
 
+
remove() - Method in class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
+ + + +

S

+
+
sameInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
SamePropertyValuesAs<T> - Class in org.hamcrest.beans
+
 
+
SamePropertyValuesAs(T, List<String>) - Constructor for class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.beans.SamePropertyValuesAs
+
+
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.
+
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
SelfDescribing - Interface in org.hamcrest
+
+
The ability of an object to describe itself.
+
+
SelfDescribingValue<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValue(T) - Constructor for class org.hamcrest.internal.SelfDescribingValue
+
 
+
SelfDescribingValueIterator<T> - Class in org.hamcrest.internal
+
 
+
SelfDescribingValueIterator(Iterator<T>) - Constructor for class org.hamcrest.internal.SelfDescribingValueIterator
+
 
+
startsWith(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
StringContains - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a specific substring.
+
+
StringContains(String) - Constructor for class org.hamcrest.core.StringContains
+
 
+
StringContains(boolean, String) - Constructor for class org.hamcrest.core.StringContains
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringContainsInOrder - Class in org.hamcrest.text
+
 
+
StringContainsInOrder(Iterable<String>) - Constructor for class org.hamcrest.text.StringContainsInOrder
+
 
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
StringDescription() - Constructor for class org.hamcrest.StringDescription
+
 
+
StringDescription(Appendable) - Constructor for class org.hamcrest.StringDescription
+
 
+
StringEndsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that ends with a specific substring.
+
+
StringEndsWith(String) - Constructor for class org.hamcrest.core.StringEndsWith
+
 
+
StringEndsWith(boolean, String) - Constructor for class org.hamcrest.core.StringEndsWith
+
 
+
StringRegularExpression - Class in org.hamcrest.core
+
 
+
StringRegularExpression(Pattern) - Constructor for class org.hamcrest.core.StringRegularExpression
+
 
+
StringStartsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that starts with a specific substring.
+
+
StringStartsWith(String) - Constructor for class org.hamcrest.core.StringStartsWith
+
 
+
StringStartsWith(boolean, String) - Constructor for class org.hamcrest.core.StringStartsWith
+
 
+
stripSpaces(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
substring - Variable in class org.hamcrest.core.SubstringMatcher
+
 
+
SubstringMatcher - Class in org.hamcrest.core
+
 
+
SubstringMatcher(String, boolean, String) - Constructor for class org.hamcrest.core.SubstringMatcher
+
 
+
+ + + +

T

+
+
theInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
then(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
 
+
toString() - Method in class org.hamcrest.BaseMatcher
+
 
+
toString() - Method in class org.hamcrest.Description.NullDescription
+
 
+
toString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+
Return the description of a SelfDescribing object as a String.
+
+
toString() - Method in class org.hamcrest.StringDescription
+
+
Returns the description as a string.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.object.IsCompatibleType
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
TypeSafeDiagnosingMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+
+
TypeSafeDiagnosingMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher() - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type.
+
+
TypeSafeMatcher() - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
+ + + +

U

+
+
usingNaturalOrdering() - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparables.
+
+
+ + + +

_

+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in class org.hamcrest.BaseMatcher
+
+
Deprecated.
+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in interface org.hamcrest.Matcher
+
+
Deprecated. +
to make
+
+
+
+A B C D E F G H I L M N O P R S T U _ 
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.2/index.html b/docs/javadoc/2.2/index.html new file mode 100644 index 000000000..4edb47c55 --- /dev/null +++ b/docs/javadoc/2.2/index.html @@ -0,0 +1,75 @@ + + + + + +Hamcrest 2.2 API + + + + + + + + + +<noscript> +<div>JavaScript is disabled on your browser.</div> +</noscript> +<h2>Frame Alert</h2> +<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p> + + + diff --git a/docs/javadoc/2.2/org/hamcrest/BaseDescription.html b/docs/javadoc/2.2/org/hamcrest/BaseDescription.html new file mode 100644 index 000000000..77d217c02 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/BaseDescription.html @@ -0,0 +1,479 @@ + + + + + +BaseDescription (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseDescription
    • +
    +
  • +
+
+ +
+
+
    +
  • + + + + + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      BaseDescription() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethod and Description
      protected abstract voidappend(char c) +
      Append the char c to the description.
      +
      protected voidappend(java.lang.String str) +
      Append the String str to the description.
      +
      DescriptionappendDescriptionOf(SelfDescribing value) +
      Appends the description of a SelfDescribing value to this description.
      +
      DescriptionappendList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<? extends SelfDescribing> values) +
      Appends a list of SelfDescribing objects + to the description.
      +
      DescriptionappendText(java.lang.String text) +
      Appends some plain text to the description.
      +
      DescriptionappendValue(java.lang.Object value) +
      Appends an arbitrary value to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + java.lang.Iterable<T> values) +
      Appends a list of values to the description.
      +
      <T> DescriptionappendValueList(java.lang.String start, + java.lang.String separator, + java.lang.String end, + T... values) +
      Appends a list of values to the description.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseDescription

        +
        public BaseDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        @SafeVarargs
        +public final <T> Description appendValueList(java.lang.String start,
        +                                                          java.lang.String separator,
        +                                                          java.lang.String end,
        +                                                          T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Append the String str to the description. + The default implementation passes every character to append(char). + Override in subclasses to provide an efficient implementation.
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected abstract void append(char c)
        +
        Append the char c to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/BaseMatcher.html b/docs/javadoc/2.2/org/hamcrest/BaseMatcher.html new file mode 100644 index 000000000..eac324034 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/BaseMatcher.html @@ -0,0 +1,383 @@ + + + + + +BaseMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class BaseMatcher<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.BaseMatcher<T>
    • +
    +
  • +
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseMatcher

        +
        public BaseMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      + + + +
        +
      • +

        isNotNull

        +
        protected static boolean isNotNull(java.lang.Object actual,
        +                                   Description mismatch)
        +
        Useful null-check method. Writes a mismatch description if the actual object is null
        +
        +
        Parameters:
        +
        actual - the object to check
        +
        mismatch - where to write the mismatch description, if any
        +
        Returns:
        +
        false iff the actual object is null
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Condition.Step.html b/docs/javadoc/2.2/org/hamcrest/Condition.Step.html new file mode 100644 index 000000000..c884be2fc --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Condition.Step.html @@ -0,0 +1,227 @@ + + + + + +Condition.Step (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Condition.Step<I,O>

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    Condition<T>
    +
    +
    +
    +
    public static interface Condition.Step<I,O>
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Condition.html b/docs/javadoc/2.2/org/hamcrest/Condition.html new file mode 100644 index 000000000..6c2374cda --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Condition.html @@ -0,0 +1,367 @@ + + + + + +Condition (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Condition<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Condition<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public abstract class Condition<T>
    +extends java.lang.Object
    +
    A Condition implements part of a multi-step match. We sometimes need to write matchers + that have a sequence of steps, where each step depends on the result of the previous + step and we can stop processing as soon as a step fails. These classes provide + infrastructure for writing such a sequence. + + Based on https://github.com/npryce/maybe-java
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NOT_MATCHED

        +
        public static final org.hamcrest.Condition.NotMatched<java.lang.Object> NOT_MATCHED
        +
      • +
      +
    • +
    + + +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/CoreMatchers.html b/docs/javadoc/2.2/org/hamcrest/CoreMatchers.html new file mode 100644 index 000000000..b6159332e --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/CoreMatchers.html @@ -0,0 +1,1077 @@ + + + + + +CoreMatchers (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CoreMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.CoreMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class CoreMatchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      CoreMatchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static Matcher<java.lang.Object>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>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>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>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>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>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<T> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>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>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CoreMatchers

        +
        public CoreMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<T> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/CustomMatcher.html b/docs/javadoc/2.2/org/hamcrest/CustomMatcher.html new file mode 100644 index 000000000..43d4f6a8e --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/CustomMatcher.html @@ -0,0 +1,324 @@ + + + + + +CustomMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched.
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomMatcher<T>
    +extends BaseMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomMatcher<String>("a non empty string") {
    +   public boolean matches(Object object) {
    +     return ((object instanceof String) && !((String) object).isEmpty();
    +   }
    + };
    + 
    +

    + This class is designed for scenarios where an anonymous inner class + matcher makes sense. It should not be used by API designers implementing + matchers.

    +
    +
    See Also:
    +
    for a type safe variant of this class that you probably + want to use.
    +
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomMatcher

        +
        public CustomMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/CustomTypeSafeMatcher.html b/docs/javadoc/2.2/org/hamcrest/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..d1bf56892 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/CustomTypeSafeMatcher.html @@ -0,0 +1,327 @@ + + + + + +CustomTypeSafeMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class CustomTypeSafeMatcher<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - The type of object being matched
    +
    +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public abstract class CustomTypeSafeMatcher<T>
    +extends TypeSafeMatcher<T>
    +
    Utility class for writing one off matchers. + For example: +
    + Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
    +   public boolean matchesSafely(String string) {
    +     return !string.isEmpty();
    +   }
    +   public void describeMismatchSafely(String string, Description mismatchDescription) {
    +     mismatchDescription.appendText("was empty");
    +   }
    + };
    + 
    + This is a variant of CustomMatcher that first type checks + the argument being matched. By the time TypeSafeMatcher.matchesSafely(T) is + is called the argument is guaranteed to be non-null and of the correct + type.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CustomTypeSafeMatcher

        +
        public CustomTypeSafeMatcher(java.lang.String description)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Description.NullDescription.html b/docs/javadoc/2.2/org/hamcrest/Description.NullDescription.html new file mode 100644 index 000000000..339012fe3 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Description.NullDescription.html @@ -0,0 +1,460 @@ + + + + + +Description.NullDescription (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Description.NullDescription

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Description.NullDescription
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Description
    +
    +
    +
    Enclosing interface:
    +
    Description
    +
    +
    +
    +
    public static final class Description.NullDescription
    +extends java.lang.Object
    +implements Description
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullDescription

        +
        public NullDescription()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        appendList

        +
        public Description appendList(java.lang.String start,
        +                              java.lang.String separator,
        +                              java.lang.String end,
        +                              java.lang.Iterable<? extends SelfDescribing> values)
        +
        Description copied from interface: Description
        +
        Appends a list of SelfDescribing objects + to the description.
        +
        +
        Specified by:
        +
        appendList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendText

        +
        public Description appendText(java.lang.String text)
        +
        Description copied from interface: Description
        +
        Appends some plain text to the description.
        +
        +
        Specified by:
        +
        appendText in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValue

        +
        public Description appendValue(java.lang.Object value)
        +
        Description copied from interface: Description
        +
        Appends an arbitrary value to the description.
        +
        +
        Specified by:
        +
        appendValue in interface Description
        +
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       T... values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        public <T> Description appendValueList(java.lang.String start,
        +                                       java.lang.String separator,
        +                                       java.lang.String end,
        +                                       java.lang.Iterable<T> values)
        +
        Description copied from interface: Description
        +
        Appends a list of values to the description.
        +
        +
        Specified by:
        +
        appendValueList in interface Description
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Description.html b/docs/javadoc/2.2/org/hamcrest/Description.html new file mode 100644 index 000000000..936fda374 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Description.html @@ -0,0 +1,392 @@ + + + + + +Description (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Description

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NONE

        +
        static final Description NONE
        +
        A description that consumes input but does nothing.
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        appendText

        +
        Description appendText(java.lang.String text)
        +
        Appends some plain text to the description.
        +
      • +
      + + + + + + + +
        +
      • +

        appendValue

        +
        Description appendValue(java.lang.Object value)
        +
        Appends an arbitrary value to the description.
        +
      • +
      + + + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                T... values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendValueList

        +
        <T> Description appendValueList(java.lang.String start,
        +                                java.lang.String separator,
        +                                java.lang.String end,
        +                                java.lang.Iterable<T> values)
        +
        Appends a list of values to the description.
        +
      • +
      + + + +
        +
      • +

        appendList

        +
        Description appendList(java.lang.String start,
        +                       java.lang.String separator,
        +                       java.lang.String end,
        +                       java.lang.Iterable<? extends SelfDescribing> values)
        +
        Appends a list of SelfDescribing objects + to the description.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/DiagnosingMatcher.html b/docs/javadoc/2.2/org/hamcrest/DiagnosingMatcher.html new file mode 100644 index 000000000..7b7d49367 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/DiagnosingMatcher.html @@ -0,0 +1,365 @@ + + + + + +DiagnosingMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class DiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DiagnosingMatcher

        +
        public DiagnosingMatcher()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected abstract boolean matches(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/FeatureMatcher.html b/docs/javadoc/2.2/org/hamcrest/FeatureMatcher.html new file mode 100644 index 000000000..9bb56e774 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/FeatureMatcher.html @@ -0,0 +1,381 @@ + + + + + +FeatureMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class FeatureMatcher<T,U>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FeatureMatcher

        +
        public FeatureMatcher(Matcher<? super U> subMatcher,
        +                      java.lang.String featureDescription,
        +                      java.lang.String featureName)
        +
        Constructor
        +
        +
        Parameters:
        +
        subMatcher - The matcher to apply to the feature
        +
        featureDescription - Descriptive text to use in describeTo
        +
        featureName - Identifying text for mismatch message
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected abstract U featureValueOf(T actual)
        +
        Implement this to extract the interesting feature.
        +
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public final void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Matcher.html b/docs/javadoc/2.2/org/hamcrest/Matcher.html new file mode 100644 index 000000000..0881999c8 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Matcher.html @@ -0,0 +1,328 @@ + + + + + +Matcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface Matcher<T>

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        boolean matches(java.lang.Object actual)
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        actual - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        void describeMismatch(java.lang.Object actual,
        +                      Description mismatchDescription)
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Parameters:
        +
        actual - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        _dont_implement_Matcher___instead_extend_BaseMatcher_

        +
        @Deprecated
        +void _dont_implement_Matcher___instead_extend_BaseMatcher_()
        +
        Deprecated. to make
        +
        This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors .
        +
        +
        See Also:
        +
        for reasons why., +BaseMatcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/MatcherAssert.html b/docs/javadoc/2.2/org/hamcrest/MatcherAssert.html new file mode 100644 index 000000000..d286f3f83 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/MatcherAssert.html @@ -0,0 +1,307 @@ + + + + + +MatcherAssert (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class MatcherAssert

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.MatcherAssert
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class MatcherAssert
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      MatcherAssert() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static voidassertThat(java.lang.String reason, + boolean assertion) 
      static <T> voidassertThat(java.lang.String reason, + T actual, + Matcher<? super T> matcher) 
      static <T> voidassertThat(T actual, + Matcher<? super T> matcher) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatcherAssert

        +
        public MatcherAssert()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + + + +
        +
      • +

        assertThat

        +
        public static <T> void assertThat(java.lang.String reason,
        +                                  T actual,
        +                                  Matcher<? super T> matcher)
        +
      • +
      + + + +
        +
      • +

        assertThat

        +
        public static void assertThat(java.lang.String reason,
        +                              boolean assertion)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/Matchers.html b/docs/javadoc/2.2/org/hamcrest/Matchers.html new file mode 100644 index 000000000..456099239 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/Matchers.html @@ -0,0 +1,3426 @@ + + + + + +Matchers (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class Matchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.Matchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class Matchers
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Matchers() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<T>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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      +
      static <T> Matcher<T>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(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(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(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(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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(int size) +
      Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>anEmptyMap() +
      Creates a matcher for Maps that matches when the size() method returns + zero.
      +
      static <T> Matcher<T>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(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(Matcher<? super T>... matchers) +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      +
      static <T> AnyOf<T>anyOf(Matcher<? super 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(Matcher<? super 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(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 ANY of the specified matchers.
      +
      static <T> AnyOf<T>anyOf(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 ANY of the specified matchers.
      +
      static <T> AnyOf<T>anyOf(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 ANY of the specified matchers.
      +
      static Matcher<java.lang.Object>anything() +
      Creates a matcher that always matches, regardless of the examined object.
      +
      static Matcher<java.lang.Object>anything(java.lang.String description) +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      static <T> IsArray<T>array(Matcher<? super T>... elementMatchers) +
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
      +
      static <E> Matcher<E[]>arrayContaining(E... items) +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
      +
      static <E> Matcher<E[]>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[]>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[]>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[]>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[]>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[]>arrayWithSize(int size) +
      Creates a matcher for arrays that matches when the length of the array + equals the specified size.
      +
      static <E> Matcher<E[]>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 Matcher<java.lang.String>blankOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
      +
      static Matcher<java.lang.String>blankString() +
      Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
      +
      static <LHS> CombinableMatcher.CombinableBothMatcher<LHS>both(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when both of the specified matchers match the examined object.
      +
      static Matcher<java.math.BigDecimal>closeTo(java.math.BigDecimal operand, + java.math.BigDecimal error) +
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
      +
      static Matcher<java.lang.Double>closeTo(double operand, + double error) +
      Creates a matcher of Doubles 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>
      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 <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables 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>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      static Matcher<java.lang.String>containsString(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere.
      +
      static Matcher<java.lang.String>containsStringIgnoringCase(java.lang.String substring) +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
      +
      static <T> Matcher<T>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>either(Matcher<? super LHS> matcher) +
      Creates a matcher that matches when either of the specified matchers match the examined object.
      +
      static <E> Matcher<java.util.Collection<? extends E>>empty() +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<E[]>emptyArray() +
      Creates a matcher for arrays that matches when the length of the array + is zero.
      +
      static <E> Matcher<java.util.Collection<E>>emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>emptyIterable() +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static <E> Matcher<java.lang.Iterable<E>>emptyIterableOf(java.lang.Class<E> unusedToForceReturnType) +
      Creates a matcher for Iterables matching examined iterables that yield no items.
      +
      static Matcher<java.lang.String>emptyOrNullString() +
      Creates a matcher of String that matches when the examined string is null, or + has zero length.
      +
      static Matcher<java.lang.String>emptyString() +
      Creates a matcher of String that matches when the examined string has zero length.
      +
      static Matcher<java.lang.String>endsWith(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String.
      +
      static Matcher<java.lang.String>endsWithIgnoringCase(java.lang.String suffix) +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
      +
      static <T> Matcher<T>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 Matcher<java.lang.String>equalToCompressingWhiteSpace(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>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>equalToIgnoringWhiteSpace(java.lang.String expectedString) + +
      static Matcher<java.lang.Object>equalToObject(java.lang.Object operand) +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      static Matcher<java.util.EventObject>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>eventFrom(java.lang.Object source) +
      Creates a matcher of EventObject that matches any EventObject + announced by source.
      +
      static <U> Matcher<java.lang.Iterable<? extends U>>everyItem(Matcher<U> itemMatcher) +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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 <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps 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<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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<T[]>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[]>hasItemInArray(T element) +
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      +
      static <T> Matcher<java.lang.Iterable<T>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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 <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static Matcher<java.lang.CharSequence>hasLength(int length) +
      Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
      +
      static <T> Matcher<T>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>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 <E> Matcher<java.util.Collection<? extends E>>hasSize(int size) +
      Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
      +
      static <E> Matcher<java.util.Collection<? extends E>>hasSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
      +
      static <T> Matcher<T>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(java.lang.String expectedToString) +
      Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>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(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<?> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      static Matcher<java.lang.String>isEmptyOrNullString() +
      Deprecated.  +
      use is(emptyOrNullString()) instead
      +
      +
      static Matcher<java.lang.String>isEmptyString() +
      Deprecated.  +
      use is(emptyString()) instead
      +
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      static <E> Matcher<java.lang.Iterable<E>>iterableWithSize(int size) +
      Creates a matcher for Iterables 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>>iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
      +
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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.
      +
      static Matcher<java.lang.String>matchesPattern(java.util.regex.Pattern pattern) +
      Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
      +
      static Matcher<java.lang.String>matchesPattern(java.lang.String regex) +
      Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
      +
      static Matcher<java.lang.String>matchesRegex(java.util.regex.Pattern pattern) +
      Validate a string with a Pattern.
      +
      static Matcher<java.lang.String>matchesRegex(java.lang.String regex) +
      Validate a string with a regex.
      +
      static <T> Matcher<T>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>not(T value) +
      A shortcut to the frequently used not(equalTo(x)).
      +
      static Matcher<java.lang.Double>notANumber() +
      Creates a matcher of Doubles that matches when an examined double is not a number.
      +
      static Matcher<java.lang.Object>notNullValue() +
      A shortcut to the frequently used not(nullValue()).
      +
      static <T> Matcher<T>notNullValue(java.lang.Class<T> type) +
      A shortcut to the frequently used not(nullValue(X.class)).
      +
      static Matcher<java.lang.Object>nullValue() +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>nullValue(java.lang.Class<T> type) +
      Creates a matcher that matches if examined object is null.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      static <T> Matcher<T>sameInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <B> Matcher<B>samePropertyValuesAs(B expectedBean, + java.lang.String... ignoredProperties) +
      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.
      +
      static Matcher<java.lang.String>startsWith(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String.
      +
      static Matcher<java.lang.String>startsWithIgnoringCase(java.lang.String prefix) +
      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
      +
      static Matcher<java.lang.String>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, considering the order of their appearance.
      +
      static Matcher<java.lang.String>stringContainsInOrder(java.lang.String... substrings) +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
      +
      static <T> Matcher<T>theInstance(T target) +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      static <T> Matcher<java.lang.Class<?>>typeCompatibleWith(java.lang.Class<T> baseType) +
      Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Matchers

        +
        public Matchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(Matcher<? super T> first,
        +                                   Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(Matcher<? super T> first,
        +                                 Matcher<? super T> second)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(Matcher<? super 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. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenized description
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<?> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWithIgnoringCase("My"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWithIgnoringCase("note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.util.regex.Pattern pattern)
        +
        Validate a string with a Pattern. + +
        + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
        + 
        +
        +
        Parameters:
        +
        pattern - the pattern to be used.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.lang.String regex)
        +
        Validate a string with a regex. + +
        + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
        + 
        +
        +
        Parameters:
        +
        regex - The regex to be used for the validation.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        array

        +
        @SafeVarargs
        +public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString)
        + +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToCompressingWhiteSpace

        +
        public static Matcher<java.lang.String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(int length)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument. + For example: + +
        + assertThat("text", length(4))
        + 
        +
        +
        Parameters:
        +
        length - the expected length of the string
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <B> Matcher<B> samePropertyValuesAs(B expectedBean,
        +                                                  java.lang.String... ignoredProperties)
        +
        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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example
        age
        rather than method names such as
        getAge
        . + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        ignoredProperties - do not check any of these named properties.
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/SelfDescribing.html b/docs/javadoc/2.2/org/hamcrest/SelfDescribing.html new file mode 100644 index 000000000..de6fc4bbf --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/SelfDescribing.html @@ -0,0 +1,237 @@ + + + + + +SelfDescribing (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Interface SelfDescribing

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        void describeTo(Description description)
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/StringDescription.html b/docs/javadoc/2.2/org/hamcrest/StringDescription.html new file mode 100644 index 000000000..ff55925e6 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/StringDescription.html @@ -0,0 +1,417 @@ + + + + + +StringDescription (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class StringDescription

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription()
        +
      • +
      + + + +
        +
      • +

        StringDescription

        +
        public StringDescription(java.lang.Appendable out)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        toString

        +
        public static java.lang.String toString(SelfDescribing selfDescribing)
        +
        Return the description of a SelfDescribing object as a String.
        +
        +
        Parameters:
        +
        selfDescribing - The object to be described.
        +
        Returns:
        +
        The description of the object.
        +
        +
      • +
      + + + + + + + +
        +
      • +

        append

        +
        protected void append(java.lang.String str)
        +
        Description copied from class: BaseDescription
        +
        Append the String str to the description. + The default implementation passes every character to BaseDescription.append(char). + Override in subclasses to provide an efficient implementation.
        +
        +
        Overrides:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        append

        +
        protected void append(char c)
        +
        Description copied from class: BaseDescription
        +
        Append the char c to the description.
        +
        +
        Specified by:
        +
        append in class BaseDescription
        +
        +
      • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        Returns the description as a string.
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/TypeSafeDiagnosingMatcher.html b/docs/javadoc/2.2/org/hamcrest/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..74b65e794 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,423 @@ + + + + + +TypeSafeDiagnosingMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeDiagnosingMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeDiagnosingMatcher

        +
        protected TypeSafeDiagnosingMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item,
        +                                         Description mismatchDescription)
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/TypeSafeMatcher.html b/docs/javadoc/2.2/org/hamcrest/TypeSafeMatcher.html new file mode 100644 index 000000000..c75ea7136 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/TypeSafeMatcher.html @@ -0,0 +1,432 @@ + + + + + +TypeSafeMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest
+

Class TypeSafeMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher()
        +
        The default constructor for simple sub types
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(java.lang.Class<?> expectedType)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        expectedType - The expectedType of the actual value.
        +
        +
      • +
      + + + +
        +
      • +

        TypeSafeMatcher

        +
        protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder)
        +
        Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
        +
        +
        Parameters:
        +
        typeFinder - A type finder to extract the type
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        protected abstract boolean matchesSafely(T item)
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        protected void describeMismatchSafely(T item,
        +                                      Description mismatchDescription)
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
      • +
      + + + +
        +
      • +

        matches

        +
        public final boolean matches(java.lang.Object item)
        +
        Methods made final to prevent accidental override. + If you need to override this, there's no point on extending TypeSafeMatcher. + Instead, extend the BaseMatcher.
        +
        +
        Parameters:
        +
        item - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public final void describeMismatch(java.lang.Object item,
        +                                   Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/HasProperty.html b/docs/javadoc/2.2/org/hamcrest/beans/HasProperty.html new file mode 100644 index 000000000..79d745686 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/HasProperty.html @@ -0,0 +1,384 @@ + + + + + +HasProperty (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasProperty<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasProperty<T>
    +extends TypeSafeMatcher<T>
    +
    A Matcher that checks that an object has a JavaBean property + with the specified name. If an error occurs during introspection + of the object then this is treated as a mismatch.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasProperty

        +
        public HasProperty(java.lang.String propertyName)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T obj)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> hasProperty(java.lang.String propertyName)
        +
        Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
        assertThat(myBean, hasProperty("foo"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/HasPropertyWithValue.html b/docs/javadoc/2.2/org/hamcrest/beans/HasPropertyWithValue.html new file mode 100644 index 000000000..bcbd35284 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/HasPropertyWithValue.html @@ -0,0 +1,455 @@ + + + + + +HasPropertyWithValue (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class HasPropertyWithValue<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class HasPropertyWithValue<T>
    +extends TypeSafeDiagnosingMatcher<T>
    +

    Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher. This is useful for when objects + are created within code under test and passed to a mock object, and you wish + to assert that the created object has certain properties. +

    + +

    Example Usage

    + Consider the situation where we have a class representing a person, which + follows the basic JavaBean convention of having get() and possibly set() + methods for it's properties: +
    + public class Person {
    +   private String name;
    +   public Person(String person) {
    +     this.person = person;
    +   }
    +   public String getName() {
    +     return name;
    +   }
    + }
    + + And that these person objects are generated within a piece of code under test + (a class named PersonGenerator). This object is sent to one of our mock objects + which overrides the PersonGenerationListener interface: +
    + public interface PersonGenerationListener {
    +   public void personGenerated(Person person);
    + }
    + + In order to check that the code under test generates a person with name + "Iain" we would do the following: +
    + Mock personGenListenerMock = mock(PersonGenerationListener.class);
    + personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
    + PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy();
    + +

    If an exception is thrown by the getter method for a property, the property + does not exist, is not readable, or a reflection related exception is thrown + when trying to invoke it then this is treated as an evaluation failure and + the matches method will return false. +

    +

    This matcher class will also work with JavaBean objects that have explicit + bean descriptions via an associated BeanInfo description class. See the + JavaBeans specification for more information: + http://java.sun.com/products/javabeans/docs/index.html +

    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasPropertyWithValue

        +
        public HasPropertyWithValue(java.lang.String propertyName,
        +                            Matcher<?> valueMatcher)
        +
      • +
      + + + +
        +
      • +

        HasPropertyWithValue

        +
        public HasPropertyWithValue(java.lang.String propertyName,
        +                            Matcher<?> valueMatcher,
        +                            java.lang.String messageFormat)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasProperty

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        +
        +
        Parameters:
        +
        propertyName - the name of the JavaBean property that examined beans should possess
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      + + + +
        +
      • +

        hasPropertyAtPath

        +
        public static <T> Matcher<T> hasPropertyAtPath(java.lang.String path,
        +                                               Matcher<T> valueMatcher)
        +
        Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher. + For example: +
        assertThat(myBean, hasProperty("foo.bar.baz", equalTo("a property value"))
        +
        +
        Parameters:
        +
        path - the dot-separated path from the examined object to the JavaBean property
        +
        valueMatcher - a matcher for the value of the specified property of the examined bean
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/PropertyUtil.html b/docs/javadoc/2.2/org/hamcrest/beans/PropertyUtil.html new file mode 100644 index 000000000..2e7016687 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/PropertyUtil.html @@ -0,0 +1,354 @@ + + + + + +PropertyUtil (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class PropertyUtil

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.beans.PropertyUtil
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class PropertyUtil
    +extends java.lang.Object
    +
    Utility class for accessing properties on JavaBean objects. + See http://java.sun.com/products/javabeans/docs/index.html for + more information on JavaBeans.
    +
    +
    Since:
    +
    1.1.0
    +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static java.lang.Object[]NO_ARGUMENTS 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      PropertyUtil() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static java.beans.PropertyDescriptorgetPropertyDescriptor(java.lang.String propertyName, + java.lang.Object fromObj) +
      Returns the description of the property with the provided + name on the provided object's interface.
      +
      static java.beans.PropertyDescriptor[]propertyDescriptorsFor(java.lang.Object fromObj, + java.lang.Class<java.lang.Object> stopClass) +
      Returns all the property descriptors for the class associated with the given object
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_ARGUMENTS

        +
        public static final java.lang.Object[] NO_ARGUMENTS
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        PropertyUtil

        +
        public PropertyUtil()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getPropertyDescriptor

        +
        public static java.beans.PropertyDescriptor getPropertyDescriptor(java.lang.String propertyName,
        +                                                                  java.lang.Object fromObj)
        +                                                           throws java.lang.IllegalArgumentException
        +
        Returns the description of the property with the provided + name on the provided object's interface.
        +
        +
        Returns:
        +
        the descriptor of the property, or null if the property does not exist.
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      + + + +
        +
      • +

        propertyDescriptorsFor

        +
        public static java.beans.PropertyDescriptor[] propertyDescriptorsFor(java.lang.Object fromObj,
        +                                                                     java.lang.Class<java.lang.Object> stopClass)
        +                                                              throws java.lang.IllegalArgumentException
        +
        Returns all the property descriptors for the class associated with the given object
        +
        +
        Parameters:
        +
        fromObj - Use the class of this object
        +
        stopClass - Don't include any properties from this ancestor class upwards.
        +
        Returns:
        +
        Property descriptors
        +
        Throws:
        +
        java.lang.IllegalArgumentException - if there's a introspection failure
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/SamePropertyValuesAs.html b/docs/javadoc/2.2/org/hamcrest/beans/SamePropertyValuesAs.html new file mode 100644 index 000000000..61d5499c1 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/SamePropertyValuesAs.html @@ -0,0 +1,364 @@ + + + + + +SamePropertyValuesAs (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.beans
+

Class SamePropertyValuesAs<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SamePropertyValuesAs

        +
        public SamePropertyValuesAs(T expectedBean,
        +                            java.util.List<java.lang.String> ignoredProperties)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        samePropertyValuesAs

        +
        public static <B> Matcher<B> samePropertyValuesAs(B expectedBean,
        +                                                  java.lang.String... ignoredProperties)
        +
        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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example
        age
        rather than method names such as
        getAge
        . + For example: +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        +
        assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
        +
        +
        Parameters:
        +
        expectedBean - the bean against which examined beans are compared
        +
        ignoredProperties - do not check any of these named properties.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/package-frame.html b/docs/javadoc/2.2/org/hamcrest/beans/package-frame.html new file mode 100644 index 000000000..01d8c5601 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.beans (Hamcrest 2.2 API) + + + + + +

org.hamcrest.beans

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/package-summary.html b/docs/javadoc/2.2/org/hamcrest/beans/package-summary.html new file mode 100644 index 000000000..9db078a5c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/package-summary.html @@ -0,0 +1,169 @@ + + + + + +org.hamcrest.beans (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.beans

+
+
Matchers of Java Bean properties and their values.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasProperty<T> +
    A Matcher that checks that an object has a JavaBean property + with the specified name.
    +
    HasPropertyWithValue<T> +
    Matcher that asserts that a JavaBean property on an argument passed to the + mock object meets the provided matcher.
    +
    PropertyUtil +
    Utility class for accessing properties on JavaBean objects.
    +
    SamePropertyValuesAs<T> 
    +
  • +
+ + + +

Package org.hamcrest.beans Description

+

Matchers of Java Bean properties and their values.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/beans/package-tree.html b/docs/javadoc/2.2/org/hamcrest/beans/package-tree.html new file mode 100644 index 000000000..4717c8019 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/beans/package-tree.html @@ -0,0 +1,154 @@ + + + + + +org.hamcrest.beans Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.beans

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/ArrayAsIterableMatcher.html b/docs/javadoc/2.2/org/hamcrest/collection/ArrayAsIterableMatcher.html new file mode 100644 index 000000000..fcb49e632 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/ArrayAsIterableMatcher.html @@ -0,0 +1,410 @@ + + + + + +ArrayAsIterableMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class ArrayAsIterableMatcher<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + + + + + +
        +
      • +

        matchers

        +
        protected final java.util.Collection<Matcher<? super E>> matchers
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayAsIterableMatcher

        +
        public ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>> iterableMatcher,
        +                              java.util.Collection<Matcher<? super E>> matchers,
        +                              java.lang.String message)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/ArrayMatching.html b/docs/javadoc/2.2/org/hamcrest/collection/ArrayMatching.html new file mode 100644 index 000000000..b5c6b1eb5 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/ArrayMatching.html @@ -0,0 +1,510 @@ + + + + + +ArrayMatching (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class ArrayMatching

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.collection.ArrayMatching
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class ArrayMatching
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ArrayMatching() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<E[]>arrayContaining(E... items) +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
      +
      static <E> Matcher<E[]>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[]>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[]>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[]>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[]>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> java.util.List<Matcher<? super E>>asEqualMatchers(E[] items) 
      static <T> Matcher<T[]>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[]>hasItemInArray(T element) +
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayMatching

        +
        public ArrayMatching()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
        assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
        +
        +
        Parameters:
        +
        elementMatcher - the matcher to apply to elements in examined arrays
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItemInArray

        +
        public static <T> Matcher<T[]> hasItemInArray(T element)
        +
        A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
        assertThat(hasItemInArray(x))
        + instead of: +
        assertThat(hasItemInArray(equalTo(x)))
        +
        +
        Parameters:
        +
        element - the element that should be present in examined arrays
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        +

        N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        +

        + For example: +

        +
        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        @SafeVarargs
        +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        asEqualMatchers

        +
        public static <E> java.util.List<Matcher<? super E>> asEqualMatchers(E[] items)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/HasItemInArray.html b/docs/javadoc/2.2/org/hamcrest/collection/HasItemInArray.html new file mode 100644 index 000000000..f2d0e3663 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/HasItemInArray.html @@ -0,0 +1,358 @@ + + + + + +HasItemInArray (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class HasItemInArray<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class HasItemInArray<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matches if an array contains an item satisfying a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasItemInArray

        +
        public HasItemInArray(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] actual)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] actual,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsArray.html b/docs/javadoc/2.2/org/hamcrest/collection/IsArray.html new file mode 100644 index 000000000..34c7d99fd --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsArray.html @@ -0,0 +1,440 @@ + + + + + +IsArray (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArray<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArray<T>
    +extends TypeSafeMatcher<T[]>
    +
    Matcher for array whose elements satisfy a sequence of matchers. + The array size must equal the number of element matchers.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArray

        +
        public IsArray(Matcher<? super T>[] elementMatchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(T[] array)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(T[] actual,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<T[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        descriptionStart

        +
        protected java.lang.String descriptionStart()
        +
        Returns the string that starts the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionSeparator

        +
        protected java.lang.String descriptionSeparator()
        +
        Returns the string that separates the elements in the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        descriptionEnd

        +
        protected java.lang.String descriptionEnd()
        +
        Returns the string that ends the description. + + Can be overridden in subclasses to customise how the matcher is + described.
        +
      • +
      + + + +
        +
      • +

        array

        +
        public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
        +
        Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
        assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
        +
        +
        Parameters:
        +
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInAnyOrder.html b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..8e1823b32 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInAnyOrder.html @@ -0,0 +1,471 @@ + + + + + +IsArrayContainingInAnyOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInAnyOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInAnyOrder

        +
        public IsArrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> matchers)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Matcher[]).
        +
        Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Collection).
        +
        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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContainingInAnyOrder

        +
        public static <E> Matcher<E[]> arrayContainingInAnyOrder(E... items)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContainingInAnyOrder(Object[]).
        +
        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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the entries of an examined array, in any order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInOrder.html b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInOrder.html new file mode 100644 index 000000000..92da3cafe --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayContainingInOrder.html @@ -0,0 +1,455 @@ + + + + + +IsArrayContainingInOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayContainingInOrder<E>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayContainingInOrder

        +
        public IsArrayContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(E[] item)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(E[] item,
        +                                   Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<E[]>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(E... items)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(Object[]).
        +
        Creates a matcher for arrays that matcheswhen each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items within an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(Matcher[]).
        +
        Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers. For a positive match, the examined array + must be of the same length as the number of specified matchers. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayContaining

        +
        public static <E> Matcher<E[]> arrayContaining(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Deprecated. As of version 2.1, use ArrayMatching.arrayContaining(List).
        +
        Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers. For a positive match, the examined array + must be of the same length as the specified list of matchers. +

        + For example: +

        assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsArrayWithSize.html b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayWithSize.html new file mode 100644 index 000000000..21176fc98 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsArrayWithSize.html @@ -0,0 +1,392 @@ + + + + + +IsArrayWithSize (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsArrayWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<E[]>, SelfDescribing
    +
    +
    +
    +
    public class IsArrayWithSize<E>
    +extends FeatureMatcher<E[],java.lang.Integer>
    +
    Matches if array size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsArrayWithSize

        +
        public IsArrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(E[] actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<E[],java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the length of an examined array
        +
        +
      • +
      + + + +
        +
      • +

        arrayWithSize

        +
        public static <E> Matcher<E[]> arrayWithSize(int size)
        +
        Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
        assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
        +
        +
        Parameters:
        +
        size - the length that an examined array must have for a positive match
        +
        +
      • +
      + + + +
        +
      • +

        emptyArray

        +
        public static <E> Matcher<E[]> emptyArray()
        +
        Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
        assertThat(new String[0], emptyArray())
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsCollectionWithSize.html b/docs/javadoc/2.2/org/hamcrest/collection/IsCollectionWithSize.html new file mode 100644 index 000000000..02b35da5c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsCollectionWithSize.html @@ -0,0 +1,370 @@ + + + + + +IsCollectionWithSize (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsCollectionWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsCollectionWithSize<E>
    +extends FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
    +
    Matches if collection size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionWithSize

        +
        public IsCollectionWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Collection<? extends E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Collection<? extends E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Collection
        +
        +
      • +
      + + + +
        +
      • +

        hasSize

        +
        public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
        +
        Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasSize(2))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Collection
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyCollection.html b/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyCollection.html new file mode 100644 index 000000000..65c45a784 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyCollection.html @@ -0,0 +1,398 @@ + + + + + +IsEmptyCollection (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyCollection<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Collection<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyCollection<E>
    +extends TypeSafeMatcher<java.util.Collection<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyCollection

        +
        public IsEmptyCollection()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Collection<? extends E> item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Collection<? extends E> item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Collection<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        empty

        +
        public static <E> Matcher<java.util.Collection<? extends E>> empty()
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(empty()))
        +
      • +
      + + + +
        +
      • +

        emptyCollectionOf

        +
        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
        assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the collection's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyIterable.html b/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyIterable.html new file mode 100644 index 000000000..245e5e367 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsEmptyIterable.html @@ -0,0 +1,394 @@ + + + + + +IsEmptyIterable (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsEmptyIterable<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<? extends E>>, SelfDescribing
    +
    +
    +
    +
    public class IsEmptyIterable<E>
    +extends TypeSafeMatcher<java.lang.Iterable<? extends E>>
    +
    Tests if collection is empty.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEmptyIterable

        +
        public IsEmptyIterable()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends E> iterable)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Iterable<? extends E> iter,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        emptyIterable

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterable()))
        +
      • +
      + + + +
        +
      • +

        emptyIterableOf

        +
        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
        +
        Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
        assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
        +
        +
        Parameters:
        +
        unusedToForceReturnType - the type of the iterable's content
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsIn.html b/docs/javadoc/2.2/org/hamcrest/collection/IsIn.html new file mode 100644 index 000000000..0244faaf8 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsIn.html @@ -0,0 +1,502 @@ + + + + + +IsIn (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIn<T>

+
+
+ +
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      IsIn(java.util.Collection<T> collection) 
      IsIn(T[] elements) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description buffer) +
      Generates a description of the object.
      +
      static <T> Matcher<T>in(java.util.Collection<T> collection) +
      Creates a matcher that matches when the examined object is found within the + specified collection.
      +
      static <T> Matcher<T>in(T[] elements) +
      Creates a matcher that matches when the examined object is found within the + specified array.
      +
      static <T> Matcher<T>isIn(java.util.Collection<T> collection) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isIn(T[] elements) +
      Deprecated.  +
      use is(in(...)) instead
      +
      +
      static <T> Matcher<T>isOneOf(T... elements) +
      Deprecated.  +
      use is(oneOf(...)) instead
      +
      +
      booleanmatches(java.lang.Object o) +
      Evaluates the matcher for argument item.
      +
      static <T> Matcher<T>oneOf(T... elements) +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIn

        +
        public IsIn(java.util.Collection<T> collection)
        +
      • +
      + + + + + +
        +
      • +

        IsIn

        +
        public IsIn(T[] elements)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description buffer)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        buffer - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", isIn(Arrays.asList("bar", "foo")))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(java.util.Collection<T> collection)
        +
        Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        +
        +
        Parameters:
        +
        collection - the collection in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isIn

        +
        @Deprecated
        +public static <T> Matcher<T> isIn(T[] elements)
        +
        Deprecated. use is(in(...)) instead
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        in

        +
        public static <T> Matcher<T> in(T[] elements)
        +
        Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        +
        +
        Parameters:
        +
        elements - the array in which matching items must be found
        +
        +
      • +
      + + + + + +
        +
      • +

        isOneOf

        +
        @SafeVarargs
        + @Deprecated
        +public static <T> Matcher<T> isOneOf(T... elements)
        +
        Deprecated. use is(oneOf(...)) instead
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", isOneOf("bar", "foo"))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      + + + + + +
        +
      • +

        oneOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> oneOf(T... elements)
        +
        Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
        assertThat("foo", is(oneOf("bar", "foo")))
        +
        +
        Parameters:
        +
        elements - the elements amongst which matching items will be found
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInAnyOrder.html b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..685fe9463 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInAnyOrder.html @@ -0,0 +1,444 @@ + + + + + +IsIterableContainingInAnyOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInAnyOrder<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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 <T> Matcher<java.lang.Iterable<? extends T>>containsInAnyOrder(Matcher<? super T>... itemMatchers) +
      + Creates an order agnostic matcher for Iterables 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>>containsInAnyOrder(T... items) +
      + Creates an order agnostic matcher for Iterables 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.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends T> items, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInAnyOrder

        +
        public IsIterableContainingInAnyOrder(java.util.Collection<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends T> items,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

        +

        + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInAnyOrder

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

        +

        + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

        +

        + For example: +

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable in any order
        +
        +
      • +
      + + + +
        +
      • +

        containsInAnyOrder

        +
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
        +

        + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

        +

        + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

        +

        For example:

        +
        assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInOrder.html b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInOrder.html new file mode 100644 index 000000000..39197f25d --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInOrder.html @@ -0,0 +1,443 @@ + + + + + +IsIterableContainingInOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>contains(E... items) +
      Creates a matcher for Iterables 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>>contains(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables 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>>contains(Matcher<? super E> itemMatcher) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInOrder

        +
        public IsIterableContainingInOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
        +
        +
        Parameters:
        +
        items - the items that must equal the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
        assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        contains

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
        assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html new file mode 100644 index 000000000..f9d20768d --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html @@ -0,0 +1,415 @@ + + + + + +IsIterableContainingInRelativeOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableContainingInRelativeOrder<E>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(E... items) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
      +
      static <E> Matcher<java.lang.Iterable<? extends E>>containsInRelativeOrder(Matcher<? super E>... itemMatchers) +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? extends E> iterable, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContainingInRelativeOrder

        +
        public IsIterableContainingInRelativeOrder(java.util.List<Matcher<? super E>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? extends E> iterable,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends E>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        +
        +
        Parameters:
        +
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        @SafeVarargs
        +public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        +
        +
      • +
      + + + +
        +
      • +

        containsInRelativeOrder

        +
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        +
        +
        Parameters:
        +
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsIterableWithSize.html b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableWithSize.html new file mode 100644 index 000000000..c2a8bccdb --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsIterableWithSize.html @@ -0,0 +1,373 @@ + + + + + +IsIterableWithSize (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsIterableWithSize<E>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Iterable<E>>, SelfDescribing
    +
    +
    +
    +
    public class IsIterableWithSize<E>
    +extends FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableWithSize

        +
        public IsIterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.lang.Iterable<E> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.lang.Iterable<E>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        iterableWithSize

        +
        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
        +
        Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
        assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
        +
        +
        Parameters:
        +
        size - the number of items that should be yielded by an examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsMapContaining.html b/docs/javadoc/2.2/org/hamcrest/collection/IsMapContaining.html new file mode 100644 index 000000000..1a8bdb73c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsMapContaining.html @@ -0,0 +1,515 @@ + + + + + +IsMapContaining (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapContaining<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public class IsMapContaining<K,V>
    +extends TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatchSafely(java.util.Map<? extends K,? extends V> map, + Description mismatchDescription) +
      Subclasses should override this.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <K,V> Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, + V value) +
      Creates a matcher for Maps 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>>hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
      +
      static <K> Matcher<java.util.Map<? extends K,?>>hasKey(K key) +
      Creates a matcher for Maps 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,?>>hasKey(Matcher<? super K> keyMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(Matcher<? super V> valueMatcher) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
      +
      static <V> Matcher<java.util.Map<?,? extends V>>hasValue(V value) +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
      +
      booleanmatchesSafely(java.util.Map<? extends K,? extends V> map) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapContaining

        +
        public IsMapContaining(Matcher<? super K> keyMatcher,
        +                       Matcher<? super V> valueMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.Map<? extends K,? extends V> map)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.util.Map<? extends K,? extends V> map,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.util.Map<? extends K,? extends V>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher,
        +                                                                             Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
        +
        +
        Parameters:
        +
        keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
        +
        valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
        +
        +
      • +
      + + + + + +
        +
      • +

        hasEntry

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key,
        +                                                                             V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
        assertThat(myMap, hasEntry("bar", "foo"))
        +
        +
        Parameters:
        +
        key - the key that, in combination with the value, must be describe at least one entry
        +
        value - the value that, in combination with the key, must be describe at least one entry
        +
        +
      • +
      + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
        assertThat(myMap, hasKey(equalTo("bar")))
        +
        +
        Parameters:
        +
        keyMatcher - the matcher that must be satisfied by at least one key
        +
        +
      • +
      + + + + + +
        +
      • +

        hasKey

        +
        public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
        assertThat(myMap, hasKey("bar"))
        +
        +
        Parameters:
        +
        key - the key that satisfying maps must contain
        +
        +
      • +
      + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
        assertThat(myMap, hasValue(equalTo("foo")))
        +
        +
        Parameters:
        +
        valueMatcher - the matcher that must be satisfied by at least one value
        +
        +
      • +
      + + + + + +
        +
      • +

        hasValue

        +
        public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
        +
        Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
        assertThat(myMap, hasValue("foo"))
        +
        +
        Parameters:
        +
        value - the value that satisfying maps must contain
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/IsMapWithSize.html b/docs/javadoc/2.2/org/hamcrest/collection/IsMapWithSize.html new file mode 100644 index 000000000..bea81f612 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/IsMapWithSize.html @@ -0,0 +1,390 @@ + + + + + +IsMapWithSize (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.collection
+

Class IsMapWithSize<K,V>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.Map<? extends K,? extends V>>, SelfDescribing
    +
    +
    +
    +
    public final class IsMapWithSize<K,V>
    +extends FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
    +
    Matches if map size satisfies a nested matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsMapWithSize

        +
        public IsMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.util.Map<? extends K,? extends V> actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.util.Map<? extends K,? extends V>,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        +
        +
        Parameters:
        +
        sizeMatcher - a matcher for the size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        aMapWithSize

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
        +
        Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
        assertThat(myMap, is(aMapWithSize(2)))
        +
        +
        Parameters:
        +
        size - the expected size of an examined Map
        +
        +
      • +
      + + + +
        +
      • +

        anEmptyMap

        +
        public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
        +
        Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
        assertThat(myMap, is(anEmptyMap()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/package-frame.html b/docs/javadoc/2.2/org/hamcrest/collection/package-frame.html new file mode 100644 index 000000000..4c0dca1d0 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/package-frame.html @@ -0,0 +1,36 @@ + + + + + +org.hamcrest.collection (Hamcrest 2.2 API) + + + + + +

org.hamcrest.collection

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/package-summary.html b/docs/javadoc/2.2/org/hamcrest/collection/package-summary.html new file mode 100644 index 000000000..01383911c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/package-summary.html @@ -0,0 +1,231 @@ + + + + + +org.hamcrest.collection (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.collection

+
+
Matchers of arrays and collections.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.collection Description

+

Matchers of arrays and collections.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/collection/package-tree.html b/docs/javadoc/2.2/org/hamcrest/collection/package-tree.html new file mode 100644 index 000000000..2d0195eb8 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/collection/package-tree.html @@ -0,0 +1,167 @@ + + + + + +org.hamcrest.collection Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.collection

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/comparator/ComparatorMatcherBuilder.html b/docs/javadoc/2.2/org/hamcrest/comparator/ComparatorMatcherBuilder.html new file mode 100644 index 000000000..cd6f9cf35 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/comparator/ComparatorMatcherBuilder.html @@ -0,0 +1,406 @@ + + + + + +ComparatorMatcherBuilder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.comparator
+

Class ComparatorMatcherBuilder<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.comparator.ComparatorMatcherBuilder<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class ComparatorMatcherBuilder<T>
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T> ComparatorMatcherBuilder<T>comparedBy(java.util.Comparator<T> comparator) +
      Creates a matcher factory for matchers of Comparatorss of T.
      +
      Matcher<T>comparesEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThan(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>greaterThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThan(T value) +
      Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
      +
      Matcher<T>lessThanOrEqualTo(T value) +
      Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
      +
      static <T extends java.lang.Comparable<T>>
      ComparatorMatcherBuilder<T>
      usingNaturalOrdering() +
      Creates a matcher factory for matchers of Comparables.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        usingNaturalOrdering

        +
        public static <T extends java.lang.Comparable<T>> ComparatorMatcherBuilder<T> usingNaturalOrdering()
        +
        Creates a matcher factory for matchers of Comparables. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
      • +
      + + + +
        +
      • +

        comparedBy

        +
        public static <T> ComparatorMatcherBuilder<T> comparedBy(java.util.Comparator<T> comparator)
        +
        Creates a matcher factory for matchers of Comparatorss of T. + For example: +
        assertThat(5, comparedBy(new Comparator<Integer>() {
        + public int compare(Integer o1, Integer o2) {
        + return -o1.compareTo(o2);
        + }
        + }).lessThan(4))
        +
      • +
      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public Matcher<T> comparesEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public Matcher<T> greaterThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(2, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public Matcher<T> greaterThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public Matcher<T> lessThan(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public Matcher<T> lessThanOrEqualTo(T value)
        +
        Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
        assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the Comparator supplied to this builder, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/comparator/package-frame.html b/docs/javadoc/2.2/org/hamcrest/comparator/package-frame.html new file mode 100644 index 000000000..691322c79 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/comparator/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.comparator (Hamcrest 2.2 API) + + + + + +

org.hamcrest.comparator

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.2/org/hamcrest/comparator/package-summary.html b/docs/javadoc/2.2/org/hamcrest/comparator/package-summary.html new file mode 100644 index 000000000..13634e0b7 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/comparator/package-summary.html @@ -0,0 +1,140 @@ + + + + + +org.hamcrest.comparator (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.comparator

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/comparator/package-tree.html b/docs/javadoc/2.2/org/hamcrest/comparator/package-tree.html new file mode 100644 index 000000000..7f53fb9e5 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/comparator/package-tree.html @@ -0,0 +1,135 @@ + + + + + +org.hamcrest.comparator Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.comparator

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/AllOf.html b/docs/javadoc/2.2/org/hamcrest/core/AllOf.html new file mode 100644 index 000000000..7fae45e8b --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/AllOf.html @@ -0,0 +1,378 @@ + + + + + +AllOf (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AllOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AllOf<T>
    +extends DiagnosingMatcher<T>
    +
    Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns false.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AllOf

        +
        @SafeVarargs
        +public AllOf(Matcher<? super T>... matchers)
        +
      • +
      + + + +
        +
      • +

        AllOf

        +
        public AllOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        allOf

        +
        @SafeVarargs
        +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/AnyOf.html b/docs/javadoc/2.2/org/hamcrest/core/AnyOf.html new file mode 100644 index 000000000..1ab314bd1 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/AnyOf.html @@ -0,0 +1,411 @@ + + + + + +AnyOf (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class AnyOf<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class AnyOf<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns true.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        AnyOf

        +
        @SafeVarargs
        +public AnyOf(Matcher<? super T>... matchers)
        +
      • +
      + + + +
        +
      • +

        AnyOf

        +
        public AnyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Specified by:
        +
        matches in interface Matcher<T>
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        anyOf

        +
        @SafeVarargs
        +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
        +
        Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        +
      • +
      + + + +
        +
      • +

        matches

        +
        protected boolean matches(java.lang.Object o,
        +                          boolean shortcut)
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description,
        +                       java.lang.String operator)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..74a26df2b --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableBothMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableBothMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableBothMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..90dd05785 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,273 @@ + + + + + +CombinableMatcher.CombinableEitherMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher.CombinableEitherMatcher<X>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<X>
    • +
    +
  • +
+
+
    +
  • +
    +
    Enclosing class:
    +
    CombinableMatcher<T>
    +
    +
    +
    +
    public static final class CombinableMatcher.CombinableEitherMatcher<X>
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+ +
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.html b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.html new file mode 100644 index 000000000..aa0dc12ff --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/CombinableMatcher.html @@ -0,0 +1,418 @@ + + + + + +CombinableMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class CombinableMatcher<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CombinableMatcher

        +
        public CombinableMatcher(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + + + + + + + +
        +
      • +

        both

        +
        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
        assertThat("fab", both(containsString("a")).and(containsString("b")))
        +
      • +
      + + + +
        +
      • +

        either

        +
        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
        +
        Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
        assertThat("fan", either(containsString("a")).or(containsString("b")))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/DescribedAs.html b/docs/javadoc/2.2/org/hamcrest/core/DescribedAs.html new file mode 100644 index 000000000..65b62518c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/DescribedAs.html @@ -0,0 +1,391 @@ + + + + + +DescribedAs (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class DescribedAs<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class DescribedAs<T>
    +extends BaseMatcher<T>
    +
    Provides a custom description to another matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DescribedAs

        +
        public DescribedAs(java.lang.String descriptionTemplate,
        +                   Matcher<T> matcher,
        +                   java.lang.Object[] values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description description)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describedAs

        +
        public static <T> Matcher<T> describedAs(java.lang.String description,
        +                                         Matcher<T> matcher,
        +                                         java.lang.Object... values)
        +
        Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
        describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
        +
        +
        Parameters:
        +
        description - the new description for the wrapped matcher
        +
        matcher - the matcher to wrap
        +
        values - optional values to insert into the tokenised description
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/Every.html b/docs/javadoc/2.2/org/hamcrest/core/Every.html new file mode 100644 index 000000000..a47b11588 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/Every.html @@ -0,0 +1,357 @@ + + + + + +Every (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Every<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Every

        +
        public Every(Matcher<? super T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Iterable<? extends T> collection,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? extends T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        everyItem

        +
        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
        assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/Is.html b/docs/javadoc/2.2/org/hamcrest/core/Is.html new file mode 100644 index 000000000..4305017d6 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/Is.html @@ -0,0 +1,426 @@ + + + + + +Is (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class Is<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class Is<T>
    +extends BaseMatcher<T>
    +
    Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive. + + For example: assertThat(cheese, equalTo(smelly)) + vs. assertThat(cheese, is(equalTo(smelly)))
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      Is(Matcher<T> matcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeMismatch(java.lang.Object item, + Description mismatchDescription) +
      Generate a description of why the matcher has not accepted the item.
      +
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<T>is(Matcher<T> matcher) +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
      +
      static <T> Matcher<T>is(T value) +
      A shortcut to the frequently used is(equalTo(x)).
      +
      static <T> Matcher<T>isA(java.lang.Class<?> type) +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      +
      booleanmatches(java.lang.Object arg) +
      Evaluates the matcher for argument item.
      +
      + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Is

        +
        public Is(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatch

        +
        public void describeMismatch(java.lang.Object item,
        +                             Description mismatchDescription)
        +
        Description copied from interface: Matcher
        +
        Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
        +
        +
        Specified by:
        +
        describeMismatch in interface Matcher<T>
        +
        Overrides:
        +
        describeMismatch in class BaseMatcher<T>
        +
        Parameters:
        +
        item - The item that the Matcher has rejected.
        +
        mismatchDescription - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(Matcher<T> matcher)
        +
        Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
        assertThat(cheese, is(equalTo(smelly)))
        + instead of: +
        assertThat(cheese, equalTo(smelly))
        +
      • +
      + + + + + +
        +
      • +

        is

        +
        public static <T> Matcher<T> is(T value)
        +
        A shortcut to the frequently used is(equalTo(x)). + For example: +
        assertThat(cheese, is(smelly))
        + instead of: +
        assertThat(cheese, is(equalTo(smelly)))
        +
      • +
      + + + +
        +
      • +

        isA

        +
        public static <T> Matcher<T> isA(java.lang.Class<?> type)
        +
        A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
        assertThat(cheese, isA(Cheddar.class))
        + instead of: +
        assertThat(cheese, is(instanceOf(Cheddar.class)))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsAnything.html b/docs/javadoc/2.2/org/hamcrest/core/IsAnything.html new file mode 100644 index 000000000..a05a645a7 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsAnything.html @@ -0,0 +1,376 @@ + + + + + +IsAnything (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsAnything<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsAnything<T>
    +extends BaseMatcher<T>
    +
    A matcher that always returns true.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything()
        +
      • +
      + + + +
        +
      • +

        IsAnything

        +
        public IsAnything(java.lang.String message)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything()
        +
        Creates a matcher that always matches, regardless of the examined object.
        +
      • +
      + + + +
        +
      • +

        anything

        +
        public static Matcher<java.lang.Object> anything(java.lang.String description)
        +
        Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
        +
        +
        Parameters:
        +
        description - a meaningful String used when describing itself
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsCollectionContaining.html b/docs/javadoc/2.2/org/hamcrest/core/IsCollectionContaining.html new file mode 100644 index 000000000..0fdfca85e --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsCollectionContaining.html @@ -0,0 +1,460 @@ + + + + + +IsCollectionContaining (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsCollectionContaining<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCollectionContaining

        +
        public IsCollectionContaining(Matcher<? super T> elementMatcher)
        +
        Deprecated. 
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
        +                                Description mismatchDescription)
        +
        Deprecated. 
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Deprecated. 
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItem(Matcher).
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItem(Object).
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItems(Matcher[])}.
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Deprecated. As of version 2.1, use IsIterableContaining.hasItems(Object[])}.
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsEqual.html b/docs/javadoc/2.2/org/hamcrest/core/IsEqual.html new file mode 100644 index 000000000..5eac56469 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsEqual.html @@ -0,0 +1,385 @@ + + + + + +IsEqual (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsEqual<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsEqual<T>
    +extends BaseMatcher<T>
    +
    Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) invokedMethod?
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsEqual(T equalArg) 
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsEqual

        +
        public IsEqual(T equalArg)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object actualValue)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        actualValue - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        equalTo

        +
        public static <T> Matcher<T> 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. + +

        If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

        + +

        The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

        + For example: +
        + assertThat("foo", equalTo("foo"));
        + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        + 
        +
      • +
      + + + +
        +
      • +

        equalToObject

        +
        public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
        +
        Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsInstanceOf.html b/docs/javadoc/2.2/org/hamcrest/core/IsInstanceOf.html new file mode 100644 index 000000000..8044c738f --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsInstanceOf.html @@ -0,0 +1,386 @@ + + + + + +IsInstanceOf (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsInstanceOf

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Object>, SelfDescribing
    +
    +
    +
    +
    public class IsInstanceOf
    +extends DiagnosingMatcher<java.lang.Object>
    +
    Tests whether the value is an instance of a class. + Classes of basic types will be converted to the relevant "Object" classes
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      IsInstanceOf(java.lang.Class<?> expectedClass) +
      Creates a new instance of IsInstanceOf
      +
      +
    • +
    + + +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsInstanceOf

        +
        public IsInstanceOf(java.lang.Class<?> expectedClass)
        +
        Creates a new instance of IsInstanceOf
        +
        +
        Parameters:
        +
        expectedClass - The predicate evaluates to true for instances of this class + or one of its subclasses.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        instanceOf

        +
        public static <T> Matcher<T> 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. + +

        The created matcher assumes no relationship between specified type and the examined object.

        + For example: +
        assertThat(new Canoe(), instanceOf(Paddlable.class));
        +
      • +
      + + + +
        +
      • +

        any

        +
        public static <T> Matcher<T> 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. + +

        The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

        + For example: +
        assertThat(new Canoe(), instanceOf(Canoe.class));
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsIterableContaining.html b/docs/javadoc/2.2/org/hamcrest/core/IsIterableContaining.html new file mode 100644 index 000000000..215cbbef9 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsIterableContaining.html @@ -0,0 +1,445 @@ + + + + + +IsIterableContaining (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsIterableContaining<T>

+
+
+ +
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static <T> Matcher<java.lang.Iterable<? super T>>hasItem(Matcher<? super T> itemMatcher) +
      Creates a matcher for Iterables 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>>hasItem(T item) +
      Creates a matcher for Iterables 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>>hasItems(Matcher<? super T>... itemMatchers) +
      Creates a matcher for Iterables 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>>hasItems(T... items) +
      Creates a matcher for Iterables 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.
      +
      protected booleanmatchesSafely(java.lang.Iterable<? super T> collection, + Description mismatchDescription) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsIterableContaining

        +
        public IsIterableContaining(Matcher<? super T> elementMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.Iterable<? super T> collection,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.Iterable<? super T>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
        +
        +
        Parameters:
        +
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItem

        +
        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
        +
        Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
        +
        +
        Parameters:
        +
        item - the item to compare against the items provided by the examined Iterable
        +
        +
      • +
      + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
        +
        +
        Parameters:
        +
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        +
        +
      • +
      + + + + + +
        +
      • +

        hasItems

        +
        @SafeVarargs
        +public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
        +
        Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
        assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
        +
        +
        Parameters:
        +
        items - the items to compare against the items provided by the examined Iterable
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsNot.html b/docs/javadoc/2.2/org/hamcrest/core/IsNot.html new file mode 100644 index 000000000..3c3119d3a --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsNot.html @@ -0,0 +1,376 @@ + + + + + +IsNot (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNot<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsNot<T>
    +extends BaseMatcher<T>
    +
    Calculates the logical negation of a matcher.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNot

        +
        public IsNot(Matcher<T> matcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(Matcher<T> matcher)
        +
        Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        matcher - the matcher whose sense should be inverted
        +
        +
      • +
      + + + + + +
        +
      • +

        not

        +
        public static <T> Matcher<T> not(T value)
        +
        A shortcut to the frequently used not(equalTo(x)). + For example: +
        assertThat(cheese, is(not(smelly)))
        + instead of: +
        assertThat(cheese, is(not(equalTo(smelly))))
        +
        +
        Parameters:
        +
        value - the value that any examined object should not equal
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsNull.html b/docs/javadoc/2.2/org/hamcrest/core/IsNull.html new file mode 100644 index 000000000..d97117764 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsNull.html @@ -0,0 +1,412 @@ + + + + + +IsNull (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsNull<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsNull

        +
        public IsNull()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object o)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        o - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static Matcher<java.lang.Object> nullValue()
        +
        Creates a matcher that matches if examined object is null. + For example: +
        assertThat(cheese, is(nullValue())
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static Matcher<java.lang.Object> notNullValue()
        +
        A shortcut to the frequently used not(nullValue()). + For example: +
        assertThat(cheese, is(notNullValue()))
        + instead of: +
        assertThat(cheese, is(not(nullValue())))
        +
      • +
      + + + +
        +
      • +

        nullValue

        +
        public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
        +
        Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
        assertThat(cheese, is(nullValue(Cheese.class))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      + + + +
        +
      • +

        notNullValue

        +
        public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
        +
        A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
        assertThat(cheese, is(notNullValue(X.class)))
        + instead of: +
        assertThat(cheese, is(not(nullValue(X.class))))
        +
        +
        Parameters:
        +
        type - dummy parameter used to infer the generic type of the returned matcher
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/IsSame.html b/docs/javadoc/2.2/org/hamcrest/core/IsSame.html new file mode 100644 index 000000000..70fa6c11c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/IsSame.html @@ -0,0 +1,376 @@ + + + + + +IsSame (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class IsSame<T>

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<T>, SelfDescribing
    +
    +
    +
    +
    public class IsSame<T>
    +extends BaseMatcher<T>
    +
    Is the value the same object as another value?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        IsSame

        +
        public IsSame(T object)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matches

        +
        public boolean matches(java.lang.Object arg)
        +
        Description copied from interface: Matcher
        +
        Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
        +
        +
        Parameters:
        +
        arg - the object against which the matcher is evaluated.
        +
        Returns:
        +
        true if item matches, otherwise false.
        +
        See Also:
        +
        BaseMatcher
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + + + +
        +
      • +

        sameInstance

        +
        public static <T> Matcher<T> sameInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      + + + + + +
        +
      • +

        theInstance

        +
        public static <T> Matcher<T> theInstance(T target)
        +
        Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
        +
        +
        Parameters:
        +
        target - the target instance against which others should be assessed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/StringContains.html b/docs/javadoc/2.2/org/hamcrest/core/StringContains.html new file mode 100644 index 000000000..dc7ae25f0 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/StringContains.html @@ -0,0 +1,391 @@ + + + + + +StringContains (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringContains

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringContains
    +extends SubstringMatcher
    +
    Tests if the argument is a string that contains a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContains

        +
        public StringContains(java.lang.String substring)
        +
      • +
      + + + +
        +
      • +

        StringContains

        +
        public StringContains(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        containsString

        +
        public static Matcher<java.lang.String> containsString(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
        assertThat("myStringOfNote", containsString("ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      + + + +
        +
      • +

        containsStringIgnoringCase

        +
        public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
        +
        Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
        assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
        +
        +
        Parameters:
        +
        substring - the substring that the returned matcher will expect to find within any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/StringEndsWith.html b/docs/javadoc/2.2/org/hamcrest/core/StringEndsWith.html new file mode 100644 index 000000000..c85f92fd4 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/StringEndsWith.html @@ -0,0 +1,391 @@ + + + + + +StringEndsWith (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringEndsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringEndsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that ends with a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringEndsWith

        +
        public StringEndsWith(java.lang.String substring)
        +
      • +
      + + + +
        +
      • +

        StringEndsWith

        +
        public StringEndsWith(boolean ignoringCase,
        +                      java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        endsWith

        +
        public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
        assertThat("myStringOfNote", endsWith("Note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        endsWithIgnoringCase

        +
        public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
        +
        Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
        assertThat("myStringOfNote", endsWithIgnoringCase("note"))
        +
        +
        Parameters:
        +
        suffix - the substring that the returned matcher will expect at the end of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/StringRegularExpression.html b/docs/javadoc/2.2/org/hamcrest/core/StringRegularExpression.html new file mode 100644 index 000000000..cd0071f84 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/StringRegularExpression.html @@ -0,0 +1,385 @@ + + + + + +StringRegularExpression (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringRegularExpression

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringRegularExpression

        +
        protected StringRegularExpression(java.util.regex.Pattern pattern)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.String actual,
        +                                Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.util.regex.Pattern pattern)
        +
        Creates a matcher that checks if the examined string matches a specified Pattern. + +
        + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
        + 
        +
        +
        Parameters:
        +
        pattern - the pattern to be used.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      + + + +
        +
      • +

        matchesRegex

        +
        public static Matcher<java.lang.String> matchesRegex(java.lang.String regex)
        +
        Creates a matcher that checks if the examined string matches a specified regex. + +
        + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
        + 
        +
        +
        Parameters:
        +
        regex - The regex to be used for the validation.
        +
        Returns:
        +
        The matcher.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/StringStartsWith.html b/docs/javadoc/2.2/org/hamcrest/core/StringStartsWith.html new file mode 100644 index 000000000..f69047647 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/StringStartsWith.html @@ -0,0 +1,397 @@ + + + + + +StringStartsWith (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class StringStartsWith

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class StringStartsWith
    +extends SubstringMatcher
    +
    Tests if the argument is a string that starts with a specific substring.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringStartsWith

        +
        public StringStartsWith(java.lang.String substring)
        +
      • +
      + + + +
        +
      • +

        StringStartsWith

        +
        public StringStartsWith(boolean ignoringCase,
        +                        java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        startsWith

        +
        public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String. +

        + For example: +
        assertThat("myStringOfNote", startsWith("my"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      + + + +
        +
      • +

        startsWithIgnoringCase

        +
        public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
        +

        + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

        + For example: +
        assertThat("myStringOfNote", startsWithIgnoringCase("My"))
        +
        +
        Parameters:
        +
        prefix - the substring that the returned matcher will expect at the start of any examined string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/SubstringMatcher.html b/docs/javadoc/2.2/org/hamcrest/core/SubstringMatcher.html new file mode 100644 index 000000000..80d3a2f98 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/SubstringMatcher.html @@ -0,0 +1,425 @@ + + + + + +SubstringMatcher (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.core
+

Class SubstringMatcher

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        substring

        +
        protected final java.lang.String substring
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SubstringMatcher

        +
        protected SubstringMatcher(java.lang.String relationship,
        +                           boolean ignoringCase,
        +                           java.lang.String substring)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        converted

        +
        protected java.lang.String converted(java.lang.String arg)
        +
      • +
      + + + +
        +
      • +

        evalSubstringOf

        +
        protected abstract boolean evalSubstringOf(java.lang.String string)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/package-frame.html b/docs/javadoc/2.2/org/hamcrest/core/package-frame.html new file mode 100644 index 000000000..cff1784b1 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/package-frame.html @@ -0,0 +1,40 @@ + + + + + +org.hamcrest.core (Hamcrest 2.2 API) + + + + + +

org.hamcrest.core

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/package-summary.html b/docs/javadoc/2.2/org/hamcrest/core/package-summary.html new file mode 100644 index 000000000..6f7f472cf --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/package-summary.html @@ -0,0 +1,259 @@ + + + + + +org.hamcrest.core (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.core

+
+
Fundamental matchers of objects and values, and composite matchers.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.core Description

+

Fundamental matchers of objects and values, and composite matchers.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/core/package-tree.html b/docs/javadoc/2.2/org/hamcrest/core/package-tree.html new file mode 100644 index 000000000..5ced431d2 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/core/package-tree.html @@ -0,0 +1,174 @@ + + + + + +org.hamcrest.core Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.core

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/ArrayIterator.html b/docs/javadoc/2.2/org/hamcrest/internal/ArrayIterator.html new file mode 100644 index 000000000..f5a1fac1c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/ArrayIterator.html @@ -0,0 +1,319 @@ + + + + + +ArrayIterator (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ArrayIterator

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ArrayIterator
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<java.lang.Object>
    +
    +
    +
    +
    public class ArrayIterator
    +extends java.lang.Object
    +implements java.util.Iterator<java.lang.Object>
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ArrayIterator(java.lang.Object array) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      java.lang.Objectnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ArrayIterator

        +
        public ArrayIterator(java.lang.Object array)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        next

        +
        public java.lang.Object next()
        +
        +
        Specified by:
        +
        next in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<java.lang.Object>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/NullSafety.html b/docs/javadoc/2.2/org/hamcrest/internal/NullSafety.html new file mode 100644 index 000000000..77aa40d1f --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/NullSafety.html @@ -0,0 +1,269 @@ + + + + + +NullSafety (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class NullSafety

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.NullSafety
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class NullSafety
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      NullSafety() 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <E> java.util.List<Matcher<? super E>>nullSafe(Matcher<? super E>[] itemMatchers) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        NullSafety

        +
        public NullSafety()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        nullSafe

        +
        public static <E> java.util.List<Matcher<? super E>> nullSafe(Matcher<? super E>[] itemMatchers)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/ReflectiveTypeFinder.html b/docs/javadoc/2.2/org/hamcrest/internal/ReflectiveTypeFinder.html new file mode 100644 index 000000000..6afdd656f --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/ReflectiveTypeFinder.html @@ -0,0 +1,273 @@ + + + + + +ReflectiveTypeFinder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class ReflectiveTypeFinder

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.ReflectiveTypeFinder
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class ReflectiveTypeFinder
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      ReflectiveTypeFinder(java.lang.String methodName, + int expectedNumberOfParameters, + int typedParameter) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      java.lang.Class<?>findExpectedType(java.lang.Class<?> fromClass) 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ReflectiveTypeFinder

        +
        public ReflectiveTypeFinder(java.lang.String methodName,
        +                            int expectedNumberOfParameters,
        +                            int typedParameter)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        findExpectedType

        +
        public java.lang.Class<?> findExpectedType(java.lang.Class<?> fromClass)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValue.html b/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValue.html new file mode 100644 index 000000000..70bca67bc --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValue.html @@ -0,0 +1,288 @@ + + + + + +SelfDescribingValue (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValue<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValue<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    SelfDescribing
    +
    +
    +
    +
    public class SelfDescribingValue<T>
    +extends java.lang.Object
    +implements SelfDescribing
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      SelfDescribingValue(T value) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        SelfDescribingValue

        +
        public SelfDescribingValue(T value)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Specified by:
        +
        describeTo in interface SelfDescribing
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValueIterator.html b/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValueIterator.html new file mode 100644 index 000000000..cf499e756 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/SelfDescribingValueIterator.html @@ -0,0 +1,319 @@ + + + + + +SelfDescribingValueIterator (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.internal
+

Class SelfDescribingValueIterator<T>

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.internal.SelfDescribingValueIterator<T>
    • +
    +
  • +
+
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    java.util.Iterator<SelfDescribing>
    +
    +
    +
    +
    public class SelfDescribingValueIterator<T>
    +extends java.lang.Object
    +implements java.util.Iterator<SelfDescribing>
    +
  • +
+
+
+
    +
  • + + + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      booleanhasNext() 
      SelfDescribingnext() 
      voidremove() 
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
        +
      • + + +

        Methods inherited from interface java.util.Iterator

        +forEachRemaining
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SelfDescribingValueIterator

        +
        public SelfDescribingValueIterator(java.util.Iterator<T> values)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasNext

        +
        public boolean hasNext()
        +
        +
        Specified by:
        +
        hasNext in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      + + + + + + + +
        +
      • +

        remove

        +
        public void remove()
        +
        +
        Specified by:
        +
        remove in interface java.util.Iterator<SelfDescribing>
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/package-frame.html b/docs/javadoc/2.2/org/hamcrest/internal/package-frame.html new file mode 100644 index 000000000..076163593 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.internal (Hamcrest 2.2 API) + + + + + +

org.hamcrest.internal

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/package-summary.html b/docs/javadoc/2.2/org/hamcrest/internal/package-summary.html new file mode 100644 index 000000000..4e08bdfb5 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/package-summary.html @@ -0,0 +1,156 @@ + + + + + +org.hamcrest.internal (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.internal

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/internal/package-tree.html b/docs/javadoc/2.2/org/hamcrest/internal/package-tree.html new file mode 100644 index 000000000..51a45c709 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/internal/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.internal Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.internal

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.FileStatus.html b/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.FileStatus.html new file mode 100644 index 000000000..5e83792a9 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.FileStatus.html @@ -0,0 +1,223 @@ + + + + + +FileMatchers.FileStatus (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Interface FileMatchers.FileStatus

+
+
+
+
    +
  • +
    +
    Enclosing class:
    +
    FileMatchers
    +
    +
    +
    +
    public static interface FileMatchers.FileStatus
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        check

        +
        boolean check(java.io.File actual)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.html b/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.html new file mode 100644 index 000000000..6c1d789eb --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/io/FileMatchers.html @@ -0,0 +1,493 @@ + + + + + +FileMatchers (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.io
+

Class FileMatchers

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.io.FileMatchers
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public final class FileMatchers
    +extends java.lang.Object
    +
  • +
+
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FileMatchers

        +
        public FileMatchers()
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        anExistingDirectory

        +
        public static Matcher<java.io.File> anExistingDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFileOrDirectory

        +
        public static Matcher<java.io.File> anExistingFileOrDirectory()
        +
      • +
      + + + +
        +
      • +

        anExistingFile

        +
        public static Matcher<java.io.File> anExistingFile()
        +
      • +
      + + + +
        +
      • +

        aReadableFile

        +
        public static Matcher<java.io.File> aReadableFile()
        +
      • +
      + + + +
        +
      • +

        aWritableFile

        +
        public static Matcher<java.io.File> aWritableFile()
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(long size)
        +
      • +
      + + + +
        +
      • +

        aFileWithSize

        +
        public static Matcher<java.io.File> aFileWithSize(Matcher<java.lang.Long> expected)
        +
      • +
      + + + +
        +
      • +

        aFileNamed

        +
        public static Matcher<java.io.File> aFileNamed(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithCanonicalPath

        +
        public static Matcher<java.io.File> aFileWithCanonicalPath(Matcher<java.lang.String> expected)
        +
      • +
      + + + +
        +
      • +

        aFileWithAbsolutePath

        +
        public static Matcher<java.io.File> aFileWithAbsolutePath(Matcher<java.lang.String> expected)
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/io/package-frame.html b/docs/javadoc/2.2/org/hamcrest/io/package-frame.html new file mode 100644 index 000000000..a6dc1ff48 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/io/package-frame.html @@ -0,0 +1,24 @@ + + + + + +org.hamcrest.io (Hamcrest 2.2 API) + + + + + +

org.hamcrest.io

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/docs/javadoc/2.2/org/hamcrest/io/package-summary.html b/docs/javadoc/2.2/org/hamcrest/io/package-summary.html new file mode 100644 index 000000000..1734b6e5c --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/io/package-summary.html @@ -0,0 +1,155 @@ + + + + + +org.hamcrest.io (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.io

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/io/package-tree.html b/docs/javadoc/2.2/org/hamcrest/io/package-tree.html new file mode 100644 index 000000000..ec2b0446d --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/io/package-tree.html @@ -0,0 +1,139 @@ + + + + + +org.hamcrest.io Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.io

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/BigDecimalCloseTo.html b/docs/javadoc/2.2/org/hamcrest/number/BigDecimalCloseTo.html new file mode 100644 index 000000000..69b1db99e --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/BigDecimalCloseTo.html @@ -0,0 +1,383 @@ + + + + + +BigDecimalCloseTo (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class BigDecimalCloseTo

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BigDecimalCloseTo

        +
        public BigDecimalCloseTo(java.math.BigDecimal value,
        +                         java.math.BigDecimal error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.math.BigDecimal item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.math.BigDecimal item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.math.BigDecimal>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand,
        +                                                    java.math.BigDecimal error)
        +
        Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
        assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
        +
        +
        Parameters:
        +
        operand - the expected value of matching BigDecimals
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/IsCloseTo.html b/docs/javadoc/2.2/org/hamcrest/number/IsCloseTo.html new file mode 100644 index 000000000..016386b08 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/IsCloseTo.html @@ -0,0 +1,384 @@ + + + + + +IsCloseTo (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsCloseTo

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public class IsCloseTo
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number equal to a value within some range of + acceptable error?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCloseTo

        +
        public IsCloseTo(double value,
        +                 double error)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        closeTo

        +
        public static Matcher<java.lang.Double> closeTo(double operand,
        +                                                double error)
        +
        Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
        assertThat(1.03, is(closeTo(1.0, 0.03)))
        +
        +
        Parameters:
        +
        operand - the expected value of matching doubles
        +
        error - the delta (+/-) within which matches will be allowed
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/IsNaN.html b/docs/javadoc/2.2/org/hamcrest/number/IsNaN.html new file mode 100644 index 000000000..1c841eb5b --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/IsNaN.html @@ -0,0 +1,338 @@ + + + + + +IsNaN (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class IsNaN

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.Double>, SelfDescribing
    +
    +
    +
    +
    public final class IsNaN
    +extends TypeSafeMatcher<java.lang.Double>
    +
    Is the value a number actually not a number (NaN)?
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Double item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Double item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Double>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        notANumber

        +
        public static Matcher<java.lang.Double> notANumber()
        +
        Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
        assertThat(Double.NaN, is(notANumber()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/OrderingComparison.html b/docs/javadoc/2.2/org/hamcrest/number/OrderingComparison.html new file mode 100644 index 000000000..67c4ce690 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/OrderingComparison.html @@ -0,0 +1,366 @@ + + + + + +OrderingComparison (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.number
+

Class OrderingComparison

+
+
+
    +
  • java.lang.Object
  • +
  • +
      +
    • org.hamcrest.number.OrderingComparison
    • +
    +
  • +
+
+
    +
  • +
    +
    +
    public class OrderingComparison
    +extends java.lang.Object
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Concrete Methods 
      Modifier and TypeMethod and Description
      static <T extends java.lang.Comparable<T>>
      Matcher<T>
      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>
      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>
      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>
      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>
      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.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        comparesEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, comparesEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(2, greaterThan(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        greaterThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, greaterThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThan

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThan(2))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
        +
        +
      • +
      + + + + + +
        +
      • +

        lessThanOrEqualTo

        +
        public static <T extends java.lang.Comparable<T>> Matcher<T> 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. + For example: +
        assertThat(1, lessThanOrEqualTo(1))
        +
        +
        Parameters:
        +
        value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/package-frame.html b/docs/javadoc/2.2/org/hamcrest/number/package-frame.html new file mode 100644 index 000000000..9ef135e6d --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.number (Hamcrest 2.2 API) + + + + + +

org.hamcrest.number

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/package-summary.html b/docs/javadoc/2.2/org/hamcrest/number/package-summary.html new file mode 100644 index 000000000..07bd2ccc3 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/package-summary.html @@ -0,0 +1,166 @@ + + + + + +org.hamcrest.number (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.number

+
+
Matchers that perform numeric comparisons.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    BigDecimalCloseTo 
    IsCloseTo +
    Is the value a number equal to a value within some range of + acceptable error?
    +
    IsNaN +
    Is the value a number actually not a number (NaN)?
    +
    OrderingComparison 
    +
  • +
+ + + +

Package org.hamcrest.number Description

+

Matchers that perform numeric comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/number/package-tree.html b/docs/javadoc/2.2/org/hamcrest/number/package-tree.html new file mode 100644 index 000000000..529ca4b73 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/number/package-tree.html @@ -0,0 +1,146 @@ + + + + + +org.hamcrest.number Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.number

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/HasEqualValues.html b/docs/javadoc/2.2/org/hamcrest/object/HasEqualValues.html new file mode 100644 index 000000000..85afbbb59 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/HasEqualValues.html @@ -0,0 +1,335 @@ + + + + + +HasEqualValues (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class HasEqualValues<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        HasEqualValues

        +
        public HasEqualValues(T expectedObject)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/HasToString.html b/docs/javadoc/2.2/org/hamcrest/object/HasToString.html new file mode 100644 index 000000000..660ce66df --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/HasToString.html @@ -0,0 +1,371 @@ + + + + + +HasToString (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class HasToString<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasToString

        +
        public HasToString(Matcher<? super java.lang.String> toStringMatcher)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.String featureValueOf(T actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<T,java.lang.String>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> 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. + For example: +
        assertThat(true, hasToString(equalTo("TRUE")))
        +
        +
        Parameters:
        +
        toStringMatcher - the matcher used to verify the toString result
        +
        +
      • +
      + + + +
        +
      • +

        hasToString

        +
        public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
        +
        Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
        assertThat(true, hasToString("TRUE"))
        +
        +
        Parameters:
        +
        expectedToString - the expected toString result
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/IsCompatibleType.html b/docs/javadoc/2.2/org/hamcrest/object/IsCompatibleType.html new file mode 100644 index 000000000..217837e20 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/IsCompatibleType.html @@ -0,0 +1,377 @@ + + + + + +IsCompatibleType (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsCompatibleType<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsCompatibleType

        +
        public IsCompatibleType(java.lang.Class<T> type)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.Class<?> cls)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.Class<?> cls,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.Class<?>>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        typeCompatibleWith

        +
        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
        +
        Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
        assertThat(Integer.class, typeCompatibleWith(Number.class))
        +
        +
        Parameters:
        +
        baseType - the base class to examine classes against
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/IsEventFrom.html b/docs/javadoc/2.2/org/hamcrest/object/IsEventFrom.html new file mode 100644 index 000000000..eb7007440 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/IsEventFrom.html @@ -0,0 +1,385 @@ + + + + + +IsEventFrom (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.object
+

Class IsEventFrom

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.util.EventObject>, SelfDescribing
    +
    +
    +
    +
    public class IsEventFrom
    +extends TypeSafeDiagnosingMatcher<java.util.EventObject>
    +
    Tests if the value is an event announced by a specific object.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEventFrom

        +
        public IsEventFrom(java.lang.Class<?> eventClass,
        +                   java.lang.Object source)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.util.EventObject item,
        +                             Description mismatchDescription)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<java.util.EventObject>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> 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. + For example: +
        assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
        +
        +
        Parameters:
        +
        eventClass - the class of the event to match on
        +
        source - the source of the event
        +
        +
      • +
      + + + +
        +
      • +

        eventFrom

        +
        public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
        +
        Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
        assertThat(myEvent, is(eventFrom(myBean)))
        +
        +
        Parameters:
        +
        source - the source of the event
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/package-frame.html b/docs/javadoc/2.2/org/hamcrest/object/package-frame.html new file mode 100644 index 000000000..3d5046f38 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/package-frame.html @@ -0,0 +1,23 @@ + + + + + +org.hamcrest.object (Hamcrest 2.2 API) + + + + + +

org.hamcrest.object

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/package-summary.html b/docs/javadoc/2.2/org/hamcrest/object/package-summary.html new file mode 100644 index 000000000..27a96e2fa --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/package-summary.html @@ -0,0 +1,163 @@ + + + + + +org.hamcrest.object (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.object

+
+
Matchers that inspect objects and classes.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.object Description

+

Matchers that inspect objects and classes.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/object/package-tree.html b/docs/javadoc/2.2/org/hamcrest/object/package-tree.html new file mode 100644 index 000000000..2afa9109b --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/object/package-tree.html @@ -0,0 +1,154 @@ + + + + + +org.hamcrest.object Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.object

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/package-frame.html b/docs/javadoc/2.2/org/hamcrest/package-frame.html new file mode 100644 index 000000000..9bc608c34 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/package-frame.html @@ -0,0 +1,40 @@ + + + + + +org.hamcrest (Hamcrest 2.2 API) + + + + + +

org.hamcrest

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/package-summary.html b/docs/javadoc/2.2/org/hamcrest/package-summary.html new file mode 100644 index 000000000..0f5ea525d --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/package-summary.html @@ -0,0 +1,247 @@ + + + + + +org.hamcrest (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest

+
+
+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/package-tree.html b/docs/javadoc/2.2/org/hamcrest/package-tree.html new file mode 100644 index 000000000..0b7416bd7 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/package-tree.html @@ -0,0 +1,170 @@ + + + + + +org.hamcrest Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/CharSequenceLength.html b/docs/javadoc/2.2/org/hamcrest/text/CharSequenceLength.html new file mode 100644 index 000000000..c97d5b674 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/CharSequenceLength.html @@ -0,0 +1,377 @@ + + + + + +CharSequenceLength (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class CharSequenceLength

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.CharSequence>, SelfDescribing
    +
    +
    +
    +
    public class CharSequenceLength
    +extends FeatureMatcher<java.lang.CharSequence,java.lang.Integer>
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CharSequenceLength

        +
        public CharSequenceLength(Matcher<? super java.lang.Integer> lengthMatcher)
        +
        +
        Parameters:
        +
        lengthMatcher - The matcher to apply to the feature
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        featureValueOf

        +
        protected java.lang.Integer featureValueOf(java.lang.CharSequence actual)
        +
        Description copied from class: FeatureMatcher
        +
        Implement this to extract the interesting feature.
        +
        +
        Specified by:
        +
        featureValueOf in class FeatureMatcher<java.lang.CharSequence,java.lang.Integer>
        +
        Parameters:
        +
        actual - the target object
        +
        Returns:
        +
        the feature to be matched
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(int length)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
        + assertThat("text", hasLength(4))
        + 
        +
        +
        Parameters:
        +
        length - the expected length of the string
        +
        +
      • +
      + + + +
        +
      • +

        hasLength

        +
        public static Matcher<java.lang.CharSequence> hasLength(Matcher<? super java.lang.Integer> lengthMatcher)
        +
        Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
        + assertThat("text", hasLength(lessThan(4)))
        + 
        +
        +
        Parameters:
        +
        lengthMatcher - the expected length of the string
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/IsBlankString.html b/docs/javadoc/2.2/org/hamcrest/text/IsBlankString.html new file mode 100644 index 000000000..013c93ea6 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/IsBlankString.html @@ -0,0 +1,336 @@ + + + + + +IsBlankString (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsBlankString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsBlankString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches blank Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        blankString

        +
        public static Matcher<java.lang.String> blankString()
        +
        Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
        assertThat("  ", is(blankString()))
        +
      • +
      + + + +
        +
      • +

        blankOrNullString

        +
        public static Matcher<java.lang.String> blankOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
        assertThat(((String)null), is(blankOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/IsEmptyString.html b/docs/javadoc/2.2/org/hamcrest/text/IsEmptyString.html new file mode 100644 index 000000000..9863ae092 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/IsEmptyString.html @@ -0,0 +1,379 @@ + + + + + +IsEmptyString (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEmptyString

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public final class IsEmptyString
    +extends TypeSafeMatcher<java.lang.String>
    +
    Matches empty Strings (and null).
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        isEmptyString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyString()
        +
        Deprecated. use is(emptyString()) instead
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", isEmptyString())
        +
      • +
      + + + +
        +
      • +

        emptyString

        +
        public static Matcher<java.lang.String> emptyString()
        +
        Creates a matcher of String that matches when the examined string has zero length. + For example: +
        assertThat("", is(emptyString()))
        +
      • +
      + + + +
        +
      • +

        isEmptyOrNullString

        +
        @Deprecated
        +public static Matcher<java.lang.String> isEmptyOrNullString()
        +
        Deprecated. use is(emptyOrNullString()) instead
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), isEmptyOrNullString())
        +
      • +
      + + + +
        +
      • +

        emptyOrNullString

        +
        public static Matcher<java.lang.String> emptyOrNullString()
        +
        Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
        assertThat(((String)null), is(emptyOrNullString()))
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/IsEqualCompressingWhiteSpace.html b/docs/javadoc/2.2/org/hamcrest/text/IsEqualCompressingWhiteSpace.html new file mode 100644 index 000000000..19ec02a22 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/IsEqualCompressingWhiteSpace.html @@ -0,0 +1,418 @@ + + + + + +IsEqualCompressingWhiteSpace (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualCompressingWhiteSpace

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualCompressingWhiteSpace
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, compressing any changes in whitespace.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualCompressingWhiteSpace

        +
        public IsEqualCompressingWhiteSpace(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stripSpaces

        +
        public java.lang.String stripSpaces(java.lang.String toBeStripped)
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringWhiteSpace

        +
        public static Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString)
        + +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      + + + +
        +
      • +

        equalToCompressingWhiteSpace

        +
        public static Matcher<java.lang.String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
          +
        • all leading and trailing whitespace of both the expectedString and the examined string are ignored
        • +
        • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
        • +
        + For example: +
        assertThat("   my\tfoo  bar ", equalToCompressingWhiteSpace(" my  foo bar"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/IsEqualIgnoringCase.html b/docs/javadoc/2.2/org/hamcrest/text/IsEqualIgnoringCase.html new file mode 100644 index 000000000..85ac7ea8e --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/IsEqualIgnoringCase.html @@ -0,0 +1,378 @@ + + + + + +IsEqualIgnoringCase (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class IsEqualIgnoringCase

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<java.lang.String>, SelfDescribing
    +
    +
    +
    +
    public class IsEqualIgnoringCase
    +extends TypeSafeMatcher<java.lang.String>
    +
    Tests if a string is equal to another string, regardless of the case.
    +
  • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        IsEqualIgnoringCase

        +
        public IsEqualIgnoringCase(java.lang.String string)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        equalToIgnoringCase

        +
        public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
        +
        Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
        assertThat("Foo", equalToIgnoringCase("FOO"))
        +
        +
        Parameters:
        +
        expectedString - the expected value of matched strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/MatchesPattern.html b/docs/javadoc/2.2/org/hamcrest/text/MatchesPattern.html new file mode 100644 index 000000000..e61d31e0f --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/MatchesPattern.html @@ -0,0 +1,365 @@ + + + + + +MatchesPattern (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class MatchesPattern

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MatchesPattern

        +
        public MatchesPattern(java.util.regex.Pattern pattern)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        protected boolean matchesSafely(java.lang.String item)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
        +
      • +
      + + + +
        +
      • +

        matchesPattern

        +
        public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
        +
        Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/StringContainsInOrder.html b/docs/javadoc/2.2/org/hamcrest/text/StringContainsInOrder.html new file mode 100644 index 000000000..5f430ab73 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/StringContainsInOrder.html @@ -0,0 +1,403 @@ + + + + + +StringContainsInOrder (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.text
+

Class StringContainsInOrder

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        StringContainsInOrder

        +
        public StringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(java.lang.String s)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should implement this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeMismatchSafely

        +
        public void describeMismatchSafely(java.lang.String item,
        +                                   Description mismatchDescription)
        +
        Description copied from class: TypeSafeMatcher
        +
        Subclasses should override this. The item will already have been checked for + the specific type and will never be null.
        +
        +
        Overrides:
        +
        describeMismatchSafely in class TypeSafeMatcher<java.lang.String>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> 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, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      + + + +
        +
      • +

        stringContainsInOrder

        +
        public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
        +
        Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        +
        +
        Parameters:
        +
        substrings - the substrings that must be contained within matching strings
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/package-frame.html b/docs/javadoc/2.2/org/hamcrest/text/package-frame.html new file mode 100644 index 000000000..d247098bf --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/package-frame.html @@ -0,0 +1,26 @@ + + + + + +org.hamcrest.text (Hamcrest 2.2 API) + + + + + +

org.hamcrest.text

+ + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/package-summary.html b/docs/javadoc/2.2/org/hamcrest/text/package-summary.html new file mode 100644 index 000000000..f916feead --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/package-summary.html @@ -0,0 +1,181 @@ + + + + + +org.hamcrest.text (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.text

+
+
Matchers that perform text comparisons.
+
+

See: Description

+
+
+ + + + +

Package org.hamcrest.text Description

+

Matchers that perform text comparisons.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/text/package-tree.html b/docs/javadoc/2.2/org/hamcrest/text/package-tree.html new file mode 100644 index 000000000..70c310e68 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/text/package-tree.html @@ -0,0 +1,157 @@ + + + + + +org.hamcrest.text Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.text

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/xml/HasXPath.html b/docs/javadoc/2.2/org/hamcrest/xml/HasXPath.html new file mode 100644 index 000000000..8f44b8aca --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/xml/HasXPath.html @@ -0,0 +1,509 @@ + + + + + +HasXPath (Hamcrest 2.2 API) + + + + + + + + + + + + +
+
org.hamcrest.xml
+

Class HasXPath

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Matcher<org.w3c.dom.Node>, SelfDescribing
    +
    +
    +
    +
    public class HasXPath
    +extends TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
    +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static javax.xml.namespace.NamespaceContextNO_NAMESPACE_CONTEXT 
      +
    • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + +
      Constructors 
      Constructor and Description
      HasXPath(java.lang.String xPathExpression, + Matcher<java.lang.String> valueMatcher) 
      HasXPath(java.lang.String xPathExpression, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) 
      +
    • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voiddescribeTo(Description description) +
      Generates a description of the object.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath) +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
      +
      static Matcher<org.w3c.dom.Node>hasXPath(java.lang.String xPath, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext) +
      Creates a matcher of Nodes 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(java.lang.String xPath, + javax.xml.namespace.NamespaceContext namespaceContext, + Matcher<java.lang.String> valueMatcher) +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
      +
      booleanmatchesSafely(org.w3c.dom.Node item, + Description mismatch) +
      Subclasses should implement this.
      +
      + + +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
      • +
      +
    • +
    +
  • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NO_NAMESPACE_CONTEXT

        +
        public static final javax.xml.namespace.NamespaceContext NO_NAMESPACE_CONTEXT
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      + + + +
        +
      • +

        HasXPath

        +
        public HasXPath(java.lang.String xPathExpression,
        +                javax.xml.namespace.NamespaceContext namespaceContext,
        +                Matcher<java.lang.String> valueMatcher)
        +
        +
        Parameters:
        +
        xPathExpression - XPath expression.
        +
        namespaceContext - Resolves XML namespace prefixes in the XPath expression
        +
        valueMatcher - Matcher to use at given XPath. + May be null to specify that the XPath must exist but the value is irrelevant.
        +
        +
      • +
      +
    • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        matchesSafely

        +
        public boolean matchesSafely(org.w3c.dom.Node item,
        +                             Description mismatch)
        +
        Description copied from class: TypeSafeDiagnosingMatcher
        +
        Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
        +
        +
        Specified by:
        +
        matchesSafely in class TypeSafeDiagnosingMatcher<org.w3c.dom.Node>
        +
        +
      • +
      + + + +
        +
      • +

        describeTo

        +
        public void describeTo(Description description)
        +
        Description copied from interface: SelfDescribing
        +
        Generates a description of the object. The description may be part of a + a description of a larger object of which this is just a component, so it + should be worded appropriately.
        +
        +
        Parameters:
        +
        description - The description to be built or appended to.
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext,
        +                                                 Matcher<java.lang.String> valueMatcher)
        +
        Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        valueMatcher - matcher for the value at the specified xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese"))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        +
      • +
      + + + +
        +
      • +

        hasXPath

        +
        public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath,
        +                                                 javax.xml.namespace.NamespaceContext namespaceContext)
        +
        Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
        assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
        +
        +
        Parameters:
        +
        xPath - the target xpath
        +
        namespaceContext - the namespace for matching nodes
        +
        +
      • +
      +
    • +
    +
  • +
+
+
+ + + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/xml/package-frame.html b/docs/javadoc/2.2/org/hamcrest/xml/package-frame.html new file mode 100644 index 000000000..9f44e09d4 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/xml/package-frame.html @@ -0,0 +1,20 @@ + + + + + +org.hamcrest.xml (Hamcrest 2.2 API) + + + + + +

org.hamcrest.xml

+
+

Classes

+ +
+ + diff --git a/docs/javadoc/2.2/org/hamcrest/xml/package-summary.html b/docs/javadoc/2.2/org/hamcrest/xml/package-summary.html new file mode 100644 index 000000000..2ddddabb3 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/xml/package-summary.html @@ -0,0 +1,151 @@ + + + + + +org.hamcrest.xml (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Package org.hamcrest.xml

+
+
Matchers of XML documents.
+
+

See: Description

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    HasXPath +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
    +
  • +
+ + + +

Package org.hamcrest.xml Description

+

Matchers of XML documents.

+
+ + + + + + diff --git a/docs/javadoc/2.2/org/hamcrest/xml/package-tree.html b/docs/javadoc/2.2/org/hamcrest/xml/package-tree.html new file mode 100644 index 000000000..6341509a9 --- /dev/null +++ b/docs/javadoc/2.2/org/hamcrest/xml/package-tree.html @@ -0,0 +1,143 @@ + + + + + +org.hamcrest.xml Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + + + + +
+

Hierarchy For Package org.hamcrest.xml

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ + + + + + diff --git a/docs/javadoc/2.2/overview-frame.html b/docs/javadoc/2.2/overview-frame.html new file mode 100644 index 000000000..55f053681 --- /dev/null +++ b/docs/javadoc/2.2/overview-frame.html @@ -0,0 +1,31 @@ + + + + + +Overview List (Hamcrest 2.2 API) + + + + + + + +

 

+ + diff --git a/docs/javadoc/2.2/overview-summary.html b/docs/javadoc/2.2/overview-summary.html new file mode 100644 index 000000000..805b3a515 --- /dev/null +++ b/docs/javadoc/2.2/overview-summary.html @@ -0,0 +1,190 @@ + + + + + +Overview (Hamcrest 2.2 API) + + + + + + + + +
+ + + + + + + +
+ + +
+

Hamcrest 2.2 API

+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Packages 
PackageDescription
org.hamcrest 
org.hamcrest.beans +
Matchers of Java Bean properties and their values.
+
org.hamcrest.collection +
Matchers of arrays and collections.
+
org.hamcrest.comparator 
org.hamcrest.core +
Fundamental matchers of objects and values, and composite matchers.
+
org.hamcrest.internal 
org.hamcrest.io 
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.
+
+
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.2/overview-tree.html b/docs/javadoc/2.2/overview-tree.html new file mode 100644 index 000000000..f65d6d0ef --- /dev/null +++ b/docs/javadoc/2.2/overview-tree.html @@ -0,0 +1,255 @@ + + + + + +Class Hierarchy (Hamcrest 2.2 API) + + + + + + + + +
+ + + + + + + +
+ + + +
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + + + + + + +
+ + + + diff --git a/docs/javadoc/2.2/package-list b/docs/javadoc/2.2/package-list new file mode 100644 index 000000000..37d7af536 --- /dev/null +++ b/docs/javadoc/2.2/package-list @@ -0,0 +1,11 @@ +org.hamcrest +org.hamcrest.beans +org.hamcrest.collection +org.hamcrest.comparator +org.hamcrest.core +org.hamcrest.internal +org.hamcrest.io +org.hamcrest.number +org.hamcrest.object +org.hamcrest.text +org.hamcrest.xml diff --git a/docs/javadoc/2.2/script.js b/docs/javadoc/2.2/script.js new file mode 100644 index 000000000..b34635693 --- /dev/null +++ b/docs/javadoc/2.2/script.js @@ -0,0 +1,30 @@ +function show(type) +{ + count = 0; + for (var key in methods) { + var row = document.getElementById(key); + if ((methods[key] & type) != 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) +{ + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} diff --git a/docs/javadoc/2.2/stylesheet.css b/docs/javadoc/2.2/stylesheet.css new file mode 100644 index 000000000..98055b22d --- /dev/null +++ b/docs/javadoc/2.2/stylesheet.css @@ -0,0 +1,574 @@ +/* Javadoc style sheet */ +/* +Overall document style +*/ + +@import url('resources/fonts/dejavu.css'); + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a:hover, a:focus { + text-decoration:none; + color:#bb7a2a; +} +a:active { + text-decoration:none; + color:#4A6782; +} +a[name] { + color:#353833; +} +a[name]:hover { + text-decoration:none; + color:#353833; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} +/* +Document title and Copyright styles +*/ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* +Navigation bar styles +*/ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.subNavList li{ + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* +Page header and footer styles +*/ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexHeader { + margin:10px; + position:relative; +} +.indexHeader span{ + margin-right:15px; +} +.indexHeader h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* +Heading styles +*/ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* +Page layout container styles +*/ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Sans Mono',monospace; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* +List styles +*/ +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* +Table styles +*/ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary { + width:100%; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited { + color:#FFFFFF; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; + +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th, +td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{ + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colLast, th.colOne, .constantsSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + white-space:nowrap; + font-size:13px; +} +td.colLast, th.colLast { + font-size:13px; +} +td.colOne, th.colOne { + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.useSummary td.colFirst, .useSummary th.colFirst, +.overviewSummary td.colOne, .overviewSummary th.colOne, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colOne, .memberSummary th.colOne, +.typeSummary td.colFirst{ + width:25%; + vertical-align:top; +} +td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor { + background-color:#FFFFFF; +} +.rowColor { + background-color:#EEEEEF; +} +/* +Content styles +*/ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} + +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} + +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} + +td.colLast div { + padding-top:0px; +} + + +td.colLast a { + padding-bottom:3px; +} +/* +Formatting effect styles +*/ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink, +.overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel, +.seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} + +div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} + +div.contentContainer ul.blockList li.blockList h2{ + padding-bottom:0px; +} diff --git a/docs/javadoc/3.0/allclasses-index.html b/docs/javadoc/3.0/allclasses-index.html new file mode 100644 index 000000000..48f667013 --- /dev/null +++ b/docs/javadoc/3.0/allclasses-index.html @@ -0,0 +1,394 @@ + + + + +All Classes and Interfaces (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

All Classes and Interfaces

+
+
+
+
+
+
Class
+
Description
+ +
+
Calculates the logical conjunction of multiple matchers.
+
+ +
+
Calculates the logical disjunction of multiple matchers.
+
+ +
+
A matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+ +
+
Collected helper code for converting matchers between lists and iterables.
+
+ +
+
A Description that is stored as a string.
+
+ +
+
BaseClass for all Matcher implementations.
+
+ +
+
A matcher that checks a BigDecimal is close to an expected value.
+
+ +
+
A Matcher that checks the length of a string.
+
+ +
+
Allows matchers of the same type to be combined using + either/or, or + both/and.
+
+ +
+
Allows syntactic sugar of using both and and.
+
+ +
+
Allows syntactic sugar of using either and or.
+
+ +
+
Builder for matchers that allow matchers to use a corresponding Compartor
+
+ +
+
A Condition implements part of a multi-step match.
+
+ +
+
Represents a single step in a multi-step sequence
+
+ +
+
Builder methods for various matchers.
+
+ +
+
Utility class for writing one off matchers.
+
+ +
+
Utility class for writing one off matchers (with type safety and null checks).
+
+ +
+
Provides a custom description to another matcher.
+
+ +
+
A description of a Matcher.
+
+ +
+
A description that consumes input but does nothing.
+
+ +
+
Convenient base class for Matchers of a specific type and that will report why the + received value has been rejected.
+
+ +
+
A matcher that applies a delegate matcher to every item in an Iterable.
+
+ +
+
Supporting class for matching a feature of an object.
+
+ +
+
Matchers for properties of files.
+
+ +
+
Checks the status of a File.
+
+ +
+
A matcher that checks if an object as equal fields values to an expected object.
+
+ +
+
Matches if an array contains an item satisfying a nested matcher.
+
+ +
+
A matcher that checks if an object has a JavaBean property with the + specified name.
+
+ +
+
A matcher that checks if an object has a JavaBean property with the + specified name and an expected value.
+
+ +
+
A Matcher that checks the output of the toString() method.
+
+ +
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+ +
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+
+ +
+
A matcher that always returns true.
+
+ +
+
Matcher for array whose elements satisfy a sequence of matchers.
+
+ +
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+ +
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+ +
+
Matches if array size satisfies a size matcher.
+
+ +
+
Matches blank Strings (and null).
+
+ +
+
Is the value a number equal to a value within some range of acceptable error?
+
+ +
Deprecated. +
As of release 2.1, replaced by IsIterableContaining.
+
+ +
+
Matches if collection size satisfies a nested matcher.
+
+ +
+
A matcher of Class that matches when the specified baseType is assignable from the examined class.
+
+ +
+
Tests if a collection is empty.
+
+ +
+
Tests if an iterable is empty.
+
+ +
+
Matches empty Strings (and null).
+
+ +
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) method.
+
+ +
+
Tests if a string is equal to another string, compressing any changes in whitespace.
+
+ +
+
Tests if a string is equal to another string, regardless of the case.
+
+ +
+
Tests if the value is an event announced by a specific object.
+
+ +
+
Tests if a collection contains a matching object.
+
+ +
+
Tests whether the value is an instance of a class.
+
+ +
+
Tests if an iterable contains matching elements.
+
+ +
+
Tests if an iterable contains matching elements in any order.
+
+ +
+
Tests if an iterable contains matching elements in order.
+
+ +
+
Tests if an iterable contains matching elements in relative order.
+
+ +
+
Matches if iterable size satisfies a size matcher.
+
+ +
+
Matches if map keys, values or entries match the value matchers.
+
+ +
+
Matches if map size satisfies a nested matcher.
+
+ +
+
Is the value a number actually not a number (NaN)?
+
+ +
+
Calculates the logical negation of a matcher.
+
+ +
+
Is the value null?
+
+ +
+
Is the value the same object as another value?
+
+ +
+
+ A matcher over acceptable values.
+
+ +
+
The Hamcrest entrypoint, static methods to check if matchers match a + given value.
+
+ +
+
Builder methods for various matchers.
+
+ +
+
Tests if a string matches a regular expression.
+
+ +
+
Static methods for building ordering comparisons.
+
+ +
+
Utility class with static methods for accessing properties on JavaBean objects.
+
+ +
+
A matcher that checks if a given bean has the same property values + as an example bean.
+
+ +
+
The ability of an object to describe itself.
+
+ +
+
Tests if the argument is a string that contains a specific substring.
+
+ +
+
Tests if a string contains the given substrings in order.
+
+ +
+
A Description that is stored as a string.
+
+ +
+
Tests if the argument is a string that ends with a specific substring.
+
+ +
+
A matcher that checks a string against a regular expression.
+
+ +
+
Tests if the argument is a string that starts with a specific substring.
+
+ +
+
Common behaviour for matchers that check substrings.
+
+ +
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+
+ +
+
Convenient base class for Matchers that require a non-null value of a specific type.
+
+
+
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/allpackages-index.html b/docs/javadoc/3.0/allpackages-index.html new file mode 100644 index 000000000..c468a0683 --- /dev/null +++ b/docs/javadoc/3.0/allpackages-index.html @@ -0,0 +1,102 @@ + + + + +All Packages (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

All Packages

+
+
Package Summary
+
+
Package
+
Description
+ +
+
Top level matcher classes and interfaces.
+
+ +
+
Matchers of Java Bean properties and their values.
+
+ +
+
Matchers of arrays and collections.
+
+ +
+
Helper classes for building matcher comparators.
+
+ +
+
Fundamental matchers of objects and values, and composite matchers.
+
+ +
+
Matchers that perform file comparisons.
+
+ +
+
Matchers that perform numeric comparisons.
+
+ +
+
Matchers that inspect objects and classes.
+
+ +
+
Matchers that perform text comparisons.
+
+ +
+
Matchers of XML documents.
+
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/copy.svg b/docs/javadoc/3.0/copy.svg new file mode 100644 index 000000000..7c46ab15f --- /dev/null +++ b/docs/javadoc/3.0/copy.svg @@ -0,0 +1,33 @@ + + + + + + + + diff --git a/docs/javadoc/3.0/deprecated-list.html b/docs/javadoc/3.0/deprecated-list.html new file mode 100644 index 000000000..a384cc076 --- /dev/null +++ b/docs/javadoc/3.0/deprecated-list.html @@ -0,0 +1,204 @@ + + + + +Deprecated List (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Deprecated API

+
+

Contents

+ + + + +
+
+
+ + diff --git a/docs/javadoc/3.0/element-list b/docs/javadoc/3.0/element-list new file mode 100644 index 000000000..5b86331ac --- /dev/null +++ b/docs/javadoc/3.0/element-list @@ -0,0 +1,10 @@ +org.hamcrest +org.hamcrest.beans +org.hamcrest.collection +org.hamcrest.comparator +org.hamcrest.core +org.hamcrest.io +org.hamcrest.number +org.hamcrest.object +org.hamcrest.text +org.hamcrest.xml diff --git a/docs/javadoc/3.0/help-doc.html b/docs/javadoc/3.0/help-doc.html new file mode 100644 index 000000000..c52c7b9c7 --- /dev/null +++ b/docs/javadoc/3.0/help-doc.html @@ -0,0 +1,188 @@ + + + + +API Help (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+

JavaDoc Help

+ +
+
+

Navigation

+Starting from the Overview page, you can browse the documentation using the links in each page, and in the navigation bar at the top of each page. The Index and Search box allow you to navigate to specific declarations and summary pages, including: All Packages, All Classes and Interfaces + +
+
+
+

Kinds of Pages

+The following sections describe the different kinds of pages in this collection. +
+

Overview

+

The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

+
+
+

Package

+

Each package has a page that contains a list of its classes and interfaces, with a summary for each. These pages may contain the following categories:

+
    +
  • Interfaces
  • +
  • Classes
  • +
  • Enum Classes
  • +
  • Exception Classes
  • +
  • Annotation Interfaces
  • +
+
+
+

Class or Interface

+

Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a declaration and description, member summary tables, and detailed member descriptions. Entries in each of these sections are omitted if they are empty or not applicable.

+
    +
  • Class Inheritance Diagram
  • +
  • Direct Subclasses
  • +
  • All Known Subinterfaces
  • +
  • All Known Implementing Classes
  • +
  • Class or Interface Declaration
  • +
  • Class or Interface Description
  • +
+
+
    +
  • Nested Class Summary
  • +
  • Enum Constant Summary
  • +
  • Field Summary
  • +
  • Property Summary
  • +
  • Constructor Summary
  • +
  • Method Summary
  • +
  • Required Element Summary
  • +
  • Optional Element Summary
  • +
+
+
    +
  • Enum Constant Details
  • +
  • Field Details
  • +
  • Property Details
  • +
  • Constructor Details
  • +
  • Method Details
  • +
  • Element Details
  • +
+

Note: Annotation interfaces have required and optional elements, but not methods. Only enum classes have enum constants. The components of a record class are displayed as part of the declaration of the record class. Properties are a feature of JavaFX.

+

The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.

+
+
+

Other Files

+

Packages and modules may contain pages with additional information related to the declarations nearby.

+
+
+

Tree (Class Hierarchy)

+

There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. Classes are organized by inheritance structure starting with java.lang.Object. Interfaces do not inherit from java.lang.Object.

+
    +
  • When viewing the Overview page, clicking on TREE displays the hierarchy for all packages.
  • +
  • When viewing a particular package, class or interface page, clicking on TREE displays the hierarchy for only that package.
  • +
+
+
+

Deprecated API

+

The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to shortcomings, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.

+
+
+

All Packages

+

The All Packages page contains an alphabetic index of all packages contained in the documentation.

+
+
+

All Classes and Interfaces

+

The All Classes and Interfaces page contains an alphabetic index of all classes and interfaces contained in the documentation, including annotation interfaces, enum classes, and record classes.

+
+
+

Index

+

The Index contains an alphabetic index of all classes, interfaces, constructors, methods, and fields in the documentation, as well as summary pages such as All Packages, All Classes and Interfaces.

+
+
+
+This help file applies to API documentation generated by the standard doclet.
+
+
+ + diff --git a/docs/javadoc/3.0/index-all.html b/docs/javadoc/3.0/index-all.html new file mode 100644 index 000000000..36bfefbde --- /dev/null +++ b/docs/javadoc/3.0/index-all.html @@ -0,0 +1,2934 @@ + + + + +Index (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Index

+
+A B C D E F G H I L M N O P S T U _ 
All Classes and Interfaces|All Packages +

A

+
+
aFileNamed(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file name matches an expected name.
+
+
aFileWithAbsolutePath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file absolute path matches an expected path.
+
+
aFileWithCanonicalPath(Matcher<String>) - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file canonical path matches an expected path.
+
+
aFileWithSize(long) - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file has a specific size.
+
+
aFileWithSize(Matcher<Long>) - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file size matches an expected size.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AllOf
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
allOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ALL of the specified matchers.
+
+
AllOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical conjunction of multiple matchers.
+
+
AllOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AllOf
+
+
Constructor, best called from AllOf.allOf(Iterable).
+
+
AllOf(Matcher<? super T>...) - Constructor for class org.hamcrest.core.AllOf
+
+
Constructor, best called from AllOf.allOf(Matcher[]).
+
+
aMapWithSize(int) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
aMapWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
aMapWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
and(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
+
Applies the mapping to the current value in the sequence
+
+
and(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
+
Specify the second matcher in a CombinableMatcher pair.
+
+
and(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
+
Specify the second matcher in a CombinableMatcher pair.
+
+
anEmptyMap() - Static method in class org.hamcrest.collection.IsMapWithSize
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anEmptyMap() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps that matches when the size() method returns + zero.
+
+
anExistingDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a directory exists.
+
+
anExistingFile() - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file exists.
+
+
anExistingFileOrDirectory() - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file or directory exists.
+
+
any(Class<T>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
any(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
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 + examined object.
+
+
any(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
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 + examined object.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Iterable<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.core.AnyOf
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
anyOf(Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>, Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined object matches ANY of the specified matchers.
+
+
AnyOf<T> - Class in org.hamcrest.core
+
+
Calculates the logical disjunction of multiple matchers.
+
+
AnyOf(Iterable<Matcher<? super T>>) - Constructor for class org.hamcrest.core.AnyOf
+
+
Constructor, best called from AnyOf.anyOf(Iterable).
+
+
AnyOf(Matcher<? super T>...) - Constructor for class org.hamcrest.core.AnyOf
+
+
Constructor, best called from AnyOf.anyOf(Matcher[]).
+
+
anything() - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object.
+
+
anything(String) - Static method in class org.hamcrest.core.IsAnything
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
anything(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
+
+
append(char) - Method in class org.hamcrest.BaseDescription
+
+
Append the char c to the description.
+
+
append(char) - Method in class org.hamcrest.StringDescription
+
 
+
append(String) - Method in class org.hamcrest.BaseDescription
+
+
Append the String str to the description.
+
+
append(String) - Method in class org.hamcrest.StringDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.BaseDescription
+
 
+
appendDescriptionOf(SelfDescribing) - Method in interface org.hamcrest.Description
+
+
Appends the description of a SelfDescribing value to this description.
+
+
appendDescriptionOf(SelfDescribing) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in interface org.hamcrest.Description
+
+
Appends a list of SelfDescribing objects + to the description.
+
+
appendList(String, String, String, Iterable<? extends SelfDescribing>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendText(String) - Method in class org.hamcrest.BaseDescription
+
 
+
appendText(String) - Method in interface org.hamcrest.Description
+
+
Appends some plain text to the description.
+
+
appendText(String) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValue(Object) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValue(Object) - Method in interface org.hamcrest.Description
+
+
Appends an arbitrary value to the description.
+
+
appendValue(Object) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, Iterable<T>) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, Iterable<T>) - Method in class org.hamcrest.Description.NullDescription
+
 
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.BaseDescription
+
 
+
appendValueList(String, String, String, T...) - Method in interface org.hamcrest.Description
+
+
Appends a list of values to the description.
+
+
appendValueList(String, String, String, T...) - Method in class org.hamcrest.Description.NullDescription
+
 
+
apply(I, Description) - Method in interface org.hamcrest.Condition.Step
+
+
Apply this condition to a value
+
+
aReadableFile() - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a file is readable.
+
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsArray
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
array(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
+
+
ArrayAsIterableMatcher<E> - Class in org.hamcrest.collection
+
+
A matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher<Iterable<? extends E>>, Collection<Matcher<? super E>>, String) - Constructor for class org.hamcrest.collection.ArrayAsIterableMatcher
+
+ +
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. +
As of version 2.1, use ArrayMatching.arrayContaining(List).
+
+
+
arrayContaining(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated. + +
+
+
arrayContaining(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
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.
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ 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.
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
+ 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.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated. + +
+
+
arrayContainingInAnyOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers.
+
+
ArrayMatching - Class in org.hamcrest.collection
+
+
Collected helper code for converting matchers between lists and iterables.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
arrayWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + equals the specified size.
+
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
arrayWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
+
+
asEqualMatchers(E[]) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Converts item array to corresponding array of equalTo matchers
+
+
assertThat(String, boolean) - Static method in class org.hamcrest.MatcherAssert
+
+
Checks that an assertion is true
+
+
assertThat(String, T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
+
Checks that a value matches a matcher
+
+
assertThat(T, Matcher<? super T>) - Static method in class org.hamcrest.MatcherAssert
+
+
Checks that a value matches a matcher
+
+
asString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+ +
+
aWritableFile() - Static method in class org.hamcrest.io.FileMatchers
+
+
A matcher that checks if a directory is writable.
+
+
+

B

+
+
BaseDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
BaseDescription() - Constructor for class org.hamcrest.BaseDescription
+
+
Default constructor
+
+
BaseMatcher<T> - Class in org.hamcrest
+
+
BaseClass for all Matcher implementations.
+
+
BaseMatcher() - Constructor for class org.hamcrest.BaseMatcher
+
+
Default constructor.
+
+
BigDecimalCloseTo - Class in org.hamcrest.number
+
+
A matcher that checks a BigDecimal is close to an expected value.
+
+
BigDecimalCloseTo(BigDecimal, BigDecimal) - Constructor for class org.hamcrest.number.BigDecimalCloseTo
+
+ +
+
blankOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankOrNullString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
blankString() - Static method in class org.hamcrest.text.IsBlankString
+
+
Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
both(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when both of the specified matchers match the examined object.
+
+
+

C

+
+
CAN_READ - Static variable in class org.hamcrest.io.FileMatchers
+
+
Checks if a File is readable.
+
+
CAN_WRITE - Static variable in class org.hamcrest.io.FileMatchers
+
+
Checks if a File is writable.
+
+
CharSequenceLength - Class in org.hamcrest.text
+
+
A Matcher that checks the length of a string.
+
+
CharSequenceLength(Matcher<? super Integer>) - Constructor for class org.hamcrest.text.CharSequenceLength
+
+
Constructor, best called from CharSequenceLength.hasLength(Matcher).
+
+
check(File) - Method in interface org.hamcrest.io.FileMatchers.FileStatus
+
+
Checks the give file against a status.
+
+
closeTo(double, double) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(double, double) - Static method in class org.hamcrest.number.IsCloseTo
+
+
Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
closeTo(BigDecimal, BigDecimal) - Static method in class org.hamcrest.number.BigDecimalCloseTo
+
+
Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
+
+
CombinableBothMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableBothMatcher
+
+
Constructor, best called from CombinableMatcher.both(Matcher).
+
+
CombinableEitherMatcher(Matcher<? super X>) - Constructor for class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
+
Constructor, best called from CombinableMatcher.either(Matcher)
+
+
CombinableMatcher<T> - Class in org.hamcrest.core
+
+
Allows matchers of the same type to be combined using + either/or, or + both/and.
+
+
CombinableMatcher(Matcher<? super T>) - Constructor for class org.hamcrest.core.CombinableMatcher
+
+
Constructor, best called from either or both.
+
+
CombinableMatcher.CombinableBothMatcher<X> - Class in org.hamcrest.core
+
+
Allows syntactic sugar of using both and and.
+
+
CombinableMatcher.CombinableEitherMatcher<X> - Class in org.hamcrest.core
+
+
Allows syntactic sugar of using either and or.
+
+
ComparatorMatcherBuilder<T> - Class in org.hamcrest.comparator
+
+
Builder for matchers that allow matchers to use a corresponding Compartor
+
+
comparedBy(Comparator<T>) - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparatorss of T.
+
+
comparesEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
comparesEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
Condition<T> - Class in org.hamcrest
+
+
A Condition implements part of a multi-step match.
+
+
Condition.Step<I,O> - Interface in org.hamcrest
+
+
Represents a single step in a multi-step sequence
+
+
contains(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables 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.
+
+
contains(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
contains(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Collection<Matcher<? super T>>) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInAnyOrder(T...) - Static method in class org.hamcrest.Matchers
+
+
+ Creates an order agnostic matcher for Iterables 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.
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(E...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsInRelativeOrder(List<Matcher<? super E>>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsInRelativeOrder(Matcher<? super E>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
+
+
containsString(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.core.StringContains
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
containsStringIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
+
+
converted(String) - Method in class org.hamcrest.core.SubstringMatcher
+
+
Helper method to allow subclasses to handle case insensitivity.
+
+
CoreMatchers - Class in org.hamcrest
+
+
Builder methods for various matchers.
+
+
CustomMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers.
+
+
CustomMatcher(String) - Constructor for class org.hamcrest.CustomMatcher
+
+
Constructor
+
+
CustomTypeSafeMatcher<T> - Class in org.hamcrest
+
+
Utility class for writing one off matchers (with type safety and null checks).
+
+
CustomTypeSafeMatcher(String) - Constructor for class org.hamcrest.CustomTypeSafeMatcher
+
+
Constructor
+
+
+

D

+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.core.DescribedAs
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.CoreMatchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
describedAs(String, Matcher<T>, Object...) - Static method in class org.hamcrest.Matchers
+
+
Wraps an existing matcher, overriding its description with that specified.
+
+
DescribedAs<T> - Class in org.hamcrest.core
+
+
Provides a custom description to another matcher.
+
+
DescribedAs(String, Matcher<T>, Object[]) - Constructor for class org.hamcrest.core.DescribedAs
+
+ +
+
describeMismatch(Object, Description) - Method in class org.hamcrest.BaseMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.core.Is
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in interface org.hamcrest.Matcher
+
+
Generate a description of why the matcher has not accepted the item.
+
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
describeMismatch(Object, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeMismatchSafely(E[], Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeMismatchSafely(Class<?>, Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeMismatchSafely(Double, Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeMismatchSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeMismatchSafely(String, Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeMismatchSafely(BigDecimal, Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeMismatchSafely(Collection<? extends E>, Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeMismatchSafely(Map<? extends K, ? extends V>, Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeMismatchSafely(T[], Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeMismatchSafely(T, Description) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Describe the mismatch.
+
+
describeTo(Description) - Method in class org.hamcrest.beans.HasProperty
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
describeTo(Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArray
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIn
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AllOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.AnyOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.DescribedAs
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Every
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.Is
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsAnything
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
describeTo(Description) - Method in class org.hamcrest.core.IsEqual
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNot
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsNull
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.IsSame
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
describeTo(Description) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.CustomTypeSafeMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
describeTo(Description) - Method in class org.hamcrest.number.IsNaN
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
describeTo(Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
describeTo(Description) - Method in interface org.hamcrest.SelfDescribing
+
+
Generates a description of the object.
+
+
describeTo(Description) - Method in class org.hamcrest.text.IsBlankString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
describeTo(Description) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
describeTo(Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
describeTo(Description, String) - Method in class org.hamcrest.core.AnyOf
+
+
Describe this matcher to description
+
+
Description - Interface in org.hamcrest
+
+
A description of a Matcher.
+
+
Description.NullDescription - Class in org.hamcrest
+
+
A description that consumes input but does nothing.
+
+
descriptionEnd() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that ends the description.
+
+
descriptionSeparator() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that separates the elements in the description.
+
+
descriptionStart() - Method in class org.hamcrest.collection.IsArray
+
+
Returns the string that starts the description.
+
+
DiagnosingMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers of a specific type and that will report why the + received value has been rejected.
+
+
DiagnosingMatcher() - Constructor for class org.hamcrest.DiagnosingMatcher
+
+
Constructor
+
+
+

E

+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.core.CombinableMatcher
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
either(Matcher<? super LHS>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when either of the specified matchers match the examined object.
+
+
empty() - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
empty() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyArray() - Static method in class org.hamcrest.collection.IsArrayWithSize
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyArray() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the length of the array + is zero.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyCollection
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyCollectionOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
+
+
emptyIterable() - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterable() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.collection.IsEmptyIterable
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyIterableOf(Class<E>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables matching examined iterables that yield no items.
+
+
emptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string is null, or + has zero length.
+
+
emptyString() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
emptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Creates a matcher of String that matches when the examined string has zero length.
+
+
endsWith(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWith(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringEndsWith
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
endsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
+
+
equalTo(T) - Static method in class org.hamcrest.core.IsEqual
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
equalTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToCompressingWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, when whitespace differences are (mostly) ignored.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringCase(String) - Static method in class org.hamcrest.text.IsEqualIgnoringCase
+
+
Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
+
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.Matchers
+
+ +
+
equalToIgnoringWhiteSpace(String) - Static method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+ +
+
equalToObject(Object) - Static method in class org.hamcrest.core.IsEqual
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
equalToObject(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
+
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringContains
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringEndsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.StringStartsWith
+
 
+
evalSubstringOf(String) - Method in class org.hamcrest.core.SubstringMatcher
+
+
Checks if the input matches the specific substring.
+
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Class<? extends EventObject>, Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
eventFrom(Object) - Static method in class org.hamcrest.object.IsEventFrom
+
+
Creates a matcher of EventObject that matches any EventObject + announced by source.
+
+
Every<T> - Class in org.hamcrest.core
+
+
A matcher that applies a delegate matcher to every item in an Iterable.
+
+
Every(Matcher<? super T>) - Constructor for class org.hamcrest.core.Every
+
+
Constructor, best called from Every.everyItem(Matcher).
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.core.Every
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
everyItem(Matcher<U>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
+
+
Example Usage - Search tag in class org.hamcrest.beans.HasPropertyWithValue
+
Section
+
EXISTS - Static variable in class org.hamcrest.io.FileMatchers
+
+
Checks if a File is a exists.
+
+
+

F

+
+
FeatureMatcher<T,U> - Class in org.hamcrest
+
+
Supporting class for matching a feature of an object.
+
+
FeatureMatcher(Matcher<? super U>, String, String) - Constructor for class org.hamcrest.FeatureMatcher
+
+
Constructor
+
+
featureValueOf(E[]) - Method in class org.hamcrest.collection.IsArrayWithSize
+
 
+
featureValueOf(CharSequence) - Method in class org.hamcrest.text.CharSequenceLength
+
 
+
featureValueOf(Iterable<E>) - Method in class org.hamcrest.collection.IsIterableWithSize
+
 
+
featureValueOf(Collection<? extends E>) - Method in class org.hamcrest.collection.IsCollectionWithSize
+
 
+
featureValueOf(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapWithSize
+
 
+
featureValueOf(T) - Method in class org.hamcrest.FeatureMatcher
+
+
Implement this to extract the interesting feature.
+
+
featureValueOf(T) - Method in class org.hamcrest.object.HasToString
+
 
+
FileMatchers - Class in org.hamcrest.io
+
+
Matchers for properties of files.
+
+
FileMatchers.FileStatus - Interface in org.hamcrest.io
+
+
Checks the status of a File.
+
+
+

G

+
+
getPropertyDescriptor(String, Object) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns the description of the property with the provided + name on the provided object's interface.
+
+
getString() - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
Gets the string
+
+
greaterThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
greaterThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
greaterThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+

H

+
+
hasEntry(K, V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasEntry(K, V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value.
+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
hasEntry(Matcher<? super K>, Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
+
+
HasEqualValues<T> - Class in org.hamcrest.object
+
+
A matcher that checks if an object as equal fields values to an expected object.
+
+
HasEqualValues(T) - Constructor for class org.hamcrest.object.HasEqualValues
+
+
Constructor
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher.
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. +
As of version 2.1, use IsIterableContaining.hasItem(Object).
+
+
+
hasItem(T) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItem(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item.
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(Matcher<? super T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for arrays that matches when the examined array contains at least one item + that is matched by the specified elementMatcher.
+
+
hasItemInArray(T) - Static method in class org.hamcrest.collection.ArrayMatching
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
hasItemInArray(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used hasItemInArray(equalTo(x)).
+
+
HasItemInArray<T> - Class in org.hamcrest.collection
+
+
Matches if an array contains an item satisfying a nested matcher.
+
+
HasItemInArray(Matcher<? super T>) - Constructor for class org.hamcrest.collection.HasItemInArray
+
+
Constructor, best called from ArrayMatching.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(Matcher<? super T>...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated. + +
+
+
hasItems(T...) - Static method in class org.hamcrest.core.IsIterableContaining
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher for Iterables 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.
+
+
hasItems(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables 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.
+
+
hasKey(K) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasKey(K) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasKey(Matcher<? super K>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
+
+
hasLength(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
+
+
hasLength(int) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasLength(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of CharSequence that matches when a char sequence has the length + that satisfies the specified matcher.
+
+
hasLength(Matcher<? super Integer>) - Static method in class org.hamcrest.text.CharSequenceLength
+
+
Creates a matcher of CharSequence that matches when a char sequence has the given length + For example:
+
+
hasProperty(String) - Static method in class org.hamcrest.beans.HasProperty
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
hasProperty(String, Matcher<?>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object has a JavaBean property + with the specified name whose value satisfies the specified matcher.
+
+
HasProperty<T> - Class in org.hamcrest.beans
+
+
A matcher that checks if an object has a JavaBean property with the + specified name.
+
+
HasProperty(String) - Constructor for class org.hamcrest.beans.HasProperty
+
+
Constructor, best called from HasProperty.hasProperty(String).
+
+
hasPropertyAtPath(String, Matcher<T>) - Static method in class org.hamcrest.beans.HasPropertyWithValue
+
+
Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher.
+
+
HasPropertyWithValue<T> - Class in org.hamcrest.beans
+
+
A matcher that checks if an object has a JavaBean property with the + specified name and an expected value.
+
+
HasPropertyWithValue(String, Matcher<?>) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
+ +
+
HasPropertyWithValue(String, Matcher<?>, String) - Constructor for class org.hamcrest.beans.HasPropertyWithValue
+
+ +
+
hasSize(int) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
+
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsCollectionWithSize
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
+
+
hasToString(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
hasToString(String) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
+
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
hasToString(Matcher<? super String>) - Static method in class org.hamcrest.object.HasToString
+
+
Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
+
+
HasToString<T> - Class in org.hamcrest.object
+
+
A Matcher that checks the output of the toString() method.
+
+
HasToString(Matcher<? super String>) - Constructor for class org.hamcrest.object.HasToString
+
+ +
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(Matcher<? super V>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
+
+
hasValue(V) - Static method in class org.hamcrest.collection.IsMapContaining
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasValue(V) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
+
+
hasXPath(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
hasXPath(String, NamespaceContext) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String, NamespaceContext, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
+
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
hasXPath(String, Matcher<String>) - Static method in class org.hamcrest.xml.HasXPath
+
+
Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
+
+
HasXPath - Class in org.hamcrest.xml
+
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+
HasXPath(String, NamespaceContext, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
+
Constructor, best called from one of the hasXPath static factory methods.
+
+
HasXPath(String, Matcher<String>) - Constructor for class org.hamcrest.xml.HasXPath
+
+
Constructor, best called from one of the hasXPath static factory methods.
+
+
+

I

+
+
in(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified collection.
+
+
in(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
in(T[]) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is found within the + specified array.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.core.IsInstanceOf
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.CoreMatchers
+
+
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.
+
+
instanceOf(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
is(Matcher<T>) - Static method in class org.hamcrest.core.Is
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
+
+
is(T) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
is(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(equalTo(x)).
+
+
Is<T> - Class in org.hamcrest.core
+
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
+
+
Is(Matcher<T>) - Constructor for class org.hamcrest.core.Is
+
+
Constructor, best called from Is.is(Object), Is.is(Matcher), or Is.isA(Class).
+
+
IS_DIRECTORY - Static variable in class org.hamcrest.io.FileMatchers
+
+
Checks if a File is a directory.
+
+
IS_FILE - Static variable in class org.hamcrest.io.FileMatchers
+
+
Checks if a File is a file.
+
+
isA(Class<?>) - Static method in class org.hamcrest.core.Is
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<?>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
isA(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used is(instanceOf(SomeClass.class)).
+
+
IsAnything<T> - Class in org.hamcrest.core
+
+
A matcher that always returns true.
+
+
IsAnything() - Constructor for class org.hamcrest.core.IsAnything
+
+
Constructor, best called from IsAnything.anything().
+
+
IsAnything(String) - Constructor for class org.hamcrest.core.IsAnything
+
+
Constructor, best called from IsAnything.anything(String).
+
+
IsArray<T> - Class in org.hamcrest.collection
+
+
Matcher for array whose elements satisfy a sequence of matchers.
+
+
IsArray(Matcher<? super T>[]) - Constructor for class org.hamcrest.collection.IsArray
+
+
Constructor, best called from IsArray.array(Matcher[]).
+
+
IsArrayContainingInAnyOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInAnyOrder(Collection<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+ +
+
IsArrayContainingInOrder<E> - Class in org.hamcrest.collection
+
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
IsArrayContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+ +
+
IsArrayWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if array size satisfies a size matcher.
+
+
IsArrayWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsArrayWithSize
+
+ +
+
IsBlankString - Class in org.hamcrest.text
+
+
Matches blank Strings (and null).
+
+
IsCloseTo - Class in org.hamcrest.number
+
+
Is the value a number equal to a value within some range of acceptable error?
+
+
IsCloseTo(double, double) - Constructor for class org.hamcrest.number.IsCloseTo
+
+
Constructor, best called from IsCloseTo.closeTo(double, double).
+
+
IsCollectionContaining<T> - Class in org.hamcrest.core
+
+
Deprecated. +
As of release 2.1, replaced by IsIterableContaining.
+
+
+
IsCollectionContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
Constructor, best called from one of the static factory methods.
+
+
IsCollectionWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if collection size satisfies a nested matcher.
+
+
IsCollectionWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsCollectionWithSize
+
+ +
+
IsCompatibleType<T> - Class in org.hamcrest.object
+
+
A matcher of Class that matches when the specified baseType is assignable from the examined class.
+
+
IsCompatibleType(Class<T>) - Constructor for class org.hamcrest.object.IsCompatibleType
+
+
Constructor, best called from IsCompatibleType.typeCompatibleWith(Class).
+
+
IsEmptyCollection<E> - Class in org.hamcrest.collection
+
+
Tests if a collection is empty.
+
+
IsEmptyCollection() - Constructor for class org.hamcrest.collection.IsEmptyCollection
+
+ +
+
IsEmptyIterable<E> - Class in org.hamcrest.collection
+
+
Tests if an iterable is empty.
+
+
IsEmptyIterable() - Constructor for class org.hamcrest.collection.IsEmptyIterable
+
+ +
+
isEmptyOrNullString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyOrNullString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyOrNullString()) instead
+
+
+
isEmptyString() - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
isEmptyString() - Static method in class org.hamcrest.text.IsEmptyString
+
+
Deprecated. +
use is(emptyString()) instead
+
+
+
IsEmptyString - Class in org.hamcrest.text
+
+
Matches empty Strings (and null).
+
+
IsEqual<T> - Class in org.hamcrest.core
+
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) method.
+
+
IsEqual(T) - Constructor for class org.hamcrest.core.IsEqual
+
+
Constructor, best called from IsEqual.equalTo(Object) or IsEqual.equalToObject(Object).
+
+
IsEqualCompressingWhiteSpace - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, compressing any changes in whitespace.
+
+
IsEqualCompressingWhiteSpace(String) - Constructor for class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+ +
+
IsEqualIgnoringCase - Class in org.hamcrest.text
+
+
Tests if a string is equal to another string, regardless of the case.
+
+
IsEqualIgnoringCase(String) - Constructor for class org.hamcrest.text.IsEqualIgnoringCase
+
+ +
+
IsEventFrom - Class in org.hamcrest.object
+
+
Tests if the value is an event announced by a specific object.
+
+
IsEventFrom(Class<?>, Object) - Constructor for class org.hamcrest.object.IsEventFrom
+
+ +
+
isIn(Collection<T>) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(Collection<T>) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
isIn(T[]) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(in(...)) instead
+
+
+
IsIn<T> - Class in org.hamcrest.collection
+
+
Tests if a collection contains a matching object.
+
+
IsIn(Collection<T>) - Constructor for class org.hamcrest.collection.IsIn
+
+
Constructor, best called from IsIn.in(Collection).
+
+
IsIn(T[]) - Constructor for class org.hamcrest.collection.IsIn
+
+
Constructor, best called from IsIn.in(Object[]).
+
+
IsInstanceOf - Class in org.hamcrest.core
+
+
Tests whether the value is an instance of a class.
+
+
IsInstanceOf(Class<?>) - Constructor for class org.hamcrest.core.IsInstanceOf
+
+
Creates a new instance of IsInstanceOf
+
+
IsIterableContaining<T> - Class in org.hamcrest.core
+
+
Tests if an iterable contains matching elements.
+
+
IsIterableContaining(Matcher<? super T>) - Constructor for class org.hamcrest.core.IsIterableContaining
+
+
Constructor, best called from one of the static factory methods.
+
+
IsIterableContainingInAnyOrder<T> - Class in org.hamcrest.collection
+
+
Tests if an iterable contains matching elements in any order.
+
+
IsIterableContainingInAnyOrder(Collection<Matcher<? super T>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
+
Constructor, best called from one of the static "containsInAnyOrder" factory methods.
+
+
IsIterableContainingInOrder<E> - Class in org.hamcrest.collection
+
+
Tests if an iterable contains matching elements in order.
+
+
IsIterableContainingInOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInOrder
+
+
Constructor, best called from one of the static "contains" factory methods.
+
+
IsIterableContainingInRelativeOrder<E> - Class in org.hamcrest.collection
+
+
Tests if an iterable contains matching elements in relative order.
+
+
IsIterableContainingInRelativeOrder(List<Matcher<? super E>>) - Constructor for class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
+ +
+
IsIterableWithSize<E> - Class in org.hamcrest.collection
+
+
Matches if iterable size satisfies a size matcher.
+
+
IsIterableWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsIterableWithSize
+
+ +
+
IsMapContaining<K,V> - Class in org.hamcrest.collection
+
+
Matches if map keys, values or entries match the value matchers.
+
+
IsMapContaining(Matcher<? super K>, Matcher<? super V>) - Constructor for class org.hamcrest.collection.IsMapContaining
+
+
Constructor, best called from one of the static factory methods (hasKey, hasValue, + or hasEntry).
+
+
IsMapWithSize<K,V> - Class in org.hamcrest.collection
+
+
Matches if map size satisfies a nested matcher.
+
+
IsMapWithSize(Matcher<? super Integer>) - Constructor for class org.hamcrest.collection.IsMapWithSize
+
+ +
+
IsNaN - Class in org.hamcrest.number
+
+
Is the value a number actually not a number (NaN)?
+
+
IsNot<T> - Class in org.hamcrest.core
+
+
Calculates the logical negation of a matcher.
+
+
IsNot(Matcher<T>) - Constructor for class org.hamcrest.core.IsNot
+
+
Constructor, best called from IsNot.not(Object) or + IsNot.not(Matcher).
+
+
isNotNull(Object, Description) - Static method in class org.hamcrest.BaseMatcher
+
+
Useful null-check method.
+
+
IsNull<T> - Class in org.hamcrest.core
+
+
Is the value null?
+
+
IsNull() - Constructor for class org.hamcrest.core.IsNull
+
+ +
+
isOneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
isOneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Deprecated. +
use is(oneOf(...)) instead
+
+
+
IsSame<T> - Class in org.hamcrest.core
+
+
Is the value the same object as another value?
+
+
IsSame(T) - Constructor for class org.hamcrest.core.IsSame
+
+
Constructor, best called from IsSame.sameInstance(Object) or + IsSame.theInstance(Object).
+
+
iterableMatcher - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
+
The matchers to match iterable against
+
+
iterableWithSize(int) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
iterableWithSize(int) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument.
+
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.collection.IsIterableWithSize
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
iterableWithSize(Matcher<? super Integer>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
+
+
+

L

+
+
lessThan(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThan(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThan(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
lessThanOrEqualTo(T) - Method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
lessThanOrEqualTo(T) - Static method in class org.hamcrest.number.OrderingComparison
+
+
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.
+
+
+

M

+
+
matched(T, Description) - Static method in class org.hamcrest.Condition
+
+
Called by steps when a match occurs
+
+
Matcher<T> - Interface in org.hamcrest
+
+
+ A matcher over acceptable values.
+
+
MatcherAssert - Class in org.hamcrest
+
+
The Hamcrest entrypoint, static methods to check if matchers match a + given value.
+
+
matchers - Variable in class org.hamcrest.collection.ArrayAsIterableMatcher
+
+
The matchers to match items against
+
+
Matchers - Class in org.hamcrest
+
+
Builder methods for various matchers.
+
+
matches(Object) - Method in class org.hamcrest.collection.IsIn
+
 
+
matches(Object) - Method in class org.hamcrest.core.AnyOf
+
 
+
matches(Object) - Method in class org.hamcrest.core.DescribedAs
+
 
+
matches(Object) - Method in class org.hamcrest.core.Is
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsAnything
+
+
Always returns true.
+
+
matches(Object) - Method in class org.hamcrest.core.IsEqual
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNot
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsNull
+
 
+
matches(Object) - Method in class org.hamcrest.core.IsSame
+
 
+
matches(Object) - Method in class org.hamcrest.DiagnosingMatcher
+
 
+
matches(Object) - Method in interface org.hamcrest.Matcher
+
+
Evaluates the matcher for argument item.
+
+
matches(Object) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
 
+
matches(Object) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Methods made final to prevent accidental override.
+
+
matches(Object, boolean) - Method in class org.hamcrest.core.AnyOf
+
+
Evaluates the argument o against the delegate matchers.
+
+
matches(Object, Description) - Method in class org.hamcrest.beans.SamePropertyValuesAs
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.AllOf
+
 
+
matches(Object, Description) - Method in class org.hamcrest.core.IsInstanceOf
+
 
+
matches(Object, Description) - Method in class org.hamcrest.DiagnosingMatcher
+
+
Evaluates the matcher for argument item.
+
+
matchesPattern(String) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
matchesPattern(String) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
+
+
matchesPattern(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
matchesPattern(Pattern) - Static method in class org.hamcrest.text.MatchesPattern
+
+
Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
+
+
MatchesPattern - Class in org.hamcrest.text
+
+
Tests if a string matches a regular expression.
+
+
MatchesPattern(Pattern) - Constructor for class org.hamcrest.text.MatchesPattern
+
+ +
+
matchesRegex(String) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified regex.
+
+
matchesRegex(String) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a regex.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.core.StringRegularExpression
+
+
Creates a matcher that checks if the examined string matches a specified Pattern.
+
+
matchesRegex(Pattern) - Static method in class org.hamcrest.Matchers
+
+
Validate a string with a Pattern.
+
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.ArrayAsIterableMatcher
+
 
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInAnyOrder
+
+
Deprecated.
+
matchesSafely(E[]) - Method in class org.hamcrest.collection.IsArrayContainingInOrder
+
+
Deprecated.
+
matchesSafely(Class<?>) - Method in class org.hamcrest.object.IsCompatibleType
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsCloseTo
+
 
+
matchesSafely(Double) - Method in class org.hamcrest.number.IsNaN
+
 
+
matchesSafely(Iterable<? extends E>) - Method in class org.hamcrest.collection.IsEmptyIterable
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInOrder
+
 
+
matchesSafely(Iterable<? extends E>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInRelativeOrder
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.collection.IsIterableContainingInAnyOrder
+
 
+
matchesSafely(Iterable<? extends T>, Description) - Method in class org.hamcrest.core.Every
+
 
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsCollectionContaining
+
+
Deprecated.
+
matchesSafely(Iterable<? super T>, Description) - Method in class org.hamcrest.core.IsIterableContaining
+
 
+
matchesSafely(String) - Method in class org.hamcrest.core.SubstringMatcher
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsBlankString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEmptyString
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.IsEqualIgnoringCase
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.MatchesPattern
+
 
+
matchesSafely(String) - Method in class org.hamcrest.text.StringContainsInOrder
+
 
+
matchesSafely(String, Description) - Method in class org.hamcrest.core.StringRegularExpression
+
 
+
matchesSafely(BigDecimal) - Method in class org.hamcrest.number.BigDecimalCloseTo
+
 
+
matchesSafely(Collection<? extends E>) - Method in class org.hamcrest.collection.IsEmptyCollection
+
 
+
matchesSafely(EventObject, Description) - Method in class org.hamcrest.object.IsEventFrom
+
 
+
matchesSafely(Map<? extends K, ? extends V>) - Method in class org.hamcrest.collection.IsMapContaining
+
 
+
matchesSafely(Node, Description) - Method in class org.hamcrest.xml.HasXPath
+
 
+
matchesSafely(T) - Method in class org.hamcrest.beans.HasProperty
+
 
+
matchesSafely(T) - Method in class org.hamcrest.TypeSafeMatcher
+
+
Check if the item matches.
+
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.HasItemInArray
+
 
+
matchesSafely(T[]) - Method in class org.hamcrest.collection.IsArray
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.beans.HasPropertyWithValue
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.core.CombinableMatcher
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.FeatureMatcher
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.object.HasEqualValues
+
 
+
matchesSafely(T, Description) - Method in class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Subclasses should implement this.
+
+
matching(Matcher<T>) - Method in class org.hamcrest.Condition
+
+
Applies the matcher as the final step in the sequence
+
+
matching(Matcher<T>, String) - Method in class org.hamcrest.Condition
+
+
Applies the matcher as the final step in the sequence
+
+
+

N

+
+
NO_ARGUMENTS - Static variable in class org.hamcrest.beans.PropertyUtil
+
+
Empty object array, used for documenting that we are deliberately passing no arguments to a method.
+
+
NO_NAMESPACE_CONTEXT - Static variable in class org.hamcrest.xml.HasXPath
+
+
Null NamespaceContext, used to document deliberate use + of no namespace.
+
+
NONE - Static variable in interface org.hamcrest.Description
+
+
A description that consumes input but does nothing, implemented by + Description.NullDescription.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.core.IsNot
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(Matcher<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match.
+
+
not(T) - Static method in class org.hamcrest.core.IsNot
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(T) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
not(T) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(equalTo(x)).
+
+
notANumber() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notANumber() - Static method in class org.hamcrest.number.IsNaN
+
+
Creates a matcher of Doubles that matches when an examined double is not a number.
+
+
notMatched() - Static method in class org.hamcrest.Condition
+
+
Called by steps when a mismatch occurs.
+
+
notNullValue() - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue() - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue()).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
notNullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
A shortcut to the frequently used not(nullValue(X.class)).
+
+
NullDescription() - Constructor for class org.hamcrest.Description.NullDescription
+
+
Constructor.
+
+
nullValue() - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue() - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches if examined object is null.
+
+
nullValue(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches if examined object is null.
+
+
+

O

+
+
oneOf(T...) - Static method in class org.hamcrest.collection.IsIn
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
oneOf(T...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches when the examined object is equal to one of the + specified elements.
+
+
or(Matcher<? super T>) - Method in class org.hamcrest.core.CombinableMatcher
+
+
Specify the second matcher in a CombinableMatcher pair.
+
+
or(Matcher<? super X>) - Method in class org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher
+
+
Specify the second matcher in a CombinableMatcher pair.
+
+
OrderingComparison - Class in org.hamcrest.number
+
+
Static methods for building ordering comparisons.
+
+
org.hamcrest - package org.hamcrest
+
+
Top level matcher classes and interfaces.
+
+
org.hamcrest.beans - package org.hamcrest.beans
+
+
Matchers of Java Bean properties and their values.
+
+
org.hamcrest.collection - package org.hamcrest.collection
+
+
Matchers of arrays and collections.
+
+
org.hamcrest.comparator - package org.hamcrest.comparator
+
+
Helper classes for building matcher comparators.
+
+
org.hamcrest.core - package org.hamcrest.core
+
+
Fundamental matchers of objects and values, and composite matchers.
+
+
org.hamcrest.io - package org.hamcrest.io
+
+
Matchers that perform file comparisons.
+
+
org.hamcrest.number - package org.hamcrest.number
+
+
Matchers that perform numeric comparisons.
+
+
org.hamcrest.object - package org.hamcrest.object
+
+
Matchers that inspect objects and classes.
+
+
org.hamcrest.text - package org.hamcrest.text
+
+
Matchers that perform text comparisons.
+
+
org.hamcrest.xml - package org.hamcrest.xml
+
+
Matchers of XML documents.
+
+
+

P

+
+
propertyDescriptorsFor(Object, Class<Object>) - Static method in class org.hamcrest.beans.PropertyUtil
+
+
Returns all the property descriptors for the class associated with the given object
+
+
PropertyUtil - Class in org.hamcrest.beans
+
+
Utility class with static methods for accessing properties on JavaBean objects.
+
+
+

S

+
+
sameInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
sameInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.beans.SamePropertyValuesAs
+
+
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.
+
+
samePropertyValuesAs(B, String...) - Static method in class org.hamcrest.Matchers
+
+
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.
+
+
SamePropertyValuesAs<T> - Class in org.hamcrest.beans
+
+
A matcher that checks if a given bean has the same property values + as an example bean.
+
+
SamePropertyValuesAs(T, List<String>) - Constructor for class org.hamcrest.beans.SamePropertyValuesAs
+
+ +
+
SelfDescribing - Interface in org.hamcrest
+
+
The ability of an object to describe itself.
+
+
startsWith(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWith(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String.
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.core.StringStartsWith
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.CoreMatchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
startsWithIgnoringCase(String) - Static method in class org.hamcrest.Matchers
+
+
+ Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
+
+
StringContains - Class in org.hamcrest.core
+
+
Tests if the argument is a string that contains a specific substring.
+
+
StringContains(boolean, String) - Constructor for class org.hamcrest.core.StringContains
+
+ +
+
StringContains(String) - Constructor for class org.hamcrest.core.StringContains
+
+
Constructor, best used with StringContains.containsString(String).
+
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(Iterable<String>) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
stringContainsInOrder(String...) - Static method in class org.hamcrest.text.StringContainsInOrder
+
+
Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
+
+
StringContainsInOrder - Class in org.hamcrest.text
+
+
Tests if a string contains the given substrings in order.
+
+
StringContainsInOrder(Iterable<String>) - Constructor for class org.hamcrest.text.StringContainsInOrder
+
+ +
+
StringDescription - Class in org.hamcrest
+
+
A Description that is stored as a string.
+
+
StringDescription() - Constructor for class org.hamcrest.StringDescription
+
+
Creates a new description.
+
+
StringDescription(Appendable) - Constructor for class org.hamcrest.StringDescription
+
+
Creates a new description using the given appendable.
+
+
StringEndsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that ends with a specific substring.
+
+
StringEndsWith(boolean, String) - Constructor for class org.hamcrest.core.StringEndsWith
+
+ +
+
StringEndsWith(String) - Constructor for class org.hamcrest.core.StringEndsWith
+
+
Constructor, best used with StringEndsWith.endsWith(String).
+
+
StringRegularExpression - Class in org.hamcrest.core
+
+
A matcher that checks a string against a regular expression.
+
+
StringRegularExpression(Pattern) - Constructor for class org.hamcrest.core.StringRegularExpression
+
+ +
+
StringStartsWith - Class in org.hamcrest.core
+
+
Tests if the argument is a string that starts with a specific substring.
+
+
StringStartsWith(boolean, String) - Constructor for class org.hamcrest.core.StringStartsWith
+
+ +
+
StringStartsWith(String) - Constructor for class org.hamcrest.core.StringStartsWith
+
+
Constructor, best used with StringStartsWith.startsWith(String).
+
+
stripSpaces(String) - Method in class org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
Strips spaces
+
+
substring - Variable in class org.hamcrest.core.SubstringMatcher
+
+
The substring to match
+
+
SubstringMatcher - Class in org.hamcrest.core
+
+
Common behaviour for matchers that check substrings.
+
+
SubstringMatcher(String, boolean, String) - Constructor for class org.hamcrest.core.SubstringMatcher
+
+
Build a SubstringMatcher.
+
+
+

T

+
+
theInstance(T) - Static method in class org.hamcrest.core.IsSame
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.CoreMatchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
theInstance(T) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
+
+
then(Condition.Step<? super T, U>) - Method in class org.hamcrest.Condition
+
+
An alias for Condition.and(Step), which applies the mapping to the current value in the + sequence.
+
+
toString() - Method in class org.hamcrest.BaseMatcher
+
 
+
toString() - Method in class org.hamcrest.Description.NullDescription
+
 
+
toString() - Method in class org.hamcrest.StringDescription
+
+
Returns the description as a string.
+
+
toString(SelfDescribing) - Static method in class org.hamcrest.StringDescription
+
+
Return the description of a SelfDescribing object as a String.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.Matchers
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
typeCompatibleWith(Class<T>) - Static method in class org.hamcrest.object.IsCompatibleType
+
+
Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
+
+
TypeSafeDiagnosingMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
+
+
TypeSafeDiagnosingMatcher() - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeDiagnosingMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeDiagnosingMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeDiagnosingMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeMatcher<T> - Class in org.hamcrest
+
+
Convenient base class for Matchers that require a non-null value of a specific type.
+
+
TypeSafeMatcher() - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
The default constructor for simple sub types
+
+
TypeSafeMatcher(Class<?>) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
TypeSafeMatcher(ReflectiveTypeFinder) - Constructor for class org.hamcrest.TypeSafeMatcher
+
+
Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
+
+
+

U

+
+
usingNaturalOrdering() - Static method in class org.hamcrest.comparator.ComparatorMatcherBuilder
+
+
Creates a matcher factory for matchers of Comparables.
+
+
+

_

+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in class org.hamcrest.BaseMatcher
+
+
Deprecated.
+
+
_dont_implement_Matcher___instead_extend_BaseMatcher_() - Method in interface org.hamcrest.Matcher
+
+
Deprecated. +
to make
+
+
+
+A B C D E F G H I L M N O P S T U _ 
All Classes and Interfaces|All Packages
+
+
+ + diff --git a/docs/javadoc/3.0/index.html b/docs/javadoc/3.0/index.html new file mode 100644 index 000000000..a1f85435f --- /dev/null +++ b/docs/javadoc/3.0/index.html @@ -0,0 +1,125 @@ + + + + +Overview (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hamcrest 3.0 API

+
+

Matchers that can be combined to create flexible expressions of intent.

+

For example:

+
import org.junit.jupiter.api.Test;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class BiscuitTest {
+  @Test
+  public void testEquals() {
+    Biscuit theBiscuit = new Biscuit("Ginger");
+    Biscuit myBiscuit = new Biscuit("Ginger");
+    assertThat(theBiscuit, equalTo(myBiscuit));
+  }
+}
+
+ +

For more information and documentation, see:

+
+
+
Packages
+
+
Package
+
Description
+ +
+
Top level matcher classes and interfaces.
+
+ +
+
Matchers of Java Bean properties and their values.
+
+ +
+
Matchers of arrays and collections.
+
+ +
+
Helper classes for building matcher comparators.
+
+ +
+
Fundamental matchers of objects and values, and composite matchers.
+
+ +
+
Matchers that perform file comparisons.
+
+ +
+
Matchers that perform numeric comparisons.
+
+ +
+
Matchers that inspect objects and classes.
+
+ +
+
Matchers that perform text comparisons.
+
+ +
+
Matchers of XML documents.
+
+
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/legal/ADDITIONAL_LICENSE_INFO b/docs/javadoc/3.0/legal/ADDITIONAL_LICENSE_INFO new file mode 100644 index 000000000..ff700cd09 --- /dev/null +++ b/docs/javadoc/3.0/legal/ADDITIONAL_LICENSE_INFO @@ -0,0 +1,37 @@ + ADDITIONAL INFORMATION ABOUT LICENSING + +Certain files distributed by Oracle America, Inc. and/or its affiliates are +subject to the following clarification and special exception to the GPLv2, +based on the GNU Project exception for its Classpath libraries, known as the +GNU Classpath Exception. + +Note that Oracle includes multiple, independent programs in this software +package. Some of those programs are provided under licenses deemed +incompatible with the GPLv2 by the Free Software Foundation and others. +For example, the package includes programs licensed under the Apache +License, Version 2.0 and may include FreeType. Such programs are licensed +to you under their original licenses. + +Oracle facilitates your further distribution of this package by adding the +Classpath Exception to the necessary parts of its GPLv2 code, which permits +you to use that code in combination with other independent modules not +licensed under the GPLv2. However, note that this would not permit you to +commingle code under an incompatible license with Oracle's GPLv2 licensed +code by, for example, cutting and pasting such code into a file also +containing Oracle's GPLv2 licensed code and then distributing the result. + +Additionally, if you were to remove the Classpath Exception from any of the +files to which it applies and distribute the result, you would likely be +required to license some or all of the other code in that distribution under +the GPLv2 as well, and since the GPLv2 is incompatible with the license terms +of some items included in the distribution by Oracle, removing the Classpath +Exception could therefore effectively compromise your ability to further +distribute the package. + +Failing to distribute notices associated with some files may also create +unexpected legal consequences. + +Proceed with caution and we recommend that you obtain the advice of a lawyer +skilled in open source matters before removing the Classpath Exception or +making modifications to this package which may subsequently be redistributed +and/or involve the use of third party software. diff --git a/docs/javadoc/3.0/legal/ASSEMBLY_EXCEPTION b/docs/javadoc/3.0/legal/ASSEMBLY_EXCEPTION new file mode 100644 index 000000000..429666664 --- /dev/null +++ b/docs/javadoc/3.0/legal/ASSEMBLY_EXCEPTION @@ -0,0 +1,27 @@ + +OPENJDK ASSEMBLY EXCEPTION + +The OpenJDK source code made available by Oracle America, Inc. (Oracle) at +openjdk.org ("OpenJDK Code") is distributed under the terms of the GNU +General Public License version 2 +only ("GPL2"), with the following clarification and special exception. + + Linking this OpenJDK Code statically or dynamically with other code + is making a combined work based on this library. Thus, the terms + and conditions of GPL2 cover the whole combination. + + As a special exception, Oracle gives you permission to link this + OpenJDK Code with certain code licensed by Oracle as indicated at + https://openjdk.org/legal/exception-modules-2007-05-08.html + ("Designated Exception Modules") to produce an executable, + regardless of the license terms of the Designated Exception Modules, + and to copy and distribute the resulting executable under GPL2, + provided that the Designated Exception Modules continue to be + governed by the licenses under which they were offered by Oracle. + +As such, it allows licensees and sublicensees of Oracle's GPL2 OpenJDK Code +to build an executable that includes those portions of necessary code that +Oracle could not provide under GPL2 (or that Oracle has provided under GPL2 +with the Classpath exception). If you modify or add to the OpenJDK code, +that new GPL2 code may still be combined with Designated Exception Modules +if the new code is made subject to this exception by its copyright holder. diff --git a/docs/javadoc/3.0/legal/LICENSE b/docs/javadoc/3.0/legal/LICENSE new file mode 100644 index 000000000..8b400c7ab --- /dev/null +++ b/docs/javadoc/3.0/legal/LICENSE @@ -0,0 +1,347 @@ +The GNU General Public License (GPL) + +Version 2, June 1991 + +Copyright (C) 1989, 1991 Free Software Foundation, Inc. +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Everyone is permitted to copy and distribute verbatim copies of this license +document, but changing it is not allowed. + +Preamble + +The licenses for most software are designed to take away your freedom to share +and change it. By contrast, the GNU General Public License is intended to +guarantee your freedom to share and change free software--to make sure the +software is free for all its users. This General Public License applies to +most of the Free Software Foundation's software and to any other program whose +authors commit to using it. (Some other Free Software Foundation software is +covered by the GNU Library General Public License instead.) You can apply it to +your programs, too. + +When we speak of free software, we are referring to freedom, not price. Our +General Public Licenses are designed to make sure that you have the freedom to +distribute copies of free software (and charge for this service if you wish), +that you receive source code or can get it if you want it, that you can change +the software or use pieces of it in new free programs; and that you know you +can do these things. + +To protect your rights, we need to make restrictions that forbid anyone to deny +you these rights or to ask you to surrender the rights. These restrictions +translate to certain responsibilities for you if you distribute copies of the +software, or if you modify it. + +For example, if you distribute copies of such a program, whether gratis or for +a fee, you must give the recipients all the rights that you have. You must +make sure that they, too, receive or can get the source code. And you must +show them these terms so they know their rights. + +We protect your rights with two steps: (1) copyright the software, and (2) +offer you this license which gives you legal permission to copy, distribute +and/or modify the software. + +Also, for each author's protection and ours, we want to make certain that +everyone understands that there is no warranty for this free software. If the +software is modified by someone else and passed on, we want its recipients to +know that what they have is not the original, so that any problems introduced +by others will not reflect on the original authors' reputations. + +Finally, any free program is threatened constantly by software patents. We +wish to avoid the danger that redistributors of a free program will +individually obtain patent licenses, in effect making the program proprietary. +To prevent this, we have made it clear that any patent must be licensed for +everyone's free use or not licensed at all. + +The precise terms and conditions for copying, distribution and modification +follow. + +TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + +0. This License applies to any program or other work which contains a notice +placed by the copyright holder saying it may be distributed under the terms of +this General Public License. The "Program", below, refers to any such program +or work, and a "work based on the Program" means either the Program or any +derivative work under copyright law: that is to say, a work containing the +Program or a portion of it, either verbatim or with modifications and/or +translated into another language. (Hereinafter, translation is included +without limitation in the term "modification".) Each licensee is addressed as +"you". + +Activities other than copying, distribution and modification are not covered by +this License; they are outside its scope. The act of running the Program is +not restricted, and the output from the Program is covered only if its contents +constitute a work based on the Program (independent of having been made by +running the Program). Whether that is true depends on what the Program does. + +1. You may copy and distribute verbatim copies of the Program's source code as +you receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice and +disclaimer of warranty; keep intact all the notices that refer to this License +and to the absence of any warranty; and give any other recipients of the +Program a copy of this License along with the Program. + +You may charge a fee for the physical act of transferring a copy, and you may +at your option offer warranty protection in exchange for a fee. + +2. You may modify your copy or copies of the Program or any portion of it, thus +forming a work based on the Program, and copy and distribute such modifications +or work under the terms of Section 1 above, provided that you also meet all of +these conditions: + + a) You must cause the modified files to carry prominent notices stating + that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in whole or + in part contains or is derived from the Program or any part thereof, to be + licensed as a whole at no charge to all third parties under the terms of + this License. + + c) If the modified program normally reads commands interactively when run, + you must cause it, when started running for such interactive use in the + most ordinary way, to print or display an announcement including an + appropriate copyright notice and a notice that there is no warranty (or + else, saying that you provide a warranty) and that users may redistribute + the program under these conditions, and telling the user how to view a copy + of this License. (Exception: if the Program itself is interactive but does + not normally print such an announcement, your work based on the Program is + not required to print an announcement.) + +These requirements apply to the modified work as a whole. If identifiable +sections of that work are not derived from the Program, and can be reasonably +considered independent and separate works in themselves, then this License, and +its terms, do not apply to those sections when you distribute them as separate +works. But when you distribute the same sections as part of a whole which is a +work based on the Program, the distribution of the whole must be on the terms +of this License, whose permissions for other licensees extend to the entire +whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest your +rights to work written entirely by you; rather, the intent is to exercise the +right to control the distribution of derivative or collective works based on +the Program. + +In addition, mere aggregation of another work not based on the Program with the +Program (or with a work based on the Program) on a volume of a storage or +distribution medium does not bring the other work under the scope of this +License. + +3. You may copy and distribute the Program (or a work based on it, under +Section 2) in object code or executable form under the terms of Sections 1 and +2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable source + code, which must be distributed under the terms of Sections 1 and 2 above + on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three years, to + give any third party, for a charge no more than your cost of physically + performing source distribution, a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of Sections 1 + and 2 above on a medium customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer to + distribute corresponding source code. (This alternative is allowed only + for noncommercial distribution and only if you received the program in + object code or executable form with such an offer, in accord with + Subsection b above.) + +The source code for a work means the preferred form of the work for making +modifications to it. For an executable work, complete source code means all +the source code for all modules it contains, plus any associated interface +definition files, plus the scripts used to control compilation and installation +of the executable. However, as a special exception, the source code +distributed need not include anything that is normally distributed (in either +source or binary form) with the major components (compiler, kernel, and so on) +of the operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the source +code from the same place counts as distribution of the source code, even though +third parties are not compelled to copy the source along with the object code. + +4. You may not copy, modify, sublicense, or distribute the Program except as +expressly provided under this License. Any attempt otherwise to copy, modify, +sublicense or distribute the Program is void, and will automatically terminate +your rights under this License. However, parties who have received copies, or +rights, from you under this License will not have their licenses terminated so +long as such parties remain in full compliance. + +5. You are not required to accept this License, since you have not signed it. +However, nothing else grants you permission to modify or distribute the Program +or its derivative works. These actions are prohibited by law if you do not +accept this License. Therefore, by modifying or distributing the Program (or +any work based on the Program), you indicate your acceptance of this License to +do so, and all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + +6. Each time you redistribute the Program (or any work based on the Program), +the recipient automatically receives a license from the original licensor to +copy, distribute or modify the Program subject to these terms and conditions. +You may not impose any further restrictions on the recipients' exercise of the +rights granted herein. You are not responsible for enforcing compliance by +third parties to this License. + +7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), conditions +are imposed on you (whether by court order, agreement or otherwise) that +contradict the conditions of this License, they do not excuse you from the +conditions of this License. If you cannot distribute so as to satisfy +simultaneously your obligations under this License and any other pertinent +obligations, then as a consequence you may not distribute the Program at all. +For example, if a patent license would not permit royalty-free redistribution +of the Program by all those who receive copies directly or indirectly through +you, then the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply and +the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any patents or +other property right claims or to contest validity of any such claims; this +section has the sole purpose of protecting the integrity of the free software +distribution system, which is implemented by public license practices. Many +people have made generous contributions to the wide range of software +distributed through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing to +distribute software through any other system and a licensee cannot impose that +choice. + +This section is intended to make thoroughly clear what is believed to be a +consequence of the rest of this License. + +8. If the distribution and/or use of the Program is restricted in certain +countries either by patents or by copyrighted interfaces, the original +copyright holder who places the Program under this License may add an explicit +geographical distribution limitation excluding those countries, so that +distribution is permitted only in or among countries not thus excluded. In +such case, this License incorporates the limitation as if written in the body +of this License. + +9. The Free Software Foundation may publish revised and/or new versions of the +General Public License from time to time. Such new versions will be similar in +spirit to the present version, but may differ in detail to address new problems +or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any later +version", you have the option of following the terms and conditions either of +that version or of any later version published by the Free Software Foundation. +If the Program does not specify a version number of this License, you may +choose any version ever published by the Free Software Foundation. + +10. If you wish to incorporate parts of the Program into other free programs +whose distribution conditions are different, write to the author to ask for +permission. For software which is copyrighted by the Free Software Foundation, +write to the Free Software Foundation; we sometimes make exceptions for this. +Our decision will be guided by the two goals of preserving the free status of +all derivatives of our free software and of promoting the sharing and reuse of +software generally. + +NO WARRANTY + +11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR +THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE +STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE +PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND +PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, +YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + +12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL +ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE +PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR +INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA +BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER +OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +END OF TERMS AND CONDITIONS + +How to Apply These Terms to Your New Programs + +If you develop a new program, and you want it to be of the greatest possible +use to the public, the best way to achieve this is to make it free software +which everyone can redistribute and change under these terms. + +To do so, attach the following notices to the program. It is safest to attach +them to the start of each source file to most effectively convey the exclusion +of warranty; and each file should have at least the "copyright" line and a +pointer to where the full notice is found. + + One line to give the program's name and a brief idea of what it does. + + Copyright (C) + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this when it +starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author Gnomovision comes + with ABSOLUTELY NO WARRANTY; for details type 'show w'. This is free + software, and you are welcome to redistribute it under certain conditions; + type 'show c' for details. + +The hypothetical commands 'show w' and 'show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may be +called something other than 'show w' and 'show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your school, +if any, to sign a "copyright disclaimer" for the program, if necessary. Here +is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + 'Gnomovision' (which makes passes at compilers) written by James Hacker. + + signature of Ty Coon, 1 April 1989 + + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General Public +License instead of this License. + + +"CLASSPATH" EXCEPTION TO THE GPL + +Certain source files distributed by Oracle America and/or its affiliates are +subject to the following clarification and special exception to the GPL, but +only where Oracle has expressly included in the particular source file's header +the words "Oracle designates this particular file as subject to the "Classpath" +exception as provided by Oracle in the LICENSE file that accompanied this code." + + Linking this library statically or dynamically with other modules is making + a combined work based on this library. Thus, the terms and conditions of + the GNU General Public License cover the whole combination. + + As a special exception, the copyright holders of this library give you + permission to link this library with independent modules to produce an + executable, regardless of the license terms of these independent modules, + and to copy and distribute the resulting executable under terms of your + choice, provided that you also meet, for each linked independent module, + the terms and conditions of the license of that module. An independent + module is a module which is not derived from or based on this library. If + you modify this library, you may extend this exception to your version of + the library, but you are not obligated to do so. If you do not wish to do + so, delete this exception statement from your version. diff --git a/docs/javadoc/3.0/legal/jquery.md b/docs/javadoc/3.0/legal/jquery.md new file mode 100644 index 000000000..d468b3183 --- /dev/null +++ b/docs/javadoc/3.0/legal/jquery.md @@ -0,0 +1,72 @@ +## jQuery v3.6.1 + +### jQuery License +``` +jQuery v 3.6.1 +Copyright OpenJS Foundation and other contributors, https://openjsf.org/ + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +****************************************** + +The jQuery JavaScript Library v3.6.1 also includes Sizzle.js + +Sizzle.js includes the following license: + +Copyright JS Foundation and other contributors, https://js.foundation/ + +This software consists of voluntary contributions made by many +individuals. For exact contribution history, see the revision history +available at https://github.com/jquery/sizzle + +The following license applies to all parts of this software except as +documented below: + +==== + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +==== + +All files located in the node_modules and external directories are +externally maintained libraries used by this software which have their +own licenses; we recommend you read them, as their terms may differ from +the terms above. + +********************* + +``` diff --git a/docs/javadoc/3.0/legal/jqueryUI.md b/docs/javadoc/3.0/legal/jqueryUI.md new file mode 100644 index 000000000..8bda9d7a8 --- /dev/null +++ b/docs/javadoc/3.0/legal/jqueryUI.md @@ -0,0 +1,49 @@ +## jQuery UI v1.13.2 + +### jQuery UI License +``` +Copyright jQuery Foundation and other contributors, https://jquery.org/ + +This software consists of voluntary contributions made by many +individuals. For exact contribution history, see the revision history +available at https://github.com/jquery/jquery-ui + +The following license applies to all parts of this software except as +documented below: + +==== + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +==== + +Copyright and related rights for sample code are waived via CC0. Sample +code is defined as all source code contained within the demos directory. + +CC0: http://creativecommons.org/publicdomain/zero/1.0/ + +==== + +All files located in the node_modules and external directories are +externally maintained libraries used by this software which have their +own licenses; we recommend you read them, as their terms may differ from +the terms above. + +``` diff --git a/docs/javadoc/3.0/link.svg b/docs/javadoc/3.0/link.svg new file mode 100644 index 000000000..7ccc5ed08 --- /dev/null +++ b/docs/javadoc/3.0/link.svg @@ -0,0 +1,31 @@ + + + + + + + + diff --git a/docs/javadoc/3.0/member-search-index.js b/docs/javadoc/3.0/member-search-index.js new file mode 100644 index 000000000..2c33b6f91 --- /dev/null +++ b/docs/javadoc/3.0/member-search-index.js @@ -0,0 +1 @@ +memberSearchIndex = [{"p":"org.hamcrest","c":"BaseMatcher","l":"_dont_implement_Matcher___instead_extend_BaseMatcher_()"},{"p":"org.hamcrest","c":"Matcher","l":"_dont_implement_Matcher___instead_extend_BaseMatcher_()"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aFileNamed(Matcher)","u":"aFileNamed(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aFileWithAbsolutePath(Matcher)","u":"aFileWithAbsolutePath(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aFileWithCanonicalPath(Matcher)","u":"aFileWithCanonicalPath(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aFileWithSize(long)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aFileWithSize(Matcher)","u":"aFileWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"AllOf","l":"allOf(Iterable>)","u":"allOf(java.lang.Iterable)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"allOf(Iterable>)","u":"allOf(java.lang.Iterable)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Iterable>)","u":"allOf(java.lang.Iterable)"},{"p":"org.hamcrest.core","c":"AllOf","l":"AllOf(Iterable>)","u":"%3Cinit%3E(java.lang.Iterable)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher, Matcher)","u":"allOf(org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher, Matcher, Matcher)","u":"allOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher, Matcher, Matcher, Matcher)","u":"allOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher, Matcher, Matcher, Matcher, Matcher)","u":"allOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher)","u":"allOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"AllOf","l":"allOf(Matcher...)","u":"allOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"allOf(Matcher...)","u":"allOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"allOf(Matcher...)","u":"allOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"AllOf","l":"AllOf(Matcher...)","u":"%3Cinit%3E(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsMapWithSize","l":"aMapWithSize(int)"},{"p":"org.hamcrest","c":"Matchers","l":"aMapWithSize(int)"},{"p":"org.hamcrest.collection","c":"IsMapWithSize","l":"aMapWithSize(Matcher)","u":"aMapWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"aMapWithSize(Matcher)","u":"aMapWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Condition","l":"and(Condition.Step)","u":"and(org.hamcrest.Condition.Step)"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"and(Matcher)","u":"and(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"CombinableMatcher.CombinableBothMatcher","l":"and(Matcher)","u":"and(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsMapWithSize","l":"anEmptyMap()"},{"p":"org.hamcrest","c":"Matchers","l":"anEmptyMap()"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"anExistingDirectory()"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"anExistingFile()"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"anExistingFileOrDirectory()"},{"p":"org.hamcrest.core","c":"IsInstanceOf","l":"any(Class)","u":"any(java.lang.Class)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"any(Class)","u":"any(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"any(Class)","u":"any(java.lang.Class)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"anyOf(Iterable>)","u":"anyOf(java.lang.Iterable)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"anyOf(Iterable>)","u":"anyOf(java.lang.Iterable)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Iterable>)","u":"anyOf(java.lang.Iterable)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"AnyOf(Iterable>)","u":"%3Cinit%3E(java.lang.Iterable)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher, Matcher)","u":"anyOf(org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher, Matcher, Matcher)","u":"anyOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher, Matcher, Matcher, Matcher)","u":"anyOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher, Matcher, Matcher, Matcher, Matcher)","u":"anyOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher)","u":"anyOf(org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"anyOf(Matcher...)","u":"anyOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"anyOf(Matcher...)","u":"anyOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"anyOf(Matcher...)","u":"anyOf(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"AnyOf(Matcher...)","u":"%3Cinit%3E(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"IsAnything","l":"anything()"},{"p":"org.hamcrest","c":"CoreMatchers","l":"anything()"},{"p":"org.hamcrest","c":"Matchers","l":"anything()"},{"p":"org.hamcrest.core","c":"IsAnything","l":"anything(String)","u":"anything(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"anything(String)","u":"anything(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"anything(String)","u":"anything(java.lang.String)"},{"p":"org.hamcrest","c":"BaseDescription","l":"append(char)"},{"p":"org.hamcrest","c":"StringDescription","l":"append(char)"},{"p":"org.hamcrest","c":"BaseDescription","l":"append(String)","u":"append(java.lang.String)"},{"p":"org.hamcrest","c":"StringDescription","l":"append(String)","u":"append(java.lang.String)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendDescriptionOf(SelfDescribing)","u":"appendDescriptionOf(org.hamcrest.SelfDescribing)"},{"p":"org.hamcrest","c":"Description","l":"appendDescriptionOf(SelfDescribing)","u":"appendDescriptionOf(org.hamcrest.SelfDescribing)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendDescriptionOf(SelfDescribing)","u":"appendDescriptionOf(org.hamcrest.SelfDescribing)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendList(String, String, String, Iterable)","u":"appendList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"Description","l":"appendList(String, String, String, Iterable)","u":"appendList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendList(String, String, String, Iterable)","u":"appendList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendText(String)","u":"appendText(java.lang.String)"},{"p":"org.hamcrest","c":"Description","l":"appendText(String)","u":"appendText(java.lang.String)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendText(String)","u":"appendText(java.lang.String)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendValue(Object)","u":"appendValue(java.lang.Object)"},{"p":"org.hamcrest","c":"Description","l":"appendValue(Object)","u":"appendValue(java.lang.Object)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendValue(Object)","u":"appendValue(java.lang.Object)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendValueList(String, String, String, Iterable)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"Description","l":"appendValueList(String, String, String, Iterable)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendValueList(String, String, String, Iterable)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,java.lang.Iterable)"},{"p":"org.hamcrest","c":"BaseDescription","l":"appendValueList(String, String, String, T...)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,T...)"},{"p":"org.hamcrest","c":"Description","l":"appendValueList(String, String, String, T...)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,T...)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"appendValueList(String, String, String, T...)","u":"appendValueList(java.lang.String,java.lang.String,java.lang.String,T...)"},{"p":"org.hamcrest","c":"Condition.Step","l":"apply(I, Description)","u":"apply(I,org.hamcrest.Description)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aReadableFile()"},{"p":"org.hamcrest.collection","c":"IsArray","l":"array(Matcher...)","u":"array(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"array(Matcher...)","u":"array(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"ArrayAsIterableMatcher(TypeSafeDiagnosingMatcher>, Collection>, String)","u":"%3Cinit%3E(org.hamcrest.TypeSafeDiagnosingMatcher,java.util.Collection,java.lang.String)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContaining(E...)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"arrayContaining(E...)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContaining(E...)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContaining(List>)","u":"arrayContaining(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"arrayContaining(List>)","u":"arrayContaining(java.util.List)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContaining(List>)","u":"arrayContaining(java.util.List)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContaining(Matcher...)","u":"arrayContaining(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"arrayContaining(Matcher...)","u":"arrayContaining(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContaining(Matcher...)","u":"arrayContaining(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContainingInAnyOrder(Collection>)","u":"arrayContainingInAnyOrder(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"arrayContainingInAnyOrder(Collection>)","u":"arrayContainingInAnyOrder(java.util.Collection)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContainingInAnyOrder(Collection>)","u":"arrayContainingInAnyOrder(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContainingInAnyOrder(E...)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"arrayContainingInAnyOrder(E...)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContainingInAnyOrder(E...)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"arrayContainingInAnyOrder(Matcher...)","u":"arrayContainingInAnyOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"arrayContainingInAnyOrder(Matcher...)","u":"arrayContainingInAnyOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayContainingInAnyOrder(Matcher...)","u":"arrayContainingInAnyOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsArrayWithSize","l":"arrayWithSize(int)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayWithSize(int)"},{"p":"org.hamcrest.collection","c":"IsArrayWithSize","l":"arrayWithSize(Matcher)","u":"arrayWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"arrayWithSize(Matcher)","u":"arrayWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"asEqualMatchers(E[])"},{"p":"org.hamcrest","c":"MatcherAssert","l":"assertThat(String, boolean)","u":"assertThat(java.lang.String,boolean)"},{"p":"org.hamcrest","c":"MatcherAssert","l":"assertThat(String, T, Matcher)","u":"assertThat(java.lang.String,T,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"MatcherAssert","l":"assertThat(T, Matcher)","u":"assertThat(T,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"StringDescription","l":"asString(SelfDescribing)","u":"asString(org.hamcrest.SelfDescribing)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"aWritableFile()"},{"p":"org.hamcrest","c":"BaseDescription","l":"BaseDescription()","u":"%3Cinit%3E()"},{"p":"org.hamcrest","c":"BaseMatcher","l":"BaseMatcher()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.number","c":"BigDecimalCloseTo","l":"BigDecimalCloseTo(BigDecimal, BigDecimal)","u":"%3Cinit%3E(java.math.BigDecimal,java.math.BigDecimal)"},{"p":"org.hamcrest","c":"Matchers","l":"blankOrNullString()"},{"p":"org.hamcrest.text","c":"IsBlankString","l":"blankOrNullString()"},{"p":"org.hamcrest","c":"Matchers","l":"blankString()"},{"p":"org.hamcrest.text","c":"IsBlankString","l":"blankString()"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"both(Matcher)","u":"both(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"both(Matcher)","u":"both(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"both(Matcher)","u":"both(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"CAN_READ"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"CAN_WRITE"},{"p":"org.hamcrest.text","c":"CharSequenceLength","l":"CharSequenceLength(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers.FileStatus","l":"check(File)","u":"check(java.io.File)"},{"p":"org.hamcrest","c":"Matchers","l":"closeTo(BigDecimal, BigDecimal)","u":"closeTo(java.math.BigDecimal,java.math.BigDecimal)"},{"p":"org.hamcrest.number","c":"BigDecimalCloseTo","l":"closeTo(BigDecimal, BigDecimal)","u":"closeTo(java.math.BigDecimal,java.math.BigDecimal)"},{"p":"org.hamcrest","c":"Matchers","l":"closeTo(double, double)","u":"closeTo(double,double)"},{"p":"org.hamcrest.number","c":"IsCloseTo","l":"closeTo(double, double)","u":"closeTo(double,double)"},{"p":"org.hamcrest.core","c":"CombinableMatcher.CombinableBothMatcher","l":"CombinableBothMatcher(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"CombinableMatcher.CombinableEitherMatcher","l":"CombinableEitherMatcher(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"CombinableMatcher(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"comparedBy(Comparator)","u":"comparedBy(java.util.Comparator)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"comparesEqualTo(T)"},{"p":"org.hamcrest","c":"Matchers","l":"comparesEqualTo(T)"},{"p":"org.hamcrest.number","c":"OrderingComparison","l":"comparesEqualTo(T)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"contains(E...)"},{"p":"org.hamcrest","c":"Matchers","l":"contains(E...)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"contains(List>)","u":"contains(java.util.List)"},{"p":"org.hamcrest","c":"Matchers","l":"contains(List>)","u":"contains(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"contains(Matcher)","u":"contains(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"contains(Matcher)","u":"contains(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"contains(Matcher...)","u":"contains(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"contains(Matcher...)","u":"contains(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"containsInAnyOrder(Collection>)","u":"containsInAnyOrder(java.util.Collection)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInAnyOrder(Collection>)","u":"containsInAnyOrder(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"containsInAnyOrder(Matcher...)","u":"containsInAnyOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInAnyOrder(Matcher...)","u":"containsInAnyOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"containsInAnyOrder(T...)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInAnyOrder(T...)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"containsInRelativeOrder(E...)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInRelativeOrder(E...)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"containsInRelativeOrder(List>)","u":"containsInRelativeOrder(java.util.List)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInRelativeOrder(List>)","u":"containsInRelativeOrder(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"containsInRelativeOrder(Matcher...)","u":"containsInRelativeOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"containsInRelativeOrder(Matcher...)","u":"containsInRelativeOrder(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"StringContains","l":"containsString(String)","u":"containsString(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"containsString(String)","u":"containsString(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"containsString(String)","u":"containsString(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringContains","l":"containsStringIgnoringCase(String)","u":"containsStringIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"containsStringIgnoringCase(String)","u":"containsStringIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"containsStringIgnoringCase(String)","u":"containsStringIgnoringCase(java.lang.String)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"converted(String)","u":"converted(java.lang.String)"},{"p":"org.hamcrest","c":"CustomMatcher","l":"CustomMatcher(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest","c":"CustomTypeSafeMatcher","l":"CustomTypeSafeMatcher(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.core","c":"DescribedAs","l":"describedAs(String, Matcher, Object...)","u":"describedAs(java.lang.String,org.hamcrest.Matcher,java.lang.Object...)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"describedAs(String, Matcher, Object...)","u":"describedAs(java.lang.String,org.hamcrest.Matcher,java.lang.Object...)"},{"p":"org.hamcrest","c":"Matchers","l":"describedAs(String, Matcher, Object...)","u":"describedAs(java.lang.String,org.hamcrest.Matcher,java.lang.Object...)"},{"p":"org.hamcrest.core","c":"DescribedAs","l":"DescribedAs(String, Matcher, Object[])","u":"%3Cinit%3E(java.lang.String,org.hamcrest.Matcher,java.lang.Object[])"},{"p":"org.hamcrest","c":"BaseMatcher","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"DescribedAs","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"Is","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"DiagnosingMatcher","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"Matcher","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"describeMismatch(Object, Description)","u":"describeMismatch(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"BigDecimalCloseTo","l":"describeMismatchSafely(BigDecimal, Description)","u":"describeMismatchSafely(java.math.BigDecimal,org.hamcrest.Description)"},{"p":"org.hamcrest.object","c":"IsCompatibleType","l":"describeMismatchSafely(Class, Description)","u":"describeMismatchSafely(java.lang.Class,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"describeMismatchSafely(Collection, Description)","u":"describeMismatchSafely(java.util.Collection,org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"IsCloseTo","l":"describeMismatchSafely(Double, Description)","u":"describeMismatchSafely(java.lang.Double,org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"IsNaN","l":"describeMismatchSafely(Double, Description)","u":"describeMismatchSafely(java.lang.Double,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"describeMismatchSafely(E[], Description)","u":"describeMismatchSafely(E[],org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"describeMismatchSafely(E[], Description)","u":"describeMismatchSafely(E[],org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"describeMismatchSafely(E[], Description)","u":"describeMismatchSafely(E[],org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"describeMismatchSafely(Iterable, Description)","u":"describeMismatchSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"describeMismatchSafely(Map, Description)","u":"describeMismatchSafely(java.util.Map,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"describeMismatchSafely(String, Description)","u":"describeMismatchSafely(java.lang.String,org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"describeMismatchSafely(String, Description)","u":"describeMismatchSafely(java.lang.String,org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsEqualIgnoringCase","l":"describeMismatchSafely(String, Description)","u":"describeMismatchSafely(java.lang.String,org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"describeMismatchSafely(String, Description)","u":"describeMismatchSafely(java.lang.String,org.hamcrest.Description)"},{"p":"org.hamcrest.beans","c":"HasProperty","l":"describeMismatchSafely(T, Description)","u":"describeMismatchSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"describeMismatchSafely(T, Description)","u":"describeMismatchSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"HasItemInArray","l":"describeMismatchSafely(T[], Description)","u":"describeMismatchSafely(T[],org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArray","l":"describeMismatchSafely(T[], Description)","u":"describeMismatchSafely(T[],org.hamcrest.Description)"},{"p":"org.hamcrest.beans","c":"HasProperty","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.beans","c":"SamePropertyValuesAs","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"HasItemInArray","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArray","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"AllOf","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"DescribedAs","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"Every","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"Is","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsAnything","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsEqual","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsInstanceOf","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsNot","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsNull","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsSame","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"StringRegularExpression","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest","c":"CustomMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest","c":"CustomTypeSafeMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest","c":"FeatureMatcher","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"BigDecimalCloseTo","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"IsCloseTo","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.number","c":"IsNaN","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.object","c":"HasEqualValues","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.object","c":"IsCompatibleType","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.object","c":"IsEventFrom","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest","c":"SelfDescribing","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsBlankString","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"IsEqualIgnoringCase","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"MatchesPattern","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"describeTo(Description)","u":"describeTo(org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"describeTo(Description, String)","u":"describeTo(org.hamcrest.Description,java.lang.String)"},{"p":"org.hamcrest.collection","c":"IsArray","l":"descriptionEnd()"},{"p":"org.hamcrest.collection","c":"IsArray","l":"descriptionSeparator()"},{"p":"org.hamcrest.collection","c":"IsArray","l":"descriptionStart()"},{"p":"org.hamcrest","c":"DiagnosingMatcher","l":"DiagnosingMatcher()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"either(Matcher)","u":"either(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"either(Matcher)","u":"either(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"either(Matcher)","u":"either(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"empty()"},{"p":"org.hamcrest","c":"Matchers","l":"empty()"},{"p":"org.hamcrest.collection","c":"IsArrayWithSize","l":"emptyArray()"},{"p":"org.hamcrest","c":"Matchers","l":"emptyArray()"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"emptyCollectionOf(Class)","u":"emptyCollectionOf(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"emptyCollectionOf(Class)","u":"emptyCollectionOf(java.lang.Class)"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"emptyIterable()"},{"p":"org.hamcrest","c":"Matchers","l":"emptyIterable()"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"emptyIterableOf(Class)","u":"emptyIterableOf(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"emptyIterableOf(Class)","u":"emptyIterableOf(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"emptyOrNullString()"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"emptyOrNullString()"},{"p":"org.hamcrest","c":"Matchers","l":"emptyString()"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"emptyString()"},{"p":"org.hamcrest.core","c":"StringEndsWith","l":"endsWith(String)","u":"endsWith(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"endsWith(String)","u":"endsWith(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"endsWith(String)","u":"endsWith(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringEndsWith","l":"endsWithIgnoringCase(String)","u":"endsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"endsWithIgnoringCase(String)","u":"endsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"endsWithIgnoringCase(String)","u":"endsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest.core","c":"IsEqual","l":"equalTo(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"equalTo(T)"},{"p":"org.hamcrest","c":"Matchers","l":"equalTo(T)"},{"p":"org.hamcrest","c":"Matchers","l":"equalToCompressingWhiteSpace(String)","u":"equalToCompressingWhiteSpace(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"equalToCompressingWhiteSpace(String)","u":"equalToCompressingWhiteSpace(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"equalToIgnoringCase(String)","u":"equalToIgnoringCase(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualIgnoringCase","l":"equalToIgnoringCase(String)","u":"equalToIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"equalToIgnoringWhiteSpace(String)","u":"equalToIgnoringWhiteSpace(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"equalToIgnoringWhiteSpace(String)","u":"equalToIgnoringWhiteSpace(java.lang.String)"},{"p":"org.hamcrest.core","c":"IsEqual","l":"equalToObject(Object)","u":"equalToObject(java.lang.Object)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"equalToObject(Object)","u":"equalToObject(java.lang.Object)"},{"p":"org.hamcrest","c":"Matchers","l":"equalToObject(Object)","u":"equalToObject(java.lang.Object)"},{"p":"org.hamcrest.core","c":"StringContains","l":"evalSubstringOf(String)","u":"evalSubstringOf(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringEndsWith","l":"evalSubstringOf(String)","u":"evalSubstringOf(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringStartsWith","l":"evalSubstringOf(String)","u":"evalSubstringOf(java.lang.String)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"evalSubstringOf(String)","u":"evalSubstringOf(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"eventFrom(Class, Object)","u":"eventFrom(java.lang.Class,java.lang.Object)"},{"p":"org.hamcrest.object","c":"IsEventFrom","l":"eventFrom(Class, Object)","u":"eventFrom(java.lang.Class,java.lang.Object)"},{"p":"org.hamcrest","c":"Matchers","l":"eventFrom(Object)","u":"eventFrom(java.lang.Object)"},{"p":"org.hamcrest.object","c":"IsEventFrom","l":"eventFrom(Object)","u":"eventFrom(java.lang.Object)"},{"p":"org.hamcrest.core","c":"Every","l":"Every(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"Every","l":"everyItem(Matcher)","u":"everyItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"everyItem(Matcher)","u":"everyItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"everyItem(Matcher)","u":"everyItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"EXISTS"},{"p":"org.hamcrest","c":"FeatureMatcher","l":"FeatureMatcher(Matcher, String, String)","u":"%3Cinit%3E(org.hamcrest.Matcher,java.lang.String,java.lang.String)"},{"p":"org.hamcrest.text","c":"CharSequenceLength","l":"featureValueOf(CharSequence)","u":"featureValueOf(java.lang.CharSequence)"},{"p":"org.hamcrest.collection","c":"IsCollectionWithSize","l":"featureValueOf(Collection)","u":"featureValueOf(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsArrayWithSize","l":"featureValueOf(E[])"},{"p":"org.hamcrest.collection","c":"IsIterableWithSize","l":"featureValueOf(Iterable)","u":"featureValueOf(java.lang.Iterable)"},{"p":"org.hamcrest.collection","c":"IsMapWithSize","l":"featureValueOf(Map)","u":"featureValueOf(java.util.Map)"},{"p":"org.hamcrest","c":"FeatureMatcher","l":"featureValueOf(T)"},{"p":"org.hamcrest.object","c":"HasToString","l":"featureValueOf(T)"},{"p":"org.hamcrest.beans","c":"PropertyUtil","l":"getPropertyDescriptor(String, Object)","u":"getPropertyDescriptor(java.lang.String,java.lang.Object)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"getString()"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"greaterThan(T)"},{"p":"org.hamcrest","c":"Matchers","l":"greaterThan(T)"},{"p":"org.hamcrest.number","c":"OrderingComparison","l":"greaterThan(T)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"greaterThanOrEqualTo(T)"},{"p":"org.hamcrest","c":"Matchers","l":"greaterThanOrEqualTo(T)"},{"p":"org.hamcrest.number","c":"OrderingComparison","l":"greaterThanOrEqualTo(T)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasEntry(K, V)","u":"hasEntry(K,V)"},{"p":"org.hamcrest","c":"Matchers","l":"hasEntry(K, V)","u":"hasEntry(K,V)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasEntry(Matcher, Matcher)","u":"hasEntry(org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasEntry(Matcher, Matcher)","u":"hasEntry(org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest.object","c":"HasEqualValues","l":"HasEqualValues(T)","u":"%3Cinit%3E(T)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"hasItem(Matcher)","u":"hasItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"hasItem(Matcher)","u":"hasItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"hasItem(Matcher)","u":"hasItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItem(Matcher)","u":"hasItem(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"hasItem(T)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"hasItem(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"hasItem(T)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItem(T)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"hasItemInArray(Matcher)","u":"hasItemInArray(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItemInArray(Matcher)","u":"hasItemInArray(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"HasItemInArray","l":"HasItemInArray(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"ArrayMatching","l":"hasItemInArray(T)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItemInArray(T)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"hasItems(Matcher...)","u":"hasItems(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"hasItems(Matcher...)","u":"hasItems(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"hasItems(Matcher...)","u":"hasItems(org.hamcrest.Matcher...)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItems(Matcher...)","u":"hasItems(org.hamcrest.Matcher...)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"hasItems(T...)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"hasItems(T...)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"hasItems(T...)"},{"p":"org.hamcrest","c":"Matchers","l":"hasItems(T...)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasKey(K)"},{"p":"org.hamcrest","c":"Matchers","l":"hasKey(K)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasKey(Matcher)","u":"hasKey(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasKey(Matcher)","u":"hasKey(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasLength(int)"},{"p":"org.hamcrest.text","c":"CharSequenceLength","l":"hasLength(int)"},{"p":"org.hamcrest","c":"Matchers","l":"hasLength(Matcher)","u":"hasLength(org.hamcrest.Matcher)"},{"p":"org.hamcrest.text","c":"CharSequenceLength","l":"hasLength(Matcher)","u":"hasLength(org.hamcrest.Matcher)"},{"p":"org.hamcrest.beans","c":"HasProperty","l":"hasProperty(String)","u":"hasProperty(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"hasProperty(String)","u":"hasProperty(java.lang.String)"},{"p":"org.hamcrest.beans","c":"HasProperty","l":"HasProperty(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"hasProperty(String, Matcher)","u":"hasProperty(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasProperty(String, Matcher)","u":"hasProperty(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"hasPropertyAtPath(String, Matcher)","u":"hasPropertyAtPath(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"HasPropertyWithValue(String, Matcher)","u":"%3Cinit%3E(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"HasPropertyWithValue(String, Matcher, String)","u":"%3Cinit%3E(java.lang.String,org.hamcrest.Matcher,java.lang.String)"},{"p":"org.hamcrest.collection","c":"IsCollectionWithSize","l":"hasSize(int)"},{"p":"org.hamcrest","c":"Matchers","l":"hasSize(int)"},{"p":"org.hamcrest.collection","c":"IsCollectionWithSize","l":"hasSize(Matcher)","u":"hasSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasSize(Matcher)","u":"hasSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasToString(Matcher)","u":"hasToString(org.hamcrest.Matcher)"},{"p":"org.hamcrest.object","c":"HasToString","l":"hasToString(Matcher)","u":"hasToString(org.hamcrest.Matcher)"},{"p":"org.hamcrest.object","c":"HasToString","l":"HasToString(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasToString(String)","u":"hasToString(java.lang.String)"},{"p":"org.hamcrest.object","c":"HasToString","l":"hasToString(String)","u":"hasToString(java.lang.String)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasValue(Matcher)","u":"hasValue(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasValue(Matcher)","u":"hasValue(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"hasValue(V)"},{"p":"org.hamcrest","c":"Matchers","l":"hasValue(V)"},{"p":"org.hamcrest","c":"Matchers","l":"hasXPath(String)","u":"hasXPath(java.lang.String)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"hasXPath(String)","u":"hasXPath(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"hasXPath(String, Matcher)","u":"hasXPath(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"hasXPath(String, Matcher)","u":"hasXPath(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"HasXPath(String, Matcher)","u":"%3Cinit%3E(java.lang.String,org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"hasXPath(String, NamespaceContext)","u":"hasXPath(java.lang.String,javax.xml.namespace.NamespaceContext)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"hasXPath(String, NamespaceContext)","u":"hasXPath(java.lang.String,javax.xml.namespace.NamespaceContext)"},{"p":"org.hamcrest","c":"Matchers","l":"hasXPath(String, NamespaceContext, Matcher)","u":"hasXPath(java.lang.String,javax.xml.namespace.NamespaceContext,org.hamcrest.Matcher)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"hasXPath(String, NamespaceContext, Matcher)","u":"hasXPath(java.lang.String,javax.xml.namespace.NamespaceContext,org.hamcrest.Matcher)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"HasXPath(String, NamespaceContext, Matcher)","u":"%3Cinit%3E(java.lang.String,javax.xml.namespace.NamespaceContext,org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"in(Collection)","u":"in(java.util.Collection)"},{"p":"org.hamcrest","c":"Matchers","l":"in(Collection)","u":"in(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"in(T[])"},{"p":"org.hamcrest","c":"Matchers","l":"in(T[])"},{"p":"org.hamcrest.core","c":"IsInstanceOf","l":"instanceOf(Class)","u":"instanceOf(java.lang.Class)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"instanceOf(Class)","u":"instanceOf(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"instanceOf(Class)","u":"instanceOf(java.lang.Class)"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"IS_DIRECTORY"},{"p":"org.hamcrest.io","c":"FileMatchers","l":"IS_FILE"},{"p":"org.hamcrest.core","c":"Is","l":"is(Matcher)","u":"is(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"is(Matcher)","u":"is(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"is(Matcher)","u":"is(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"Is","l":"Is(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"Is","l":"is(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"is(T)"},{"p":"org.hamcrest","c":"Matchers","l":"is(T)"},{"p":"org.hamcrest.core","c":"Is","l":"isA(Class)","u":"isA(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"isA(Class)","u":"isA(java.lang.Class)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"isA(Class)","u":"isA(java.lang.Class)"},{"p":"org.hamcrest.core","c":"IsAnything","l":"IsAnything()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.core","c":"IsAnything","l":"IsAnything(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.collection","c":"IsArray","l":"IsArray(Matcher[])","u":"%3Cinit%3E(org.hamcrest.Matcher[])"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"IsArrayContainingInAnyOrder(Collection>)","u":"%3Cinit%3E(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"IsArrayContainingInOrder(List>)","u":"%3Cinit%3E(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsArrayWithSize","l":"IsArrayWithSize(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.number","c":"IsCloseTo","l":"IsCloseTo(double, double)","u":"%3Cinit%3E(double,double)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"IsCollectionContaining(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsCollectionWithSize","l":"IsCollectionWithSize(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.object","c":"IsCompatibleType","l":"IsCompatibleType(Class)","u":"%3Cinit%3E(java.lang.Class)"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"IsEmptyCollection()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"IsEmptyIterable()","u":"%3Cinit%3E()"},{"p":"org.hamcrest","c":"Matchers","l":"isEmptyOrNullString()"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"isEmptyOrNullString()"},{"p":"org.hamcrest","c":"Matchers","l":"isEmptyString()"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"isEmptyString()"},{"p":"org.hamcrest.core","c":"IsEqual","l":"IsEqual(T)","u":"%3Cinit%3E(T)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"IsEqualCompressingWhiteSpace(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualIgnoringCase","l":"IsEqualIgnoringCase(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.object","c":"IsEventFrom","l":"IsEventFrom(Class, Object)","u":"%3Cinit%3E(java.lang.Class,java.lang.Object)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"isIn(Collection)","u":"isIn(java.util.Collection)"},{"p":"org.hamcrest","c":"Matchers","l":"isIn(Collection)","u":"isIn(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"IsIn(Collection)","u":"%3Cinit%3E(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"isIn(T[])"},{"p":"org.hamcrest","c":"Matchers","l":"isIn(T[])"},{"p":"org.hamcrest.collection","c":"IsIn","l":"IsIn(T[])","u":"%3Cinit%3E(T[])"},{"p":"org.hamcrest.core","c":"IsInstanceOf","l":"IsInstanceOf(Class)","u":"%3Cinit%3E(java.lang.Class)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"IsIterableContaining(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"IsIterableContainingInAnyOrder(Collection>)","u":"%3Cinit%3E(java.util.Collection)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"IsIterableContainingInOrder(List>)","u":"%3Cinit%3E(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"IsIterableContainingInRelativeOrder(List>)","u":"%3Cinit%3E(java.util.List)"},{"p":"org.hamcrest.collection","c":"IsIterableWithSize","l":"IsIterableWithSize(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"IsMapContaining(Matcher, Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher,org.hamcrest.Matcher)"},{"p":"org.hamcrest.collection","c":"IsMapWithSize","l":"IsMapWithSize(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"IsNot","l":"IsNot(Matcher)","u":"%3Cinit%3E(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"BaseMatcher","l":"isNotNull(Object, Description)","u":"isNotNull(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsNull","l":"IsNull()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.collection","c":"IsIn","l":"isOneOf(T...)"},{"p":"org.hamcrest","c":"Matchers","l":"isOneOf(T...)"},{"p":"org.hamcrest.core","c":"IsSame","l":"IsSame(T)","u":"%3Cinit%3E(T)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"iterableMatcher"},{"p":"org.hamcrest.collection","c":"IsIterableWithSize","l":"iterableWithSize(int)"},{"p":"org.hamcrest","c":"Matchers","l":"iterableWithSize(int)"},{"p":"org.hamcrest.collection","c":"IsIterableWithSize","l":"iterableWithSize(Matcher)","u":"iterableWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"iterableWithSize(Matcher)","u":"iterableWithSize(org.hamcrest.Matcher)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"lessThan(T)"},{"p":"org.hamcrest","c":"Matchers","l":"lessThan(T)"},{"p":"org.hamcrest.number","c":"OrderingComparison","l":"lessThan(T)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"lessThanOrEqualTo(T)"},{"p":"org.hamcrest","c":"Matchers","l":"lessThanOrEqualTo(T)"},{"p":"org.hamcrest.number","c":"OrderingComparison","l":"lessThanOrEqualTo(T)"},{"p":"org.hamcrest","c":"Condition","l":"matched(T, Description)","u":"matched(T,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"matchers"},{"p":"org.hamcrest.collection","c":"IsIn","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"DescribedAs","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"Is","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"IsAnything","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"IsEqual","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"IsNot","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"IsNull","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"IsSame","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest","c":"DiagnosingMatcher","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest","c":"Matcher","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"matches(Object)","u":"matches(java.lang.Object)"},{"p":"org.hamcrest.core","c":"AnyOf","l":"matches(Object, boolean)","u":"matches(java.lang.Object,boolean)"},{"p":"org.hamcrest.beans","c":"SamePropertyValuesAs","l":"matches(Object, Description)","u":"matches(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"AllOf","l":"matches(Object, Description)","u":"matches(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsInstanceOf","l":"matches(Object, Description)","u":"matches(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"DiagnosingMatcher","l":"matches(Object, Description)","u":"matches(java.lang.Object,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"Matchers","l":"matchesPattern(Pattern)","u":"matchesPattern(java.util.regex.Pattern)"},{"p":"org.hamcrest.text","c":"MatchesPattern","l":"matchesPattern(Pattern)","u":"matchesPattern(java.util.regex.Pattern)"},{"p":"org.hamcrest.text","c":"MatchesPattern","l":"MatchesPattern(Pattern)","u":"%3Cinit%3E(java.util.regex.Pattern)"},{"p":"org.hamcrest","c":"Matchers","l":"matchesPattern(String)","u":"matchesPattern(java.lang.String)"},{"p":"org.hamcrest.text","c":"MatchesPattern","l":"matchesPattern(String)","u":"matchesPattern(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringRegularExpression","l":"matchesRegex(Pattern)","u":"matchesRegex(java.util.regex.Pattern)"},{"p":"org.hamcrest","c":"Matchers","l":"matchesRegex(Pattern)","u":"matchesRegex(java.util.regex.Pattern)"},{"p":"org.hamcrest.core","c":"StringRegularExpression","l":"matchesRegex(String)","u":"matchesRegex(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"matchesRegex(String)","u":"matchesRegex(java.lang.String)"},{"p":"org.hamcrest.number","c":"BigDecimalCloseTo","l":"matchesSafely(BigDecimal)","u":"matchesSafely(java.math.BigDecimal)"},{"p":"org.hamcrest.object","c":"IsCompatibleType","l":"matchesSafely(Class)","u":"matchesSafely(java.lang.Class)"},{"p":"org.hamcrest.collection","c":"IsEmptyCollection","l":"matchesSafely(Collection)","u":"matchesSafely(java.util.Collection)"},{"p":"org.hamcrest.number","c":"IsCloseTo","l":"matchesSafely(Double)","u":"matchesSafely(java.lang.Double)"},{"p":"org.hamcrest.number","c":"IsNaN","l":"matchesSafely(Double)","u":"matchesSafely(java.lang.Double)"},{"p":"org.hamcrest.collection","c":"ArrayAsIterableMatcher","l":"matchesSafely(E[])"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInAnyOrder","l":"matchesSafely(E[])"},{"p":"org.hamcrest.collection","c":"IsArrayContainingInOrder","l":"matchesSafely(E[])"},{"p":"org.hamcrest.object","c":"IsEventFrom","l":"matchesSafely(EventObject, Description)","u":"matchesSafely(java.util.EventObject,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsEmptyIterable","l":"matchesSafely(Iterable)","u":"matchesSafely(java.lang.Iterable)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInOrder","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInRelativeOrder","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsIterableContainingInAnyOrder","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"Every","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsCollectionContaining","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"IsIterableContaining","l":"matchesSafely(Iterable, Description)","u":"matchesSafely(java.lang.Iterable,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"IsMapContaining","l":"matchesSafely(Map)","u":"matchesSafely(java.util.Map)"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"matchesSafely(Node, Description)","u":"matchesSafely(org.w3c.dom.Node,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsBlankString","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEmptyString","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualIgnoringCase","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"MatchesPattern","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"matchesSafely(String)","u":"matchesSafely(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringRegularExpression","l":"matchesSafely(String, Description)","u":"matchesSafely(java.lang.String,org.hamcrest.Description)"},{"p":"org.hamcrest.beans","c":"HasProperty","l":"matchesSafely(T)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"matchesSafely(T)"},{"p":"org.hamcrest.beans","c":"HasPropertyWithValue","l":"matchesSafely(T, Description)","u":"matchesSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"matchesSafely(T, Description)","u":"matchesSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"FeatureMatcher","l":"matchesSafely(T, Description)","u":"matchesSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest.object","c":"HasEqualValues","l":"matchesSafely(T, Description)","u":"matchesSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"matchesSafely(T, Description)","u":"matchesSafely(T,org.hamcrest.Description)"},{"p":"org.hamcrest.collection","c":"HasItemInArray","l":"matchesSafely(T[])"},{"p":"org.hamcrest.collection","c":"IsArray","l":"matchesSafely(T[])"},{"p":"org.hamcrest","c":"Condition","l":"matching(Matcher)","u":"matching(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Condition","l":"matching(Matcher, String)","u":"matching(org.hamcrest.Matcher,java.lang.String)"},{"p":"org.hamcrest.beans","c":"PropertyUtil","l":"NO_ARGUMENTS"},{"p":"org.hamcrest.xml","c":"HasXPath","l":"NO_NAMESPACE_CONTEXT"},{"p":"org.hamcrest","c":"Description","l":"NONE"},{"p":"org.hamcrest.core","c":"IsNot","l":"not(Matcher)","u":"not(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"not(Matcher)","u":"not(org.hamcrest.Matcher)"},{"p":"org.hamcrest","c":"Matchers","l":"not(Matcher)","u":"not(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"IsNot","l":"not(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"not(T)"},{"p":"org.hamcrest","c":"Matchers","l":"not(T)"},{"p":"org.hamcrest","c":"Matchers","l":"notANumber()"},{"p":"org.hamcrest.number","c":"IsNaN","l":"notANumber()"},{"p":"org.hamcrest","c":"Condition","l":"notMatched()"},{"p":"org.hamcrest.core","c":"IsNull","l":"notNullValue()"},{"p":"org.hamcrest","c":"CoreMatchers","l":"notNullValue()"},{"p":"org.hamcrest","c":"Matchers","l":"notNullValue()"},{"p":"org.hamcrest.core","c":"IsNull","l":"notNullValue(Class)","u":"notNullValue(java.lang.Class)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"notNullValue(Class)","u":"notNullValue(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"notNullValue(Class)","u":"notNullValue(java.lang.Class)"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"NullDescription()","u":"%3Cinit%3E()"},{"p":"org.hamcrest.core","c":"IsNull","l":"nullValue()"},{"p":"org.hamcrest","c":"CoreMatchers","l":"nullValue()"},{"p":"org.hamcrest","c":"Matchers","l":"nullValue()"},{"p":"org.hamcrest.core","c":"IsNull","l":"nullValue(Class)","u":"nullValue(java.lang.Class)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"nullValue(Class)","u":"nullValue(java.lang.Class)"},{"p":"org.hamcrest","c":"Matchers","l":"nullValue(Class)","u":"nullValue(java.lang.Class)"},{"p":"org.hamcrest.collection","c":"IsIn","l":"oneOf(T...)"},{"p":"org.hamcrest","c":"Matchers","l":"oneOf(T...)"},{"p":"org.hamcrest.core","c":"CombinableMatcher","l":"or(Matcher)","u":"or(org.hamcrest.Matcher)"},{"p":"org.hamcrest.core","c":"CombinableMatcher.CombinableEitherMatcher","l":"or(Matcher)","u":"or(org.hamcrest.Matcher)"},{"p":"org.hamcrest.beans","c":"PropertyUtil","l":"propertyDescriptorsFor(Object, Class)","u":"propertyDescriptorsFor(java.lang.Object,java.lang.Class)"},{"p":"org.hamcrest.core","c":"IsSame","l":"sameInstance(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"sameInstance(T)"},{"p":"org.hamcrest","c":"Matchers","l":"sameInstance(T)"},{"p":"org.hamcrest.beans","c":"SamePropertyValuesAs","l":"samePropertyValuesAs(B, String...)","u":"samePropertyValuesAs(B,java.lang.String...)"},{"p":"org.hamcrest","c":"Matchers","l":"samePropertyValuesAs(B, String...)","u":"samePropertyValuesAs(B,java.lang.String...)"},{"p":"org.hamcrest.beans","c":"SamePropertyValuesAs","l":"SamePropertyValuesAs(T, List)","u":"%3Cinit%3E(T,java.util.List)"},{"p":"org.hamcrest.core","c":"StringStartsWith","l":"startsWith(String)","u":"startsWith(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"startsWith(String)","u":"startsWith(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"startsWith(String)","u":"startsWith(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringStartsWith","l":"startsWithIgnoringCase(String)","u":"startsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"startsWithIgnoringCase(String)","u":"startsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"startsWithIgnoringCase(String)","u":"startsWithIgnoringCase(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringContains","l":"StringContains(boolean, String)","u":"%3Cinit%3E(boolean,java.lang.String)"},{"p":"org.hamcrest.core","c":"StringContains","l":"StringContains(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest","c":"Matchers","l":"stringContainsInOrder(Iterable)","u":"stringContainsInOrder(java.lang.Iterable)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"stringContainsInOrder(Iterable)","u":"stringContainsInOrder(java.lang.Iterable)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"StringContainsInOrder(Iterable)","u":"%3Cinit%3E(java.lang.Iterable)"},{"p":"org.hamcrest","c":"Matchers","l":"stringContainsInOrder(String...)","u":"stringContainsInOrder(java.lang.String...)"},{"p":"org.hamcrest.text","c":"StringContainsInOrder","l":"stringContainsInOrder(String...)","u":"stringContainsInOrder(java.lang.String...)"},{"p":"org.hamcrest","c":"StringDescription","l":"StringDescription()","u":"%3Cinit%3E()"},{"p":"org.hamcrest","c":"StringDescription","l":"StringDescription(Appendable)","u":"%3Cinit%3E(java.lang.Appendable)"},{"p":"org.hamcrest.core","c":"StringEndsWith","l":"StringEndsWith(boolean, String)","u":"%3Cinit%3E(boolean,java.lang.String)"},{"p":"org.hamcrest.core","c":"StringEndsWith","l":"StringEndsWith(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.core","c":"StringRegularExpression","l":"StringRegularExpression(Pattern)","u":"%3Cinit%3E(java.util.regex.Pattern)"},{"p":"org.hamcrest.core","c":"StringStartsWith","l":"StringStartsWith(boolean, String)","u":"%3Cinit%3E(boolean,java.lang.String)"},{"p":"org.hamcrest.core","c":"StringStartsWith","l":"StringStartsWith(String)","u":"%3Cinit%3E(java.lang.String)"},{"p":"org.hamcrest.text","c":"IsEqualCompressingWhiteSpace","l":"stripSpaces(String)","u":"stripSpaces(java.lang.String)"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"substring"},{"p":"org.hamcrest.core","c":"SubstringMatcher","l":"SubstringMatcher(String, boolean, String)","u":"%3Cinit%3E(java.lang.String,boolean,java.lang.String)"},{"p":"org.hamcrest.core","c":"IsSame","l":"theInstance(T)"},{"p":"org.hamcrest","c":"CoreMatchers","l":"theInstance(T)"},{"p":"org.hamcrest","c":"Matchers","l":"theInstance(T)"},{"p":"org.hamcrest","c":"Condition","l":"then(Condition.Step)","u":"then(org.hamcrest.Condition.Step)"},{"p":"org.hamcrest","c":"BaseMatcher","l":"toString()"},{"p":"org.hamcrest","c":"Description.NullDescription","l":"toString()"},{"p":"org.hamcrest","c":"StringDescription","l":"toString()"},{"p":"org.hamcrest","c":"StringDescription","l":"toString(SelfDescribing)","u":"toString(org.hamcrest.SelfDescribing)"},{"p":"org.hamcrest","c":"Matchers","l":"typeCompatibleWith(Class)","u":"typeCompatibleWith(java.lang.Class)"},{"p":"org.hamcrest.object","c":"IsCompatibleType","l":"typeCompatibleWith(Class)","u":"typeCompatibleWith(java.lang.Class)"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"TypeSafeDiagnosingMatcher()","u":"%3Cinit%3E()"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"TypeSafeDiagnosingMatcher(Class)","u":"%3Cinit%3E(java.lang.Class)"},{"p":"org.hamcrest","c":"TypeSafeDiagnosingMatcher","l":"TypeSafeDiagnosingMatcher(ReflectiveTypeFinder)","u":"%3Cinit%3E(org.hamcrest.internal.ReflectiveTypeFinder)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"TypeSafeMatcher()","u":"%3Cinit%3E()"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"TypeSafeMatcher(Class)","u":"%3Cinit%3E(java.lang.Class)"},{"p":"org.hamcrest","c":"TypeSafeMatcher","l":"TypeSafeMatcher(ReflectiveTypeFinder)","u":"%3Cinit%3E(org.hamcrest.internal.ReflectiveTypeFinder)"},{"p":"org.hamcrest.comparator","c":"ComparatorMatcherBuilder","l":"usingNaturalOrdering()"}];updateSearchResults(); \ No newline at end of file diff --git a/docs/javadoc/3.0/module-search-index.js b/docs/javadoc/3.0/module-search-index.js new file mode 100644 index 000000000..0d59754fc --- /dev/null +++ b/docs/javadoc/3.0/module-search-index.js @@ -0,0 +1 @@ +moduleSearchIndex = [];updateSearchResults(); \ No newline at end of file diff --git a/docs/javadoc/3.0/org/hamcrest/BaseDescription.html b/docs/javadoc/3.0/org/hamcrest/BaseDescription.html new file mode 100644 index 000000000..5027b4aee --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/BaseDescription.html @@ -0,0 +1,388 @@ + + + + +BaseDescription (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class BaseDescription

+
+
java.lang.Object +
org.hamcrest.BaseDescription
+
+
+
+
All Implemented Interfaces:
+
Description
+
+
+
Direct Known Subclasses:
+
StringDescription
+
+
+
public abstract class BaseDescription +extends Object +implements Description
+
A Description that is stored as a string.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      BaseDescription

      +
      public BaseDescription()
      +
      Default constructor
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      appendText

      +
      public Description appendText(String text)
      +
      Description copied from interface: Description
      +
      Appends some plain text to the description.
      +
      +
      Specified by:
      +
      appendText in interface Description
      +
      Parameters:
      +
      text - the text to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendDescriptionOf

      +
      public Description appendDescriptionOf(SelfDescribing value)
      +
      Description copied from interface: Description
      +
      Appends the description of a SelfDescribing value to this description.
      +
      +
      Specified by:
      +
      appendDescriptionOf in interface Description
      +
      Parameters:
      +
      value - the value to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValue

      +
      public Description appendValue(Object value)
      +
      Description copied from interface: Description
      +
      Appends an arbitrary value to the description.
      +
      +
      Specified by:
      +
      appendValue in interface Description
      +
      Parameters:
      +
      value - the object to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      @SafeVarargs +public final <T> Description appendValueList(String start, + String separator, + String end, + T... values)
      +
      Description copied from interface: Description
      +
      Appends a list of values to the description.
      +
      +
      Specified by:
      +
      appendValueList in interface Description
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      public <T> Description appendValueList(String start, + String separator, + String end, + Iterable<T> values)
      +
      Description copied from interface: Description
      +
      Appends a list of values to the description.
      +
      +
      Specified by:
      +
      appendValueList in interface Description
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendList

      +
      public Description appendList(String start, + String separator, + String end, + Iterable<? extends SelfDescribing> values)
      +
      Description copied from interface: Description
      +
      Appends a list of SelfDescribing objects + to the description.
      +
      +
      Specified by:
      +
      appendList in interface Description
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      append

      +
      protected void append(String str)
      +
      Append the String str to the description. + The default implementation passes every character to append(char). + Override in subclasses to provide an efficient implementation.
      +
      +
      Parameters:
      +
      str - the string to append.
      +
      +
      +
    • +
    • +
      +

      append

      +
      protected abstract void append(char c)
      +
      Append the char c to the description.
      +
      +
      Parameters:
      +
      c - the char to append.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/BaseMatcher.html b/docs/javadoc/3.0/org/hamcrest/BaseMatcher.html new file mode 100644 index 000000000..899e35380 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/BaseMatcher.html @@ -0,0 +1,281 @@ + + + + +BaseMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class BaseMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T>
+
+
+
+
Type Parameters:
+
T - The Matcher type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
AnyOf, CustomMatcher, DescribedAs, DiagnosingMatcher, Is, IsAnything, IsEqual, IsIn, IsNot, IsNull, IsSame, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
public abstract class BaseMatcher<T> +extends Object +implements Matcher<T>
+
BaseClass for all Matcher implementations.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      BaseMatcher

      +
      public BaseMatcher()
      +
      Default constructor.
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      _dont_implement_Matcher___instead_extend_BaseMatcher_

      +
      @Deprecated +public final void _dont_implement_Matcher___instead_extend_BaseMatcher_()
      +
      Deprecated.
      +
      Description copied from interface: Matcher
      +
      This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors .
      +
      +
      Specified by:
      +
      _dont_implement_Matcher___instead_extend_BaseMatcher_ in interface Matcher<T>
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public void describeMismatch(Object item, + Description description)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      toString

      +
      public String toString()
      +
      +
      Overrides:
      +
      toString in class Object
      +
      +
      +
    • +
    • +
      +

      isNotNull

      +
      protected static boolean isNotNull(Object actual, + Description mismatch)
      +
      Useful null-check method. Writes a mismatch description if the actual object is null
      +
      +
      Parameters:
      +
      actual - the object to check
      +
      mismatch - where to write the mismatch description, if any
      +
      Returns:
      +
      false iff the actual object is null
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Condition.Step.html b/docs/javadoc/3.0/org/hamcrest/Condition.Step.html new file mode 100644 index 000000000..9fe914d59 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Condition.Step.html @@ -0,0 +1,160 @@ + + + + +Condition.Step (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Interface Condition.Step<I,O>

+
+
+
+
Type Parameters:
+
I - the initial value type
+
O - the next step value type
+
+
+
Enclosing class:
+
Condition<T>
+
+
+
public static interface Condition.Step<I,O>
+
Represents a single step in a multi-step sequence
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    + +
    apply(I value, + Description mismatch)
    +
    +
    Apply this condition to a value
    +
    +
    +
    +
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      apply

      +
      Condition<O> apply(I value, + Description mismatch)
      +
      Apply this condition to a value
      +
      +
      Parameters:
      +
      value - the value to match
      +
      mismatch - the description for mismatches
      +
      Returns:
      +
      the next condition
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Condition.html b/docs/javadoc/3.0/org/hamcrest/Condition.html new file mode 100644 index 000000000..d8ada2984 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Condition.html @@ -0,0 +1,286 @@ + + + + +Condition (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class Condition<T>

+
+
java.lang.Object +
org.hamcrest.Condition<T>
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
public abstract class Condition<T> +extends Object
+
A Condition implements part of a multi-step match. We sometimes need to write matchers + that have a sequence of steps, where each step depends on the result of the previous + step, and we can stop processing as soon as a step fails. These classes provide + infrastructure for writing such a sequence. + +

Based on Nat Pryce's maybe-java. +

+
+
+
    + +
  • +
    +

    Nested Class Summary

    +
    Nested Classes
    +
    +
    Modifier and Type
    +
    Class
    +
    Description
    +
    static interface 
    + +
    +
    Represents a single step in a multi-step sequence
    +
    +
    +
    +
  • + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    abstract <U> Condition<U>
    +
    and(Condition.Step<? super T,U> mapping)
    +
    +
    Applies the mapping to the current value in the sequence
    +
    +
    static <T> Condition<T>
    +
    matched(T theValue, + Description mismatch)
    +
    +
    Called by steps when a match occurs
    +
    +
    final boolean
    +
    matching(Matcher<T> match)
    +
    +
    Applies the matcher as the final step in the sequence
    +
    +
    abstract boolean
    +
    matching(Matcher<T> match, + String message)
    +
    +
    Applies the matcher as the final step in the sequence
    +
    +
    static <T> Condition<T>
    + +
    +
    Called by steps when a mismatch occurs.
    +
    +
    final <U> Condition<U>
    +
    then(Condition.Step<? super T,U> mapping)
    +
    +
    An alias for and(Step), which applies the mapping to the current value in the + sequence.
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matching

      +
      public abstract boolean matching(Matcher<T> match, + String message)
      +
      Applies the matcher as the final step in the sequence
      +
      +
      Parameters:
      +
      match - the value matcher
      +
      message - a description of the value
      +
      Returns:
      +
      true if the matcher matches the value, otherwise false
      +
      +
      +
    • +
    • +
      +

      matching

      +
      public final boolean matching(Matcher<T> match)
      +
      Applies the matcher as the final step in the sequence
      +
      +
      Parameters:
      +
      match - the value matcher
      +
      Returns:
      +
      true if the matcher matches the value, otherwise false
      +
      +
      +
    • +
    • +
      +

      and

      +
      public abstract <U> Condition<U> and(Condition.Step<? super T,U> mapping)
      +
      Applies the mapping to the current value in the sequence
      +
      +
      Type Parameters:
      +
      U - the type of the next value
      +
      Parameters:
      +
      mapping - the current step in the sequence
      +
      Returns:
      +
      the condition for the next step in the sequence
      +
      +
      +
    • +
    • +
      +

      then

      +
      public final <U> Condition<U> then(Condition.Step<? super T,U> mapping)
      +
      An alias for and(Step), which applies the mapping to the current value in the + sequence.
      +
      +
      Type Parameters:
      +
      U - the type of the next value
      +
      Parameters:
      +
      mapping - the current step in the sequence
      +
      Returns:
      +
      the condition for the next step in the sequence
      +
      +
      +
    • +
    • +
      +

      notMatched

      +
      public static <T> Condition<T> notMatched()
      +
      Called by steps when a mismatch occurs.
      +
      +
      Type Parameters:
      +
      T - the type of the unmatched value
      +
      Returns:
      +
      a condition in the not matched state
      +
      +
      +
    • +
    • +
      +

      matched

      +
      public static <T> Condition<T> matched(T theValue, + Description mismatch)
      +
      Called by steps when a match occurs
      +
      +
      Type Parameters:
      +
      T - the type of the matched value
      +
      Parameters:
      +
      theValue - the value that was matched
      +
      mismatch - a description for potential future mismatches
      +
      Returns:
      +
      the condition in a matched state
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/CoreMatchers.html b/docs/javadoc/3.0/org/hamcrest/CoreMatchers.html new file mode 100644 index 000000000..767ebca6b --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/CoreMatchers.html @@ -0,0 +1,987 @@ + + + + +CoreMatchers (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class CoreMatchers

+
+
java.lang.Object +
org.hamcrest.CoreMatchers
+
+
+
+
public class CoreMatchers +extends Object
+
Builder methods for various matchers. +

+ CodeMatchers provides syntactic sugar for building matchers, or + chains of matchers. By using static imports on these methods, concise and + readable code calling the matchers can be maintained. +

+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    static <T> Matcher<T>
    +
    allOf(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(Matcher<? super T>... matchers)
    +
    +
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    +
    +
    static <T> Matcher<T>
    +
    any(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 + examined object.
    +
    +
    static <T> AnyOf<T>
    +
    anyOf(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(Matcher<? super T>... matchers)
    +
    +
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    +
    +
    static Matcher<Object>
    + +
    +
    Creates a matcher that always matches, regardless of the examined object.
    +
    +
    static Matcher<Object>
    +
    anything(String description)
    +
    +
    Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
    +
    + +
    both(Matcher<? super LHS> matcher)
    +
    +
    Creates a matcher that matches when both of the specified matchers match the examined object.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String contains the specified + String anywhere.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
    +
    +
    static <T> Matcher<T>
    +
    describedAs(String description, + Matcher<T> matcher, + Object... values)
    +
    +
    Wraps an existing matcher, overriding its description with that specified.
    +
    + +
    either(Matcher<? super LHS> matcher)
    +
    +
    Creates a matcher that matches when either of the specified matchers match the examined object.
    +
    +
    static Matcher<String>
    +
    endsWith(String suffix)
    +
    +
    Creates a matcher that matches if the examined String ends with the specified + String.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
    +
    +
    static <T> Matcher<T>
    +
    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 Matcher<Object>
    + +
    +
    Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
    +
    +
    static <U> Matcher<Iterable<? extends U>>
    +
    everyItem(Matcher<U> itemMatcher)
    +
    +
    Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
    +
    +
    static <T> Matcher<Iterable<? super T>>
    +
    hasItem(Matcher<? super T> itemMatcher)
    +
    +
    Creates a matcher for Iterables 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<Iterable<? super T>>
    +
    hasItem(T item)
    +
    +
    Creates a matcher for Iterables 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<Iterable<T>>
    +
    hasItems(Matcher<? super T>... itemMatchers)
    +
    +
    Creates a matcher for Iterables 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<Iterable<T>>
    +
    hasItems(T... items)
    +
    +
    Creates a matcher for Iterables 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>
    +
    instanceOf(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(Matcher<T> matcher)
    +
    +
    Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
    +
    +
    static <T> Matcher<T>
    +
    is(T value)
    +
    +
    A shortcut to the frequently used is(equalTo(x)).
    +
    +
    static <T> Matcher<T>
    +
    isA(Class<T> type)
    +
    +
    A shortcut to the frequently used is(instanceOf(SomeClass.class)).
    +
    +
    static <T> Matcher<T>
    +
    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>
    +
    not(T value)
    +
    +
    A shortcut to the frequently used not(equalTo(x)).
    +
    +
    static Matcher<Object>
    + +
    +
    A shortcut to the frequently used not(nullValue()).
    +
    +
    static <T> Matcher<T>
    + +
    +
    A shortcut to the frequently used not(nullValue(X.class)).
    +
    +
    static Matcher<Object>
    + +
    +
    Creates a matcher that matches if examined object is null.
    +
    +
    static <T> Matcher<T>
    +
    nullValue(Class<T> type)
    +
    +
    Creates a matcher that matches if examined object is null.
    +
    +
    static <T> Matcher<T>
    +
    sameInstance(T target)
    +
    +
    Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
    +
    +
    static Matcher<String>
    + +
    +
    + Creates a matcher that matches if the examined String starts with the specified + String.
    +
    +
    static Matcher<String>
    + +
    +
    + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
    +
    +
    static <T> Matcher<T>
    +
    theInstance(T target)
    +
    +
    Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> allOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      @SafeVarargs +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      @SafeVarargs +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      both

      +
      public static <LHS> +CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
      assertThat("fab", both(containsString("a")).and(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and both must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      either

      +
      public static <LHS> +CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
      assertThat("fan", either(containsString("a")).or(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and either must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      describedAs

      +
      public static <T> Matcher<T> describedAs(String description, + Matcher<T> matcher, + Object... values)
      +
      Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
      describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      description - the new description for the wrapped matcher
      +
      matcher - the matcher to wrap
      +
      values - optional values to insert into the tokenized description
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      everyItem

      +
      public static <U> Matcher<Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
      assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      U - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to every item provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(Matcher<T> matcher)
      +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
      assertThat(cheese, is(equalTo(smelly)))
      + instead of: +
      assertThat(cheese, equalTo(smelly))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to wrap.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(T value)
      +
      A shortcut to the frequently used is(equalTo(x)). + For example: +
      assertThat(cheese, is(smelly))
      + instead of: +
      assertThat(cheese, is(equalTo(smelly)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isA

      +
      public static <T> Matcher<T> isA(Class<T> type)
      +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
      assertThat(cheese, isA(Cheddar.class))
      + instead of: +
      assertThat(cheese, is(instanceOf(Cheddar.class)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything()
      +
      Creates a matcher that always matches, regardless of the examined object.
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything(String description)
      +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      +
      Parameters:
      +
      description - a meaningful String used when describing itself
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(T item)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      item - the item to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(T... items)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalTo

      +
      public static <T> Matcher<T> 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. + +

      If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

      + +

      The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

      + For example: +
      + assertThat("foo", equalTo("foo"));
      + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
      + 
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToObject

      +
      public static Matcher<Object> equalToObject(Object operand)
      +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      any

      +
      public static <T> Matcher<T> any(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 + examined object. + +

      The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

      + For example: +
      assertThat(new Canoe(), any(Canoe.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      instanceOf

      +
      public static <T> Matcher<T> instanceOf(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. + +

      The created matcher assumes no relationship between specified type and the examined object.

      + For example: +
      assertThat(new Canoe(), instanceOf(Paddlable.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(Matcher<T> matcher)
      +
      Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher whose sense should be inverted
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(T value)
      +
      A shortcut to the frequently used not(equalTo(x)). + For example: +
      assertThat(cheese, is(not(smelly)))
      + instead of: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value that any examined object should not equal
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static Matcher<Object> notNullValue()
      +
      A shortcut to the frequently used not(nullValue()). + For example: +
      assertThat(cheese, is(notNullValue()))
      + instead of: +
      assertThat(cheese, is(not(nullValue())))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static <T> Matcher<T> notNullValue(Class<T> type)
      +
      A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
      assertThat(cheese, is(notNullValue(X.class)))
      + instead of: +
      assertThat(cheese, is(not(nullValue(X.class))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static Matcher<Object> nullValue()
      +
      Creates a matcher that matches if examined object is null. + For example: +
      assertThat(cheese, is(nullValue())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static <T> Matcher<T> nullValue(Class<T> type)
      +
      Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
      assertThat(cheese, is(nullValue(Cheese.class))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      sameInstance

      +
      public static <T> Matcher<T> sameInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      theInstance

      +
      public static <T> Matcher<T> theInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsString

      +
      public static Matcher<String> containsString(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
      assertThat("myStringOfNote", containsString("ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsStringIgnoringCase

      +
      public static Matcher<String> containsStringIgnoringCase(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
      assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      startsWith

      +
      public static Matcher<String> startsWith(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String. +

      + For example: +
      assertThat("myStringOfNote", startsWith("my"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      startsWithIgnoringCase

      +
      public static Matcher<String> startsWithIgnoringCase(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

      + For example: +
      assertThat("myStringOfNote", startsWithIgnoringCase("My"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      endsWith

      +
      public static Matcher<String> endsWith(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
      assertThat("myStringOfNote", endsWith("Note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      endsWithIgnoringCase

      +
      public static Matcher<String> endsWithIgnoringCase(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
      assertThat("myStringOfNote", endsWithIgnoringCase("note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/CustomMatcher.html b/docs/javadoc/3.0/org/hamcrest/CustomMatcher.html new file mode 100644 index 000000000..8c3182488 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/CustomMatcher.html @@ -0,0 +1,227 @@ + + + + +CustomMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class CustomMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.CustomMatcher<T>
+
+
+
+
+
Type Parameters:
+
T - The type of object being matched.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public abstract class CustomMatcher<T> +extends BaseMatcher<T>
+
Utility class for writing one off matchers. + For example: +
+ Matcher<String> aNonEmptyString = new CustomMatcher<String>("a non empty string") {
+   public boolean matches(Object object) {
+     return ((object instanceof String) && !((String) object).isEmpty();
+   }
+ };
+ 
+

+ This class is designed for scenarios where an anonymous inner class + matcher makes sense. It should not be used by API designers implementing + matchers. See CustomTypeSafeMatcher for a type safe variant of + this class that you probably want to use.

+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      CustomMatcher

      +
      public CustomMatcher(String description)
      +
      Constructor
      +
      +
      Parameters:
      +
      description - the description of this matcher
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      describeTo

      +
      public final void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/CustomTypeSafeMatcher.html b/docs/javadoc/3.0/org/hamcrest/CustomTypeSafeMatcher.html new file mode 100644 index 000000000..e3ad151ba --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/CustomTypeSafeMatcher.html @@ -0,0 +1,222 @@ + + + + +CustomTypeSafeMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class CustomTypeSafeMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeMatcher<T> +
org.hamcrest.CustomTypeSafeMatcher<T>
+
+
+
+
+
+
Type Parameters:
+
T - The type of object being matched
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public abstract class CustomTypeSafeMatcher<T> +extends TypeSafeMatcher<T>
+
Utility class for writing one off matchers (with type safety and null checks). + For example: +
+ Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
+   public boolean matchesSafely(String string) {
+     return !string.isEmpty();
+   }
+   public void describeMismatchSafely(String string, Description mismatchDescription) {
+     mismatchDescription.appendText("was empty");
+   }
+ };
+ 
+ This is a variant of CustomMatcher that first type checks + the argument being matched. By the time TypeSafeMatcher.matchesSafely(T) is + called the argument is guaranteed to be non-null and of the correct type.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      CustomTypeSafeMatcher

      +
      public CustomTypeSafeMatcher(String description)
      +
      Constructor
      +
      +
      Parameters:
      +
      description - the description of this matcher
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      describeTo

      +
      public final void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Description.NullDescription.html b/docs/javadoc/3.0/org/hamcrest/Description.NullDescription.html new file mode 100644 index 000000000..e36b0228b --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Description.NullDescription.html @@ -0,0 +1,366 @@ + + + + +Description.NullDescription (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class Description.NullDescription

+
+
java.lang.Object +
org.hamcrest.Description.NullDescription
+
+
+
+
All Implemented Interfaces:
+
Description
+
+
+
Enclosing interface:
+
Description
+
+
+
public static final class Description.NullDescription +extends Object +implements Description
+
A description that consumes input but does nothing.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      NullDescription

      +
      public NullDescription()
      +
      Constructor.
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      appendDescriptionOf

      +
      public Description appendDescriptionOf(SelfDescribing value)
      +
      Description copied from interface: Description
      +
      Appends the description of a SelfDescribing value to this description.
      +
      +
      Specified by:
      +
      appendDescriptionOf in interface Description
      +
      Parameters:
      +
      value - the value to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendList

      +
      public Description appendList(String start, + String separator, + String end, + Iterable<? extends SelfDescribing> values)
      +
      Description copied from interface: Description
      +
      Appends a list of SelfDescribing objects + to the description.
      +
      +
      Specified by:
      +
      appendList in interface Description
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendText

      +
      public Description appendText(String text)
      +
      Description copied from interface: Description
      +
      Appends some plain text to the description.
      +
      +
      Specified by:
      +
      appendText in interface Description
      +
      Parameters:
      +
      text - the text to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValue

      +
      public Description appendValue(Object value)
      +
      Description copied from interface: Description
      +
      Appends an arbitrary value to the description.
      +
      +
      Specified by:
      +
      appendValue in interface Description
      +
      Parameters:
      +
      value - the object to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      public <T> Description appendValueList(String start, + String separator, + String end, + T... values)
      +
      Description copied from interface: Description
      +
      Appends a list of values to the description.
      +
      +
      Specified by:
      +
      appendValueList in interface Description
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      public <T> Description appendValueList(String start, + String separator, + String end, + Iterable<T> values)
      +
      Description copied from interface: Description
      +
      Appends a list of values to the description.
      +
      +
      Specified by:
      +
      appendValueList in interface Description
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      toString

      +
      public String toString()
      +
      +
      Overrides:
      +
      toString in class Object
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Description.html b/docs/javadoc/3.0/org/hamcrest/Description.html new file mode 100644 index 000000000..d12d09e87 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Description.html @@ -0,0 +1,335 @@ + + + + +Description (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Interface Description

+
+
+
+
All Known Implementing Classes:
+
BaseDescription, Description.NullDescription, StringDescription
+
+
+
public interface Description
+
A description of a Matcher. A Matcher will describe itself to a description + which can later be used for reporting.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      appendText

      +
      Description appendText(String text)
      +
      Appends some plain text to the description.
      +
      +
      Parameters:
      +
      text - the text to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendDescriptionOf

      +
      Description appendDescriptionOf(SelfDescribing value)
      +
      Appends the description of a SelfDescribing value to this description.
      +
      +
      Parameters:
      +
      value - the value to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValue

      +
      Description appendValue(Object value)
      +
      Appends an arbitrary value to the description.
      +
      +
      Parameters:
      +
      value - the object to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      <T> Description appendValueList(String start, + String separator, + String end, + T... values)
      +
      Appends a list of values to the description.
      +
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendValueList

      +
      <T> Description appendValueList(String start, + String separator, + String end, + Iterable<T> values)
      +
      Appends a list of values to the description.
      +
      +
      Type Parameters:
      +
      T - the description type.
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    • +
      +

      appendList

      +
      Description appendList(String start, + String separator, + String end, + Iterable<? extends SelfDescribing> values)
      +
      Appends a list of SelfDescribing objects + to the description.
      +
      +
      Parameters:
      +
      start - the prefix.
      +
      separator - the separator.
      +
      end - the suffix.
      +
      values - the values to append.
      +
      Returns:
      +
      the update description when displaying the matcher error.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/DiagnosingMatcher.html b/docs/javadoc/3.0/org/hamcrest/DiagnosingMatcher.html new file mode 100644 index 000000000..ebf29fab7 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/DiagnosingMatcher.html @@ -0,0 +1,280 @@ + + + + +DiagnosingMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class DiagnosingMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.DiagnosingMatcher<T>
+
+
+
+
+
Type Parameters:
+
T - the type of matcher being diagnosed.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
AllOf, IsInstanceOf, SamePropertyValuesAs
+
+
+
public abstract class DiagnosingMatcher<T> +extends BaseMatcher<T>
+
Convenient base class for Matchers of a specific type and that will report why the + received value has been rejected. + + Unlike the TypeSafeDiagnosingMatcher, this does not implement the null check + or validate the type, so subclasses need to be prepared to handle these conditions. + + To use, implement matches(Object, Description)
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      DiagnosingMatcher

      +
      public DiagnosingMatcher()
      +
      Constructor
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public final boolean matches(Object item)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      item - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public final void describeMismatch(Object item, + Description mismatchDescription)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Overrides:
      +
      describeMismatch in class BaseMatcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      mismatchDescription - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      matches

      +
      protected abstract boolean matches(Object item, + Description mismatchDescription)
      +
      Evaluates the matcher for argument item.
      +
      +
      Parameters:
      +
      item - the value to check
      +
      mismatchDescription - the description for the matcher
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/FeatureMatcher.html b/docs/javadoc/3.0/org/hamcrest/FeatureMatcher.html new file mode 100644 index 000000000..6f4094ab1 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/FeatureMatcher.html @@ -0,0 +1,263 @@ + + + + +FeatureMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class FeatureMatcher<T,U>

+
+ +
+
+
Type Parameters:
+
T - The type of the object to be matched
+
U - The type of the feature to be matched
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
CharSequenceLength, HasToString, IsArrayWithSize, IsCollectionWithSize, IsIterableWithSize, IsMapWithSize
+
+
+
public abstract class FeatureMatcher<T,U> +extends TypeSafeDiagnosingMatcher<T>
+
Supporting class for matching a feature of an object. Implement featureValueOf() + in a subclass to pull out the feature to be matched against.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      FeatureMatcher

      +
      public FeatureMatcher(Matcher<? super U> subMatcher, + String featureDescription, + String featureName)
      +
      Constructor
      +
      +
      Parameters:
      +
      subMatcher - The matcher to apply to the feature
      +
      featureDescription - Descriptive text to use in describeTo
      +
      featureName - Identifying text for mismatch message
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected abstract U featureValueOf(T actual)
      +
      Implement this to extract the interesting feature.
      +
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(T actual, + Description mismatch)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<T>
      +
      Parameters:
      +
      actual - the item.
      +
      mismatch - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public final void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Matcher.html b/docs/javadoc/3.0/org/hamcrest/Matcher.html new file mode 100644 index 000000000..e016272a8 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Matcher.html @@ -0,0 +1,253 @@ + + + + +Matcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Interface Matcher<T>

+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Superinterfaces:
+
SelfDescribing
+
+
+
All Known Implementing Classes:
+
AllOf, AnyOf, ArrayAsIterableMatcher, BaseMatcher, BigDecimalCloseTo, CharSequenceLength, CombinableMatcher, CustomMatcher, CustomTypeSafeMatcher, DescribedAs, DiagnosingMatcher, Every, FeatureMatcher, HasEqualValues, HasItemInArray, HasProperty, HasPropertyWithValue, HasToString, HasXPath, Is, IsAnything, IsArray, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsArrayWithSize, IsBlankString, IsCloseTo, IsCollectionContaining, IsCollectionWithSize, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEmptyString, IsEqual, IsEqualCompressingWhiteSpace, IsEqualIgnoringCase, IsEventFrom, IsIn, IsInstanceOf, IsIterableContaining, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, IsIterableContainingInRelativeOrder, IsIterableWithSize, IsMapContaining, IsMapWithSize, IsNaN, IsNot, IsNull, IsSame, MatchesPattern, SamePropertyValuesAs, StringContains, StringContainsInOrder, StringEndsWith, StringRegularExpression, StringStartsWith, SubstringMatcher, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
public interface Matcher<T> +extends SelfDescribing
+

+ A matcher over acceptable values. + A matcher is able to describe itself to give feedback when it fails. +

+

+ Matcher implementations should NOT directly implement this interface. + Instead, extend the BaseMatcher abstract class, + which will ensure that the Matcher API can grow to support + new features and remain compatible with all Matcher implementations. +

+

+ When using Hamcrest, there is no guarantee as to how often matches() or + describeMismatch() will be called, so the objects passed as + actual arguments should not change when referenced. If you're testing a + stream, a good practice is to collect the contents of the stream before matching. +

+

+ N.B. Well designed matchers should be immutable. +

+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      boolean matches(Object actual)
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      actual - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      void describeMismatch(Object actual, + Description mismatchDescription)
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Parameters:
      +
      actual - The item that the Matcher has rejected.
      +
      mismatchDescription - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      _dont_implement_Matcher___instead_extend_BaseMatcher_

      +
      @Deprecated +void _dont_implement_Matcher___instead_extend_BaseMatcher_()
      +
      Deprecated. +
      to make
      +
      +
      This method simply acts a friendly reminder not to implement Matcher directly and + instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore + compile errors .
      +
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/MatcherAssert.html b/docs/javadoc/3.0/org/hamcrest/MatcherAssert.html new file mode 100644 index 000000000..77747b4ae --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/MatcherAssert.html @@ -0,0 +1,202 @@ + + + + +MatcherAssert (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class MatcherAssert

+
+
java.lang.Object +
org.hamcrest.MatcherAssert
+
+
+
+
public class MatcherAssert +extends Object
+
The Hamcrest entrypoint, static methods to check if matchers match a + given value.
+
+
+ +
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      assertThat

      +
      public static <T> void assertThat(T actual, + Matcher<? super T> matcher)
      +
      Checks that a value matches a matcher
      +
      +
      Type Parameters:
      +
      T - the type of the value
      +
      Parameters:
      +
      actual - the value to check
      +
      matcher - the matcher
      +
      +
      +
    • +
    • +
      +

      assertThat

      +
      public static <T> void assertThat(String reason, + T actual, + Matcher<? super T> matcher)
      +
      Checks that a value matches a matcher
      +
      +
      Type Parameters:
      +
      T - the type of the value
      +
      Parameters:
      +
      reason - a description of what is being matched
      +
      actual - the value to check
      +
      matcher - the matcher
      +
      +
      +
    • +
    • +
      +

      assertThat

      +
      public static void assertThat(String reason, + boolean assertion)
      +
      Checks that an assertion is true
      +
      +
      Parameters:
      +
      reason - a description of what is being checked
      +
      assertion - the result of the check
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/Matchers.html b/docs/javadoc/3.0/org/hamcrest/Matchers.html new file mode 100644 index 000000000..0da1c54f7 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/Matchers.html @@ -0,0 +1,3401 @@ + + + + +Matchers (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class Matchers

+
+
java.lang.Object +
org.hamcrest.Matchers
+
+
+
+
public class Matchers +extends Object
+
Builder methods for various matchers. +

+ Matchers provides syntactic sugar for building matchers, or + chains of matchers. By using static imports on these methods, concise and + readable code calling the matchers can be maintained. +

+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    static <T> Matcher<T>
    +
    allOf(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(Matcher<? super T>... matchers)
    +
    +
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    +
    +
    static <T> Matcher<T>
    +
    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(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(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(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(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 <K, +V> Matcher<Map<? extends K,? extends V>>
    +
    aMapWithSize(int size)
    +
    +
    Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size.
    +
    +
    static <K, +V> Matcher<Map<? extends K,? extends V>>
    +
    aMapWithSize(Matcher<? super Integer> sizeMatcher)
    +
    +
    Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher.
    +
    +
    static <K, +V> Matcher<Map<? extends K,? extends V>>
    + +
    +
    Creates a matcher for Maps that matches when the size() method returns + zero.
    +
    +
    static <T> Matcher<T>
    +
    any(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 + examined object.
    +
    +
    static <T> AnyOf<T>
    +
    anyOf(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(Matcher<? super T>... matchers)
    +
    +
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    +
    +
    static <T> AnyOf<T>
    +
    anyOf(Matcher<? super 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(Matcher<? super 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(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 ANY of the specified matchers.
    +
    +
    static <T> AnyOf<T>
    +
    anyOf(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 ANY of the specified matchers.
    +
    +
    static <T> AnyOf<T>
    +
    anyOf(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 ANY of the specified matchers.
    +
    +
    static Matcher<Object>
    + +
    +
    Creates a matcher that always matches, regardless of the examined object.
    +
    +
    static Matcher<Object>
    +
    anything(String description)
    +
    +
    Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
    +
    +
    static <T> IsArray<T>
    +
    array(Matcher<? super T>... elementMatchers)
    +
    +
    Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
    +
    +
    static <E> Matcher<E[]>
    +
    arrayContaining(E... items)
    +
    +
    Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
    +
    +
    static <E> Matcher<E[]>
    +
    arrayContaining(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[]>
    +
    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[]>
    + +
    +
    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[]>
    +
    arrayContainingInAnyOrder(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[]>
    +
    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[]>
    +
    arrayWithSize(int size)
    +
    +
    Creates a matcher for arrays that matches when the length of the array + equals the specified size.
    +
    +
    static <E> Matcher<E[]>
    +
    arrayWithSize(Matcher<? super Integer> sizeMatcher)
    +
    +
    Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else.
    +
    + +
    both(Matcher<? super LHS> matcher)
    +
    +
    Creates a matcher that matches when both of the specified matchers match the examined object.
    +
    +
    static Matcher<Double>
    +
    closeTo(double operand, + double error)
    +
    +
    Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error.
    +
    + +
    closeTo(BigDecimal operand, + BigDecimal error)
    +
    +
    Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error.
    +
    +
    static <T extends Comparable<T>>
    Matcher<T>
    +
    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 <E> Matcher<Iterable<? extends E>>
    +
    contains(E... items)
    +
    +
    Creates a matcher for Iterables 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<Iterable<? extends E>>
    +
    contains(List<Matcher<? super E>> itemMatchers)
    +
    +
    Creates a matcher for Iterables 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<Iterable<? extends E>>
    +
    contains(Matcher<? super E> itemMatcher)
    +
    +
    Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher.
    +
    +
    static <E> Matcher<Iterable<? extends E>>
    +
    contains(Matcher<? super E>... itemMatchers)
    +
    +
    Creates a matcher for Iterables 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 <T> Matcher<Iterable<? extends T>>
    +
    containsInAnyOrder(Collection<Matcher<? super T>> itemMatchers)
    +
    +
    + Creates an order agnostic matcher for Iterables 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 <T> Matcher<Iterable<? extends T>>
    +
    containsInAnyOrder(Matcher<? super T>... itemMatchers)
    +
    +
    + Creates an order agnostic matcher for Iterables 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<Iterable<? extends T>>
    +
    containsInAnyOrder(T... items)
    +
    +
    + Creates an order agnostic matcher for Iterables 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<Iterable<? extends E>>
    + +
    +
    Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example:
    +
    +
    static <E> Matcher<Iterable<? extends E>>
    +
    containsInRelativeOrder(List<Matcher<? super E>> itemMatchers)
    +
    +
    Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order.
    +
    +
    static <E> Matcher<Iterable<? extends E>>
    +
    containsInRelativeOrder(Matcher<? super E>... itemMatchers)
    +
    +
    Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String contains the specified + String anywhere.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case.
    +
    +
    static <T> Matcher<T>
    +
    describedAs(String description, + Matcher<T> matcher, + Object... values)
    +
    +
    Wraps an existing matcher, overriding its description with that specified.
    +
    + +
    either(Matcher<? super LHS> matcher)
    +
    +
    Creates a matcher that matches when either of the specified matchers match the examined object.
    +
    +
    static <E> Matcher<Collection<? extends E>>
    + +
    +
    Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
    +
    +
    static <E> Matcher<E[]>
    + +
    +
    Creates a matcher for arrays that matches when the length of the array + is zero.
    +
    +
    static <E> Matcher<Collection<E>>
    +
    emptyCollectionOf(Class<E> unusedToForceReturnType)
    +
    +
    Creates a matcher for Collections matching examined collections whose isEmpty + method returns true.
    +
    +
    static <E> Matcher<Iterable<? extends E>>
    + +
    +
    Creates a matcher for Iterables matching examined iterables that yield no items.
    +
    +
    static <E> Matcher<Iterable<E>>
    +
    emptyIterableOf(Class<E> unusedToForceReturnType)
    +
    +
    Creates a matcher for Iterables matching examined iterables that yield no items.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string is null, or + has zero length.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string has zero length.
    +
    +
    static Matcher<String>
    +
    endsWith(String suffix)
    +
    +
    Creates a matcher that matches if the examined String ends with the specified + String.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher that matches if the examined String ends with the specified + String, ignoring case.
    +
    +
    static <T> Matcher<T>
    +
    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 Matcher<String>
    + +
    +
    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<String>
    +
    equalToIgnoringCase(String expectedString)
    +
    +
    Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case.
    +
    +
    static Matcher<String>
    + + +
    static Matcher<Object>
    + +
    +
    Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
    +
    + +
    eventFrom(Class<? extends EventObject> eventClass, + Object source)
    +
    +
    Creates a matcher of EventObject that matches any object + derived from eventClass announced by source.
    +
    + +
    eventFrom(Object source)
    +
    +
    Creates a matcher of EventObject that matches any EventObject + announced by source.
    +
    +
    static <U> Matcher<Iterable<? extends U>>
    +
    everyItem(Matcher<U> itemMatcher)
    +
    +
    Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher.
    +
    +
    static <T extends Comparable<T>>
    Matcher<T>
    +
    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 Comparable<T>>
    Matcher<T>
    + +
    +
    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 <K, +V> Matcher<Map<? extends K,? extends V>>
    +
    hasEntry(K key, + V value)
    +
    +
    Creates a matcher for Maps 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<Map<? extends K,? extends V>>
    +
    hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher)
    +
    +
    Creates a matcher for Maps 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<Iterable<? super T>>
    +
    hasItem(Matcher<? super T> itemMatcher)
    +
    +
    Creates a matcher for Iterables 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<Iterable<? super T>>
    +
    hasItem(T item)
    +
    +
    Creates a matcher for Iterables 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<T[]>
    +
    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[]>
    +
    hasItemInArray(T element)
    +
    +
    A shortcut to the frequently used hasItemInArray(equalTo(x)).
    +
    +
    static <T> Matcher<Iterable<T>>
    +
    hasItems(Matcher<? super T>... itemMatchers)
    +
    +
    Creates a matcher for Iterables 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<Iterable<T>>
    +
    hasItems(T... items)
    +
    +
    Creates a matcher for Iterables 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 <K> Matcher<Map<? extends K,?>>
    +
    hasKey(K key)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
    +
    +
    static <K> Matcher<Map<? extends K,?>>
    +
    hasKey(Matcher<? super K> keyMatcher)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
    +
    + +
    hasLength(int length)
    +
    +
    Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument.
    +
    + +
    hasLength(Matcher<? super Integer> lengthMatcher)
    +
    +
    Creates a matcher of CharSequence that matches when a char sequence has the length + that satisfies the specified matcher.
    +
    +
    static <T> Matcher<T>
    +
    hasProperty(String propertyName)
    +
    +
    Creates a matcher that matches when the examined object has a JavaBean property + with the specified name.
    +
    +
    static <T> Matcher<T>
    +
    hasProperty(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 <E> Matcher<Collection<? extends E>>
    +
    hasSize(int size)
    +
    +
    Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size.
    +
    +
    static <E> Matcher<Collection<? extends E>>
    +
    hasSize(Matcher<? super Integer> sizeMatcher)
    +
    +
    Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher.
    +
    +
    static <T> Matcher<T>
    +
    hasToString(String expectedToString)
    +
    +
    Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string.
    +
    +
    static <T> Matcher<T>
    +
    hasToString(Matcher<? super String> toStringMatcher)
    +
    +
    Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher.
    +
    +
    static <V> Matcher<Map<?,? extends V>>
    +
    hasValue(Matcher<? super V> valueMatcher)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
    +
    +
    static <V> Matcher<Map<?,? extends V>>
    +
    hasValue(V value)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
    +
    +
    static Matcher<Node>
    + +
    +
    Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content.
    +
    +
    static Matcher<Node>
    +
    hasXPath(String xPath, + NamespaceContext namespaceContext)
    +
    +
    Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content.
    +
    +
    static Matcher<Node>
    +
    hasXPath(String xPath, + NamespaceContext namespaceContext, + Matcher<String> valueMatcher)
    +
    +
    Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher.
    +
    +
    static Matcher<Node>
    +
    hasXPath(String xPath, + Matcher<String> valueMatcher)
    +
    +
    Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher.
    +
    +
    static <T> Matcher<T>
    +
    in(Collection<T> collection)
    +
    +
    Creates a matcher that matches when the examined object is found within the + specified collection.
    +
    +
    static <T> Matcher<T>
    +
    in(T[] elements)
    +
    +
    Creates a matcher that matches when the examined object is found within the + specified array.
    +
    +
    static <T> Matcher<T>
    +
    instanceOf(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(Matcher<T> matcher)
    +
    +
    Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive.
    +
    +
    static <T> Matcher<T>
    +
    is(T value)
    +
    +
    A shortcut to the frequently used is(equalTo(x)).
    +
    +
    static <T> Matcher<T>
    +
    isA(Class<?> type)
    +
    +
    A shortcut to the frequently used is(instanceOf(SomeClass.class)).
    +
    +
    static Matcher<String>
    + +
    +
    Deprecated. +
    use is(emptyOrNullString()) instead
    +
    +
    +
    static Matcher<String>
    + +
    +
    Deprecated. +
    use is(emptyString()) instead
    +
    +
    +
    static <T> Matcher<T>
    +
    isIn(Collection<T> collection)
    +
    +
    Deprecated. +
    use is(in(...)) instead
    +
    +
    +
    static <T> Matcher<T>
    +
    isIn(T[] elements)
    +
    +
    Deprecated. +
    use is(in(...)) instead
    +
    +
    +
    static <T> Matcher<T>
    +
    isOneOf(T... elements)
    +
    +
    Deprecated. +
    use is(oneOf(...)) instead
    +
    +
    +
    static <E> Matcher<Iterable<E>>
    +
    iterableWithSize(int size)
    +
    +
    Creates a matcher for Iterables 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<Iterable<E>>
    +
    iterableWithSize(Matcher<? super Integer> sizeMatcher)
    +
    +
    Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher.
    +
    +
    static <T extends Comparable<T>>
    Matcher<T>
    +
    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 Comparable<T>>
    Matcher<T>
    + +
    +
    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.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
    +
    +
    static Matcher<String>
    + +
    +
    Validate a string with a regex.
    +
    +
    static Matcher<String>
    + +
    +
    Validate a string with a Pattern.
    +
    +
    static <T> Matcher<T>
    +
    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>
    +
    not(T value)
    +
    +
    A shortcut to the frequently used not(equalTo(x)).
    +
    +
    static Matcher<Double>
    + +
    +
    Creates a matcher of Doubles that matches when an examined double is not a number.
    +
    +
    static Matcher<Object>
    + +
    +
    A shortcut to the frequently used not(nullValue()).
    +
    +
    static <T> Matcher<T>
    + +
    +
    A shortcut to the frequently used not(nullValue(X.class)).
    +
    +
    static Matcher<Object>
    + +
    +
    Creates a matcher that matches if examined object is null.
    +
    +
    static <T> Matcher<T>
    +
    nullValue(Class<T> type)
    +
    +
    Creates a matcher that matches if examined object is null.
    +
    +
    static <T> Matcher<T>
    +
    oneOf(T... elements)
    +
    +
    Creates a matcher that matches when the examined object is equal to one of the + specified elements.
    +
    +
    static <T> Matcher<T>
    +
    sameInstance(T target)
    +
    +
    Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
    +
    +
    static <B> Matcher<B>
    +
    samePropertyValuesAs(B expectedBean, + String... ignoredProperties)
    +
    +
    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.
    +
    +
    static Matcher<String>
    + +
    +
    + Creates a matcher that matches if the examined String starts with the specified + String.
    +
    +
    static Matcher<String>
    + +
    +
    + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
    +
    +
    static Matcher<String>
    + +
    +
    Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance.
    +
    +
    static <T> Matcher<T>
    +
    theInstance(T target)
    +
    +
    Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
    +
    +
    static <T> Matcher<Class<?>>
    + +
    +
    Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class.
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> allOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      @SafeVarargs +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> allOf(Matcher<? super T> first, + Matcher<? super T> second)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher that must pass.
      +
      second - second matcher that must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> 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. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher that must pass.
      +
      second - second matcher that must pass.
      +
      third - third matcher that must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> 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. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher that must pass.
      +
      second - second matcher that must pass.
      +
      third - third matcher that must pass.
      +
      fourth - fourth matcher that must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> 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. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher that must pass.
      +
      second - second matcher that must pass.
      +
      third - third matcher that must pass.
      +
      fourth - fourth matcher that must pass.
      +
      fifth - fifth matcher that must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> 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. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher that must pass.
      +
      second - second matcher that must pass.
      +
      third - third matcher that must pass.
      +
      fourth - fourth matcher that must pass.
      +
      fifth - fifth matcher that must pass.
      +
      sixth - sixth matcher that must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      @SafeVarargs +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(Matcher<? super T> first, + Matcher<? super T> second)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher to check.
      +
      second - second matcher to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(Matcher<? super 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. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher to check.
      +
      second - second matcher to check.
      +
      third - third matcher to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher to check.
      +
      second - second matcher to check.
      +
      third - third matcher to check.
      +
      fourth - fourth matcher to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher to check.
      +
      second - second matcher to check.
      +
      third - third matcher to check.
      +
      fourth - fourth matcher to check.
      +
      fifth - fifth matcher to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(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 ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      first - first matcher to check.
      +
      second - second matcher to check.
      +
      third - third matcher to check.
      +
      fourth - fourth matcher to check.
      +
      fifth - fifth matcher to check.
      +
      sixth - sixth matcher to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      both

      +
      public static <LHS> +CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
      assertThat("fab", both(containsString("a")).and(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and both must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      either

      +
      public static <LHS> +CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
      assertThat("fan", either(containsString("a")).or(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and either must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      describedAs

      +
      public static <T> Matcher<T> describedAs(String description, + Matcher<T> matcher, + Object... values)
      +
      Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
      describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      description - the new description for the wrapped matcher
      +
      matcher - the matcher to wrap
      +
      values - optional values to insert into the tokenized description
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      everyItem

      +
      public static <U> Matcher<Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
      assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      U - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to every item provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(Matcher<T> matcher)
      +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
      assertThat(cheese, is(equalTo(smelly)))
      + instead of: +
      assertThat(cheese, equalTo(smelly))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to wrap.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(T value)
      +
      A shortcut to the frequently used is(equalTo(x)). + For example: +
      assertThat(cheese, is(smelly))
      + instead of: +
      assertThat(cheese, is(equalTo(smelly)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isA

      +
      public static <T> Matcher<T> isA(Class<?> type)
      +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
      assertThat(cheese, isA(Cheddar.class))
      + instead of: +
      assertThat(cheese, is(instanceOf(Cheddar.class)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything()
      +
      Creates a matcher that always matches, regardless of the examined object.
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything(String description)
      +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      +
      Parameters:
      +
      description - a meaningful String used when describing itself
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(T item)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      item - the item to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(T... items)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalTo

      +
      public static <T> Matcher<T> 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. + +

      If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

      + +

      The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

      + For example: +
      + assertThat("foo", equalTo("foo"));
      + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
      + 
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToObject

      +
      public static Matcher<Object> equalToObject(Object operand)
      +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      any

      +
      public static <T> Matcher<T> any(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 + examined object. + +

      The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

      + For example: +
      assertThat(new Canoe(), instanceOf(Canoe.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      instanceOf

      +
      public static <T> Matcher<T> instanceOf(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. + +

      The created matcher assumes no relationship between specified type and the examined object.

      + For example: +
      assertThat(new Canoe(), instanceOf(Paddlable.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(Matcher<T> matcher)
      +
      Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher whose sense should be inverted
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(T value)
      +
      A shortcut to the frequently used not(equalTo(x)). + For example: +
      assertThat(cheese, is(not(smelly)))
      + instead of: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value that any examined object should not equal
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static Matcher<Object> notNullValue()
      +
      A shortcut to the frequently used not(nullValue()). + For example: +
      assertThat(cheese, is(notNullValue()))
      + instead of: +
      assertThat(cheese, is(not(nullValue())))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static <T> Matcher<T> notNullValue(Class<T> type)
      +
      A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
      assertThat(cheese, is(notNullValue(X.class)))
      + instead of: +
      assertThat(cheese, is(not(nullValue(X.class))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static Matcher<Object> nullValue()
      +
      Creates a matcher that matches if examined object is null. + For example: +
      assertThat(cheese, is(nullValue())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static <T> Matcher<T> nullValue(Class<T> type)
      +
      Creates a matcher that matches if examined object is null. Accepts a + single dummy argument to facilitate type inference. + For example: +
      assertThat(cheese, is(nullValue(Cheese.class))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      sameInstance

      +
      public static <T> Matcher<T> sameInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      theInstance

      +
      public static <T> Matcher<T> theInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsString

      +
      public static Matcher<String> containsString(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
      assertThat("myStringOfNote", containsString("ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsStringIgnoringCase

      +
      public static Matcher<String> containsStringIgnoringCase(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
      assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      startsWith

      +
      public static Matcher<String> startsWith(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String. +

      + For example: +
      assertThat("myStringOfNote", startsWith("my"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      startsWithIgnoringCase

      +
      public static Matcher<String> startsWithIgnoringCase(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

      + For example: +
      assertThat("myStringOfNote", startsWithIgnoringCase("My"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      endsWith

      +
      public static Matcher<String> endsWith(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
      assertThat("myStringOfNote", endsWith("Note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      endsWithIgnoringCase

      +
      public static Matcher<String> endsWithIgnoringCase(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
      assertThat("myStringOfNote", endsWithIgnoringCase("note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesRegex

      +
      public static Matcher<String> matchesRegex(Pattern pattern)
      +
      Validate a string with a Pattern. + +
      + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
      + 
      +
      +
      Parameters:
      +
      pattern - the pattern to be used.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesRegex

      +
      public static Matcher<String> matchesRegex(String regex)
      +
      Validate a string with a regex. + +
      + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
      + 
      +
      +
      Parameters:
      +
      regex - The regex to be used for the validation.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      array

      +
      @SafeVarargs +public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
      +
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
      assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elementMatchers - the matchers that the elements of examined arrays should satisfy
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItemInArray

      +
      public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
      assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elementMatcher - the matcher to apply to elements in examined arrays
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItemInArray

      +
      public static <T> Matcher<T[]> hasItemInArray(T element)
      +
      A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
      assertThat(hasItemInArray(x))
      + instead of: +
      assertThat(hasItemInArray(equalTo(x)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      element - the element that should be present in examined arrays
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      @SafeVarargs +public static <E> Matcher<E[]> arrayContaining(E... items)
      +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayContaining("foo", "bar"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items within an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items in the examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      public static <E> Matcher<E[]> arrayContaining(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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

      +

      + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      public static <E> Matcher<E[]> arrayContainingInAnyOrder(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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

      +

      + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

      +

      N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder("bar", "foo"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the entries of an examined array, in any order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayWithSize

      +
      public static <E> Matcher<E[]> arrayWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the length of an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayWithSize

      +
      public static <E> Matcher<E[]> arrayWithSize(int size)
      +
      Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the length that an examined array must have for a positive match
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyArray

      +
      public static <E> Matcher<E[]> emptyArray()
      +
      Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
      assertThat(new String[0], emptyArray())
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      aMapWithSize

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> aMapWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
      assertThat(myMap, is(aMapWithSize(equalTo(2))))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the size of an examined Map
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      aMapWithSize

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> aMapWithSize(int size)
      +
      Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
      assertThat(myMap, is(aMapWithSize(2)))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      size - the expected size of an examined Map
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anEmptyMap

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> anEmptyMap()
      +
      Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
      assertThat(myMap, is(anEmptyMap()))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasSize

      +
      public static <E> Matcher<Collection<? extends E>> hasSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the size of an examined Collection
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasSize

      +
      public static <E> Matcher<Collection<? extends E>> hasSize(int size)
      +
      Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the expected size of an examined Collection
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      empty

      +
      public static <E> Matcher<Collection<? extends E>> empty()
      +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
      assertThat(new ArrayList<String>(), is(empty()))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyCollectionOf

      +
      public static <E> Matcher<Collection<E>> emptyCollectionOf(Class<E> unusedToForceReturnType)
      +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
      assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      unusedToForceReturnType - the type of the collection's content
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyIterable

      +
      public static <E> Matcher<Iterable<? extends E>> emptyIterable()
      +
      Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
      assertThat(new ArrayList<String>(), is(emptyIterable()))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyIterableOf

      +
      public static <E> Matcher<Iterable<E>> emptyIterableOf(Class<E> unusedToForceReturnType)
      +
      Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
      assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      unusedToForceReturnType - the type of the iterable's content
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> contains(E... items)
      +
      Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      public static <E> Matcher<Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
      assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      public static <E> Matcher<Iterable<? extends E>> contains(List<Matcher<? super E>> itemMatchers)
      +
      Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      @SafeVarargs +public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
      +

      + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

      +

      + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

      +

      + For example: +

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      @SafeVarargs +public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(T... items)
      +

      + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

      +

      + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

      +

      + For example: +

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items provided by an examined Iterable in any order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Collection<Matcher<? super T>> itemMatchers)
      +

      + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

      +

      + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

      +

      For example:

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(E... items)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must be contained within items provided by an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(List<Matcher<? super E>> itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      iterableWithSize

      +
      public static <E> Matcher<Iterable<E>> iterableWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
      assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      iterableWithSize

      +
      public static <E> Matcher<Iterable<E>> iterableWithSize(int size)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
      assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the number of items that should be yielded by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasEntry

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
      assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
      +
      valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasEntry

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> hasEntry(K key, + V value)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
      assertThat(myMap, hasEntry("bar", "foo"))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      key - the key that, in combination with the value, must be describe at least one entry
      +
      value - the value that, in combination with the key, must be describe at least one entry
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasKey

      +
      public static <K> Matcher<Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
      assertThat(myMap, hasKey(equalTo("bar")))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      Parameters:
      +
      keyMatcher - the matcher that must be satisfied by at least one key
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasKey

      +
      public static <K> Matcher<Map<? extends K,?>> hasKey(K key)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
      assertThat(myMap, hasKey("bar"))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      Parameters:
      +
      key - the key that satisfying maps must contain
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasValue

      +
      public static <V> Matcher<Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
      assertThat(myMap, hasValue(equalTo("foo")))
      +
      +
      Type Parameters:
      +
      V - the value type.
      +
      Parameters:
      +
      valueMatcher - the matcher that must be satisfied by at least one value
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasValue

      +
      public static <V> Matcher<Map<?,? extends V>> hasValue(V value)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
      assertThat(myMap, hasValue("foo"))
      +
      +
      Type Parameters:
      +
      V - the value type.
      +
      Parameters:
      +
      value - the value that satisfying maps must contain
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      in

      +
      public static <T> Matcher<T> in(Collection<T> collection)
      +
      Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
      assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      collection - the collection in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      in

      +
      public static <T> Matcher<T> in(T[] elements)
      +
      Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
      assertThat("foo", is(in(new String[]{"bar", "foo"})))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the array in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isIn

      +
      public static <T> Matcher<T> isIn(Collection<T> collection)
      +
      Deprecated. +
      use is(in(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
      assertThat("foo", isIn(Arrays.asList("bar", "foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      collection - the collection in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isIn

      +
      public static <T> Matcher<T> isIn(T[] elements)
      +
      Deprecated. +
      use is(in(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
      assertThat("foo", isIn(new String[]{"bar", "foo"}))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the array in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isOneOf

      +
      @SafeVarargs +public static <T> Matcher<T> isOneOf(T... elements)
      +
      Deprecated. +
      use is(oneOf(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
      assertThat("foo", isOneOf("bar", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the elements amongst which matching items will be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      oneOf

      +
      @SafeVarargs +public static <T> Matcher<T> oneOf(T... elements)
      +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
      assertThat("foo", is(oneOf("bar", "foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the elements amongst which matching items will be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      closeTo

      +
      public static Matcher<Double> closeTo(double operand, + double error)
      +
      Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
      assertThat(1.03, is(closeTo(1.0, 0.03)))
      +
      +
      Parameters:
      +
      operand - the expected value of matching doubles
      +
      error - the delta (+/-) within which matches will be allowed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notANumber

      +
      public static Matcher<Double> notANumber()
      +
      Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
      assertThat(Double.NaN, is(notANumber()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      closeTo

      +
      public static Matcher<BigDecimal> closeTo(BigDecimal operand, + BigDecimal error)
      +
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
      assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
      +
      +
      Parameters:
      +
      operand - the expected value of matching BigDecimals
      +
      error - the delta (+/-) within which matches will be allowed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      comparesEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, comparesEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThan

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(2, greaterThan(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThanOrEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, greaterThanOrEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThan

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, lessThan(2))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThanOrEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, lessThanOrEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToIgnoringCase

      +
      public static Matcher<String> equalToIgnoringCase(String expectedString)
      +
      Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
      assertThat("Foo", equalToIgnoringCase("FOO"))
      +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToIgnoringWhiteSpace

      +
      public static Matcher<String> equalToIgnoringWhiteSpace(String expectedString)
      + +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToCompressingWhiteSpace

      +
      public static Matcher<String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
        +
      • all leading and trailing whitespace of both the expectedString and the examined string are ignored
      • +
      • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
      • +
      + For example: +
      assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
      +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyOrNullString

      +
      public static Matcher<String> emptyOrNullString()
      +
      Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
      assertThat(((String)null), is(emptyOrNullString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyString

      +
      public static Matcher<String> emptyString()
      +
      Creates a matcher of String that matches when the examined string has zero length. + For example: +
      assertThat("", is(emptyString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isEmptyOrNullString

      +
      public static Matcher<String> isEmptyOrNullString()
      +
      Deprecated. +
      use is(emptyOrNullString()) instead
      +
      +
      Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
      assertThat(((String)null), isEmptyOrNullString())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isEmptyString

      +
      public static Matcher<String> isEmptyString()
      +
      Deprecated. +
      use is(emptyString()) instead
      +
      +
      Creates a matcher of String that matches when the examined string has zero length. + For example: +
      assertThat("", isEmptyString())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      blankOrNullString

      +
      public static Matcher<String> blankOrNullString()
      +
      Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
      assertThat(((String)null), is(blankOrNullString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      blankString

      +
      public static Matcher<String> blankString()
      +
      Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
      assertThat("  ", is(blankString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesPattern

      +
      public static Matcher<String> matchesPattern(Pattern pattern)
      +
      Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
      +
      +
      Parameters:
      +
      pattern - the text pattern to match.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesPattern

      +
      public static Matcher<String> matchesPattern(String regex)
      +
      Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
      +
      +
      Parameters:
      +
      regex - the regex to match.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      stringContainsInOrder

      +
      public static Matcher<String> stringContainsInOrder(Iterable<String> substrings)
      +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
      assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
      + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
      +
      +
      Parameters:
      +
      substrings - the substrings that must be contained within matching strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      stringContainsInOrder

      +
      public static Matcher<String> stringContainsInOrder(String... substrings)
      +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
      assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
      + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
      +
      +
      Parameters:
      +
      substrings - the substrings that must be contained within matching strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasLength

      +
      public static Matcher<CharSequence> hasLength(Matcher<? super Integer> lengthMatcher)
      +
      Creates a matcher of CharSequence that matches when a char sequence has the length + that satisfies the specified matcher. + For example: + +
      + assertThat("text", hasLength(lessThan(4)))
      + 
      +
      +
      Parameters:
      +
      lengthMatcher - a matcher for the expected length of the string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasLength

      +
      public static Matcher<CharSequence> hasLength(int length)
      +
      Creates a matcher of CharSequence that matches when a char sequence has the length + of the specified argument. + For example: + +
      + assertThat("text", length(4))
      + 
      +
      +
      Parameters:
      +
      length - the expected length of the string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasToString

      +
      public static <T> Matcher<T> hasToString(Matcher<? super String> toStringMatcher)
      +
      Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher. + For example: +
      assertThat(true, hasToString(equalTo("TRUE")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      toStringMatcher - the matcher used to verify the toString result
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasToString

      +
      public static <T> Matcher<T> hasToString(String expectedToString)
      +
      Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
      assertThat(true, hasToString("TRUE"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      expectedToString - the expected toString result
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      typeCompatibleWith

      +
      public static <T> Matcher<Class<?>> typeCompatibleWith(Class<T> baseType)
      +
      Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
      assertThat(Integer.class, typeCompatibleWith(Number.class))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      baseType - the base class to examine classes against
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      eventFrom

      +
      public static Matcher<EventObject> eventFrom(Class<? extends EventObject> eventClass, + Object source)
      +
      Creates a matcher of EventObject that matches any object + derived from eventClass announced by source. + For example: +
      assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
      +
      +
      Parameters:
      +
      eventClass - the class of the event to match on
      +
      source - the source of the event
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      eventFrom

      +
      public static Matcher<EventObject> eventFrom(Object source)
      +
      Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
      assertThat(myEvent, is(eventFrom(myBean)))
      +
      +
      Parameters:
      +
      source - the source of the event
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasProperty

      +
      public static <T> Matcher<T> hasProperty(String propertyName)
      +
      Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
      assertThat(myBean, hasProperty("foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      propertyName - the name of the JavaBean property that examined beans should possess
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasProperty

      +
      public static <T> Matcher<T> hasProperty(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. + For example: +
      assertThat(myBean, hasProperty("foo", equalTo("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      propertyName - the name of the JavaBean property that examined beans should possess
      +
      valueMatcher - a matcher for the value of the specified property of the examined bean
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      samePropertyValuesAs

      +
      public static <B> Matcher<B> samePropertyValuesAs(B expectedBean, + String... ignoredProperties)
      +
      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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example
      age
      rather than method names such as
      getAge
      . + For example: +
      assertThat(myBean, samePropertyValuesAs(myExpectedBean))
      +
      assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
      +
      +
      Type Parameters:
      +
      B - the matcher type.
      +
      Parameters:
      +
      expectedBean - the bean against which examined beans are compared
      +
      ignoredProperties - do not check any of these named properties.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + Matcher<String> valueMatcher)
      +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      valueMatcher - matcher for the value at the specified xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + NamespaceContext namespaceContext, + Matcher<String> valueMatcher)
      +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      namespaceContext - the namespace for matching nodes
      +
      valueMatcher - matcher for the value at the specified xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath)
      +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese"))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + NamespaceContext namespaceContext)
      +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      namespaceContext - the namespace for matching nodes
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/SelfDescribing.html b/docs/javadoc/3.0/org/hamcrest/SelfDescribing.html new file mode 100644 index 000000000..afebd6a96 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/SelfDescribing.html @@ -0,0 +1,156 @@ + + + + +SelfDescribing (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Interface SelfDescribing

+
+
+
+
All Known Subinterfaces:
+
Matcher<T>
+
+
+
All Known Implementing Classes:
+
AllOf, AnyOf, ArrayAsIterableMatcher, BaseMatcher, BigDecimalCloseTo, CharSequenceLength, CombinableMatcher, CustomMatcher, CustomTypeSafeMatcher, DescribedAs, DiagnosingMatcher, Every, FeatureMatcher, HasEqualValues, HasItemInArray, HasProperty, HasPropertyWithValue, HasToString, HasXPath, Is, IsAnything, IsArray, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsArrayWithSize, IsBlankString, IsCloseTo, IsCollectionContaining, IsCollectionWithSize, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEmptyString, IsEqual, IsEqualCompressingWhiteSpace, IsEqualIgnoringCase, IsEventFrom, IsIn, IsInstanceOf, IsIterableContaining, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, IsIterableContainingInRelativeOrder, IsIterableWithSize, IsMapContaining, IsMapWithSize, IsNaN, IsNot, IsNull, IsSame, MatchesPattern, SamePropertyValuesAs, StringContains, StringContainsInOrder, StringEndsWith, StringRegularExpression, StringStartsWith, SubstringMatcher, TypeSafeDiagnosingMatcher, TypeSafeMatcher
+
+
+
public interface SelfDescribing
+
The ability of an object to describe itself.
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    void
    +
    describeTo(Description description)
    +
    +
    Generates a description of the object.
    +
    +
    +
    +
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      describeTo

      +
      void describeTo(Description description)
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/StringDescription.html b/docs/javadoc/3.0/org/hamcrest/StringDescription.html new file mode 100644 index 000000000..efdacdf2e --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/StringDescription.html @@ -0,0 +1,301 @@ + + + + +StringDescription (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class StringDescription

+
+
java.lang.Object +
org.hamcrest.BaseDescription +
org.hamcrest.StringDescription
+
+
+
+
+
All Implemented Interfaces:
+
Description
+
+
+
public class StringDescription +extends BaseDescription
+
A Description that is stored as a string.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringDescription

      +
      public StringDescription()
      +
      Creates a new description.
      +
      +
    • +
    • +
      +

      StringDescription

      +
      public StringDescription(Appendable out)
      +
      Creates a new description using the given appendable.
      +
      +
      Parameters:
      +
      out - the place to append the description.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      toString

      +
      public static String toString(SelfDescribing selfDescribing)
      +
      Return the description of a SelfDescribing object as a String.
      +
      +
      Parameters:
      +
      selfDescribing - The object to be described.
      +
      Returns:
      +
      The description of the object.
      +
      +
      +
    • +
    • +
      +

      asString

      +
      public static String asString(SelfDescribing selfDescribing)
      + +
      +
      Parameters:
      +
      selfDescribing - The object to be described.
      +
      Returns:
      +
      The description of the object.
      +
      +
      +
    • +
    • +
      +

      append

      +
      protected void append(String str)
      +
      Description copied from class: BaseDescription
      +
      Append the String str to the description. + The default implementation passes every character to BaseDescription.append(char). + Override in subclasses to provide an efficient implementation.
      +
      +
      Overrides:
      +
      append in class BaseDescription
      +
      Parameters:
      +
      str - the string to append.
      +
      +
      +
    • +
    • +
      +

      append

      +
      protected void append(char c)
      +
      Description copied from class: BaseDescription
      +
      Append the char c to the description.
      +
      +
      Specified by:
      +
      append in class BaseDescription
      +
      Parameters:
      +
      c - the char to append.
      +
      +
      +
    • +
    • +
      +

      toString

      +
      public String toString()
      +
      Returns the description as a string.
      +
      +
      Overrides:
      +
      toString in class Object
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/TypeSafeDiagnosingMatcher.html b/docs/javadoc/3.0/org/hamcrest/TypeSafeDiagnosingMatcher.html new file mode 100644 index 000000000..7da594ed8 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/TypeSafeDiagnosingMatcher.html @@ -0,0 +1,316 @@ + + + + +TypeSafeDiagnosingMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class TypeSafeDiagnosingMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeDiagnosingMatcher<T>
+
+
+
+
+
Type Parameters:
+
T - the matcher type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
CombinableMatcher, Every, FeatureMatcher, HasEqualValues, HasPropertyWithValue, HasXPath, IsCollectionContaining, IsEventFrom, IsIterableContaining, IsIterableContainingInAnyOrder, IsIterableContainingInOrder, IsIterableContainingInRelativeOrder, StringRegularExpression
+
+
+
public abstract class TypeSafeDiagnosingMatcher<T> +extends BaseMatcher<T>
+
Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected. + This implements the null check, checks the type and then casts. + To use, implement matchesSafely(Object, Description).
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      TypeSafeDiagnosingMatcher

      +
      protected TypeSafeDiagnosingMatcher(Class<?> expectedType)
      +
      Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
      +
      +
      Parameters:
      +
      expectedType - The expectedType of the actual value.
      +
      +
      +
    • +
    • +
      +

      TypeSafeDiagnosingMatcher

      +
      protected TypeSafeDiagnosingMatcher(org.hamcrest.internal.ReflectiveTypeFinder typeFinder)
      +
      Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
      +
      +
      Parameters:
      +
      typeFinder - A type finder to extract the type
      +
      +
      +
    • +
    • +
      +

      TypeSafeDiagnosingMatcher

      +
      protected TypeSafeDiagnosingMatcher()
      +
      The default constructor for simple sub types
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected abstract boolean matchesSafely(T item, + Description mismatchDescription)
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Parameters:
      +
      item - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      matches

      +
      public final boolean matches(Object item)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      item - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public final void describeMismatch(Object item, + Description mismatchDescription)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Overrides:
      +
      describeMismatch in class BaseMatcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      mismatchDescription - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/TypeSafeMatcher.html b/docs/javadoc/3.0/org/hamcrest/TypeSafeMatcher.html new file mode 100644 index 000000000..5e56502be --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/TypeSafeMatcher.html @@ -0,0 +1,319 @@ + + + + +TypeSafeMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+
Package org.hamcrest
+

Class TypeSafeMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeMatcher<T>
+
+
+
+
+
Type Parameters:
+
T - the matcher type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
ArrayAsIterableMatcher, BigDecimalCloseTo, CustomTypeSafeMatcher, HasItemInArray, HasProperty, IsArray, IsArrayContainingInAnyOrder, IsArrayContainingInOrder, IsBlankString, IsCloseTo, IsCompatibleType, IsEmptyCollection, IsEmptyIterable, IsEmptyString, IsEqualCompressingWhiteSpace, IsEqualIgnoringCase, IsMapContaining, IsNaN, MatchesPattern, StringContainsInOrder, SubstringMatcher
+
+
+
public abstract class TypeSafeMatcher<T> +extends BaseMatcher<T>
+
Convenient base class for Matchers that require a non-null value of a specific type. + This simply implements the null check, checks the type and then casts.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      TypeSafeMatcher

      +
      protected TypeSafeMatcher()
      +
      The default constructor for simple sub types
      +
      +
    • +
    • +
      +

      TypeSafeMatcher

      +
      protected TypeSafeMatcher(Class<?> expectedType)
      +
      Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
      +
      +
      Parameters:
      +
      expectedType - The expectedType of the actual value.
      +
      +
      +
    • +
    • +
      +

      TypeSafeMatcher

      +
      protected TypeSafeMatcher(org.hamcrest.internal.ReflectiveTypeFinder typeFinder)
      +
      Use this constructor if the subclass that implements matchesSafely + is not the class that binds <T> to a type.
      +
      +
      Parameters:
      +
      typeFinder - A type finder to extract the type
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected abstract boolean matchesSafely(T item)
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      protected void describeMismatchSafely(T item, + Description mismatchDescription)
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      matches

      +
      public final boolean matches(Object item)
      +
      Methods made final to prevent accidental override. + If you need to override this, there's no point on extending TypeSafeMatcher. + Instead, extend the BaseMatcher.
      +
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public final void describeMismatch(Object item, + Description description)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Overrides:
      +
      describeMismatch in class BaseMatcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/HasProperty.html b/docs/javadoc/3.0/org/hamcrest/beans/HasProperty.html new file mode 100644 index 000000000..243dab5aa --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/HasProperty.html @@ -0,0 +1,285 @@ + + + + +HasProperty (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasProperty<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeMatcher<T> +
org.hamcrest.beans.HasProperty<T>
+
+
+
+
+
+
Type Parameters:
+
T - The Matcher type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class HasProperty<T> +extends TypeSafeMatcher<T>
+
A matcher that checks if an object has a JavaBean property with the + specified name. If an error occurs during introspection of the object + then this is treated as a mismatch.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(T obj)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<T>
      +
      Parameters:
      +
      obj - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(T item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<T>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasProperty

      +
      public static <T> Matcher<T> hasProperty(String propertyName)
      +
      Creates a matcher that matches when the examined object has a JavaBean property + with the specified name. + For example: +
      assertThat(myBean, hasProperty("foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      propertyName - the name of the JavaBean property that examined beans should possess
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/HasPropertyWithValue.html b/docs/javadoc/3.0/org/hamcrest/beans/HasPropertyWithValue.html new file mode 100644 index 000000000..87cf15582 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/HasPropertyWithValue.html @@ -0,0 +1,361 @@ + + + + +HasPropertyWithValue (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasPropertyWithValue<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeDiagnosingMatcher<T> +
org.hamcrest.beans.HasPropertyWithValue<T>
+
+
+
+
+
+
Type Parameters:
+
T - the Matcher type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class HasPropertyWithValue<T> +extends TypeSafeDiagnosingMatcher<T>
+

A matcher that checks if an object has a JavaBean property with the + specified name and an expected value. This is useful for when objects are + created within code under test and passed to a mock object, and you wish + to assert that the created object has certain properties. +

+ +

Example Usage

+ Consider the situation where we have a class representing a person, which + follows the basic JavaBean convention of having get() and possibly set() + methods for it's properties: +
 public class Person {
+   private String name;
+   public Person(String person) {
+     this.person = person;
+   }
+   public String getName() {
+     return name;
+   }
+ } 
+ + And that these person objects are generated within a piece of code under test + (a class named PersonGenerator). This object is sent to one of our mock objects + which overrides the PersonGenerationListener interface: +
 public interface PersonGenerationListener {
+   public void personGenerated(Person person);
+ } 
+ + In order to check that the code under test generates a person with name + "Iain" we would do the following: +
 Mock personGenListenerMock = mock(PersonGenerationListener.class);
+ personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
+ PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy(); 
+ +

If an exception is thrown by the getter method for a property, the property + does not exist, is not readable, or a reflection related exception is thrown + when trying to invoke it then this is treated as an evaluation failure and + the matches method will return false. +

+

This matcher class will also work with JavaBean objects that have explicit + bean descriptions via an associated BeanInfo description class. + See https://docs.oracle.com/javase/8/docs/technotes/guides/beans/index.html for + more information on JavaBeans. +

+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(T bean, + Description mismatch)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<T>
      +
      Parameters:
      +
      bean - the item.
      +
      mismatch - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasProperty

      +
      public static <T> Matcher<T> hasProperty(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. + For example: +
      assertThat(myBean, hasProperty("foo", equalTo("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      propertyName - the name of the JavaBean property that examined beans should possess
      +
      valueMatcher - a matcher for the value of the specified property of the examined bean
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasPropertyAtPath

      +
      public static <T> Matcher<T> hasPropertyAtPath(String path, + Matcher<T> valueMatcher)
      +
      Creates a matcher that matches when the examined object is a graph of + JavaBean objects that can be navigated along the declared dot-separated path + and the final element of that path is a JavaBean property whose value satisfies the + specified matcher. + For example: +
      assertThat(myBean, hasProperty("foo.bar.baz", equalTo("a property value"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      path - the dot-separated path from the examined object to the JavaBean property
      +
      valueMatcher - a matcher for the value of the specified property of the examined bean
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/PropertyUtil.html b/docs/javadoc/3.0/org/hamcrest/beans/PropertyUtil.html new file mode 100644 index 000000000..852e56e42 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/PropertyUtil.html @@ -0,0 +1,225 @@ + + + + +PropertyUtil (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class PropertyUtil

+
+
java.lang.Object +
org.hamcrest.beans.PropertyUtil
+
+
+
+
public class PropertyUtil +extends Object
+
Utility class with static methods for accessing properties on JavaBean objects. + See https://docs.oracle.com/javase/8/docs/technotes/guides/beans/index.html for + more information on JavaBeans.
+
+
Since:
+
1.1.0
+
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    +
      +
    • +
      +

      NO_ARGUMENTS

      +
      public static final Object[] NO_ARGUMENTS
      +
      Empty object array, used for documenting that we are deliberately passing no arguments to a method.
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      getPropertyDescriptor

      +
      public static PropertyDescriptor getPropertyDescriptor(String propertyName, + Object fromObj) + throws IllegalArgumentException
      +
      Returns the description of the property with the provided + name on the provided object's interface.
      +
      +
      Parameters:
      +
      propertyName - the bean property name.
      +
      fromObj - the object to check.
      +
      Returns:
      +
      the descriptor of the property, or null if the property does not exist.
      +
      Throws:
      +
      IllegalArgumentException - if there's a introspection failure
      +
      +
      +
    • +
    • +
      +

      propertyDescriptorsFor

      +
      public static PropertyDescriptor[] propertyDescriptorsFor(Object fromObj, + Class<Object> stopClass) + throws IllegalArgumentException
      +
      Returns all the property descriptors for the class associated with the given object
      +
      +
      Parameters:
      +
      fromObj - Use the class of this object
      +
      stopClass - Don't include any properties from this ancestor class upwards.
      +
      Returns:
      +
      Property descriptors
      +
      Throws:
      +
      IllegalArgumentException - if there's a introspection failure
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/SamePropertyValuesAs.html b/docs/javadoc/3.0/org/hamcrest/beans/SamePropertyValuesAs.html new file mode 100644 index 000000000..52f5718a5 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/SamePropertyValuesAs.html @@ -0,0 +1,280 @@ + + + + +SamePropertyValuesAs (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class SamePropertyValuesAs<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.DiagnosingMatcher<T> +
org.hamcrest.beans.SamePropertyValuesAs<T>
+
+
+
+
+
+
Type Parameters:
+
T - the matcher value type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class SamePropertyValuesAs<T> +extends DiagnosingMatcher<T>
+
A matcher that checks if a given bean has the same property values + as an example bean.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      SamePropertyValuesAs

      +
      public SamePropertyValuesAs(T expectedBean, + List<String> ignoredProperties)
      +
      Constructor, best called from samePropertyValuesAs(Object, String...).
      +
      +
      Parameters:
      +
      expectedBean - the bean object with the expected values
      +
      ignoredProperties - list of property names that should be excluded from the match
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      protected boolean matches(Object actual, + Description mismatch)
      +
      Description copied from class: DiagnosingMatcher
      +
      Evaluates the matcher for argument item.
      +
      +
      Specified by:
      +
      matches in class DiagnosingMatcher<T>
      +
      Parameters:
      +
      actual - the value to check
      +
      mismatch - the description for the matcher
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      samePropertyValuesAs

      +
      public static <B> Matcher<B> samePropertyValuesAs(B expectedBean, + String... ignoredProperties)
      +

      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. If any properties are marked as ignored, they will be dropped from + both the expected and actual bean. Note that the ignored properties use JavaBean + display names, for example "age" rather than method names such as + "getAge". +

      + For example: +
      
      + assertThat(myBean, samePropertyValuesAs(myExpectedBean))
      + assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
      + 
      +
      +
      Type Parameters:
      +
      B - the matcher value type.
      +
      Parameters:
      +
      expectedBean - the bean against which examined beans are compared
      +
      ignoredProperties - do not check any of these named properties.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/package-summary.html b/docs/javadoc/3.0/org/hamcrest/beans/package-summary.html new file mode 100644 index 000000000..9346e97f5 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/package-summary.html @@ -0,0 +1,124 @@ + + + + +org.hamcrest.beans (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.beans

+
+
+
package org.hamcrest.beans
+
+
Matchers of Java Bean properties and their values.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    A matcher that checks if an object has a JavaBean property with the + specified name.
    +
    + +
    +
    A matcher that checks if an object has a JavaBean property with the + specified name and an expected value.
    +
    + +
    +
    Utility class with static methods for accessing properties on JavaBean objects.
    +
    + +
    +
    A matcher that checks if a given bean has the same property values + as an example bean.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/beans/package-tree.html b/docs/javadoc/3.0/org/hamcrest/beans/package-tree.html new file mode 100644 index 000000000..e7600483d --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/beans/package-tree.html @@ -0,0 +1,90 @@ + + + + +org.hamcrest.beans Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.beans

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/ArrayAsIterableMatcher.html b/docs/javadoc/3.0/org/hamcrest/collection/ArrayAsIterableMatcher.html new file mode 100644 index 000000000..3e65057be --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/ArrayAsIterableMatcher.html @@ -0,0 +1,310 @@ + + + + +ArrayAsIterableMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class ArrayAsIterableMatcher<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<E[]> +
org.hamcrest.TypeSafeMatcher<E[]> +
org.hamcrest.collection.ArrayAsIterableMatcher<E>
+
+
+
+
+
+
Type Parameters:
+
E - the collection element type
+
+
+
All Implemented Interfaces:
+
Matcher<E[]>, SelfDescribing
+
+
+
public class ArrayAsIterableMatcher<E> +extends TypeSafeMatcher<E[]>
+
A matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers.
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    +
      +
    • +
      +

      iterableMatcher

      +
      protected final TypeSafeDiagnosingMatcher<Iterable<? extends E>> iterableMatcher
      +
      The matchers to match iterable against
      +
      +
    • +
    • +
      +

      matchers

      +
      protected final Collection<Matcher<? super E>> matchers
      +
      The matchers to match items against
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(E[] item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(E[] item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/ArrayMatching.html b/docs/javadoc/3.0/org/hamcrest/collection/ArrayMatching.html new file mode 100644 index 000000000..ef3cafd98 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/ArrayMatching.html @@ -0,0 +1,390 @@ + + + + +ArrayMatching (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class ArrayMatching

+
+
java.lang.Object +
org.hamcrest.collection.ArrayMatching
+
+
+
+
public class ArrayMatching +extends Object
+
Collected helper code for converting matchers between lists and iterables.
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    static <E> Matcher<E[]>
    +
    arrayContaining(E... items)
    +
    +
    Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items.
    +
    +
    static <E> Matcher<E[]>
    +
    arrayContaining(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[]>
    +
    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[]>
    + +
    +
    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[]>
    +
    arrayContainingInAnyOrder(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[]>
    +
    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> List<Matcher<? super E>>
    +
    asEqualMatchers(E[] items)
    +
    +
    Converts item array to corresponding array of equalTo matchers
    +
    +
    static <T> Matcher<T[]>
    +
    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[]>
    +
    hasItemInArray(T element)
    +
    +
    A shortcut to the frequently used hasItemInArray(equalTo(x)).
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      hasItemInArray

      +
      public static <T> Matcher<T[]> 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. Whilst matching, the traversal + of the examined array will stop as soon as a matching element is found. + For example: +
      assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elementMatcher - the matcher to apply to elements in examined arrays
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItemInArray

      +
      public static <T> Matcher<T[]> hasItemInArray(T element)
      +
      A shortcut to the frequently used hasItemInArray(equalTo(x)). + For example: +
      assertThat(hasItemInArray(x))
      + instead of: +
      assertThat(hasItemInArray(equalTo(x)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      element - the element that should be present in examined arrays
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

      +

      + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      public static <E> Matcher<E[]> arrayContainingInAnyOrder(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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

      +

      + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

      +

      N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

      +

      + For example: +

      +
      assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the entries of an examined array, in any order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      @SafeVarargs +public static <E> Matcher<E[]> arrayContaining(E... items)
      +
      Creates a matcher for arrays that matches when each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. + For example: +
      assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items within an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      @SafeVarargs +public static <E> Matcher<E[]> 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. For a positive match, the examined array + must be of the same length as the number of specified matchers. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items in the examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      public static <E> Matcher<E[]> arrayContaining(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. For a positive match, the examined array + must be of the same length as the specified list of matchers. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      asEqualMatchers

      +
      public static <E> List<Matcher<? super E>> asEqualMatchers(E[] items)
      +
      Converts item array to corresponding array of equalTo matchers
      +
      +
      Type Parameters:
      +
      E - type of array items
      +
      Parameters:
      +
      items - items to convert
      +
      Returns:
      +
      list of corresponding equaTo matchers
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/HasItemInArray.html b/docs/javadoc/3.0/org/hamcrest/collection/HasItemInArray.html new file mode 100644 index 000000000..97b9a186b --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/HasItemInArray.html @@ -0,0 +1,259 @@ + + + + +HasItemInArray (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasItemInArray<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T[]> +
org.hamcrest.TypeSafeMatcher<T[]> +
org.hamcrest.collection.HasItemInArray<T>
+
+
+
+
+
+
Type Parameters:
+
T - the array element type
+
+
+
All Implemented Interfaces:
+
Matcher<T[]>, SelfDescribing
+
+
+
public class HasItemInArray<T> +extends TypeSafeMatcher<T[]>
+
Matches if an array contains an item satisfying a nested matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(T[] actual)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<T[]>
      +
      Parameters:
      +
      actual - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(T[] actual, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<T[]>
      +
      Parameters:
      +
      actual - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsArray.html b/docs/javadoc/3.0/org/hamcrest/collection/IsArray.html new file mode 100644 index 000000000..30a8d5ed1 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsArray.html @@ -0,0 +1,335 @@ + + + + +IsArray (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsArray<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T[]> +
org.hamcrest.TypeSafeMatcher<T[]> +
org.hamcrest.collection.IsArray<T>
+
+
+
+
+
+
Type Parameters:
+
T - the array element type
+
+
+
All Implemented Interfaces:
+
Matcher<T[]>, SelfDescribing
+
+
+
public class IsArray<T> +extends TypeSafeMatcher<T[]>
+
Matcher for array whose elements satisfy a sequence of matchers. + The array size must equal the number of element matchers.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsArray

      +
      public IsArray(Matcher<? super T>[] elementMatchers)
      +
      Constructor, best called from array(Matcher[]).
      +
      +
      Parameters:
      +
      elementMatchers - matchers for expected values
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(T[] array)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<T[]>
      +
      Parameters:
      +
      array - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(T[] actual, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<T[]>
      +
      Parameters:
      +
      actual - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      descriptionStart

      +
      protected String descriptionStart()
      +
      Returns the string that starts the description. + + Can be overridden in subclasses to customise how the matcher is + described.
      +
      +
      Returns:
      +
      The description prefix.
      +
      +
      +
    • +
    • +
      +

      descriptionSeparator

      +
      protected String descriptionSeparator()
      +
      Returns the string that separates the elements in the description. + + Can be overridden in subclasses to customise how the matcher is + described.
      +
      +
      Returns:
      +
      The description separator.
      +
      +
      +
    • +
    • +
      +

      descriptionEnd

      +
      protected String descriptionEnd()
      +
      Returns the string that ends the description. + + Can be overridden in subclasses to customise how the matcher is + described.
      +
      +
      Returns:
      +
      The description suffix.
      +
      +
      +
    • +
    • +
      +

      array

      +
      public static <T> IsArray<T> array(Matcher<? super T>... elementMatchers)
      +
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches + positively only if the number of matchers specified is equal to the length of the examined array and + each matcher[i] is satisfied by array[i]. + For example: +
      assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elementMatchers - the matchers that the elements of examined arrays should satisfy
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html new file mode 100644 index 000000000..81fd1a2a3 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInAnyOrder.html @@ -0,0 +1,371 @@ + + + + +IsArrayContainingInAnyOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsArrayContainingInAnyOrder<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<E[]> +
org.hamcrest.TypeSafeMatcher<E[]> +
org.hamcrest.collection.IsArrayContainingInAnyOrder<E>
+
+
+
+
+
+
Type Parameters:
+
E - the collection element type
+
+
+
All Implemented Interfaces:
+
Matcher<E[]>, SelfDescribing
+
+
+
@Deprecated +public class IsArrayContainingInAnyOrder<E> +extends TypeSafeMatcher<E[]>
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(E[] item)
      +
      Deprecated.
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(E[] item, + Description mismatchDescription)
      +
      Deprecated.
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Deprecated.
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers)
      +
      Deprecated. + +
      +
      Creates an order agnostic matcher for arrays that matches when each item in the + examined array satisfies one matcher anywhere in the specified matchers. + For a positive match, the examined array must be of the same length as the number of + specified matchers. +

      + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + array. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      public static <E> Matcher<E[]> arrayContainingInAnyOrder(Collection<Matcher<? super E>> itemMatchers)
      +
      Deprecated. + +
      +
      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. + For a positive match, the examined array must be of the same length as the specified collection + of matchers. +

      + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined array. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContainingInAnyOrder

      +
      public static <E> Matcher<E[]> arrayContainingInAnyOrder(E... items)
      +
      Deprecated. + +
      +
      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. + For a positive match, the examined array must be of the same length as the number of + specified items. +

      + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + array. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the entries of an examined array, in any order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInOrder.html b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInOrder.html new file mode 100644 index 000000000..34e61029c --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayContainingInOrder.html @@ -0,0 +1,355 @@ + + + + +IsArrayContainingInOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsArrayContainingInOrder<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<E[]> +
org.hamcrest.TypeSafeMatcher<E[]> +
org.hamcrest.collection.IsArrayContainingInOrder<E>
+
+
+
+
+
+
Type Parameters:
+
E - the array element type
+
+
+
All Implemented Interfaces:
+
Matcher<E[]>, SelfDescribing
+
+
+
public class IsArrayContainingInOrder<E> +extends TypeSafeMatcher<E[]>
+
Deprecated. +
As of release 2.1, replaced by ArrayMatching.
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(E[] item)
      +
      Deprecated.
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(E[] item, + Description mismatchDescription)
      +
      Deprecated.
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<E[]>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Deprecated.
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      public static <E> Matcher<E[]> arrayContaining(E... items)
      +
      Deprecated. + +
      +
      Creates a matcher for arrays that matcheswhen each item in the examined array is + logically equal to the corresponding item in the specified items. For a positive match, + the examined array must be of the same length as the number of specified items. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items within an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatchers)
      +
      Deprecated. + +
      +
      Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified matchers. For a positive match, the examined array + must be of the same length as the number of specified matchers. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items in the examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayContaining

      +
      public static <E> Matcher<E[]> arrayContaining(List<Matcher<? super E>> itemMatchers)
      +
      Deprecated. +
      As of version 2.1, use ArrayMatching.arrayContaining(List).
      +
      +
      Creates a matcher for arrays that matches when each item in the examined array satisfies the + corresponding matcher in the specified list of matchers. For a positive match, the examined array + must be of the same length as the specified list of matchers. +

      + For example: +

      assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsArrayWithSize.html b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayWithSize.html new file mode 100644 index 000000000..d35bb5708 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsArrayWithSize.html @@ -0,0 +1,287 @@ + + + + +IsArrayWithSize (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsArrayWithSize<E>

+
+ +
+
+
Type Parameters:
+
E - the array element type
+
+
+
All Implemented Interfaces:
+
Matcher<E[]>, SelfDescribing
+
+
+
public class IsArrayWithSize<E> +extends FeatureMatcher<E[],Integer>
+
Matches if array size satisfies a size matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected Integer featureValueOf(E[] actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<E[],Integer>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      arrayWithSize

      +
      public static <E> Matcher<E[]> arrayWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for arrays that matches when the length of the array + satisfies the specified matcher. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the length of an examined array
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      arrayWithSize

      +
      public static <E> Matcher<E[]> arrayWithSize(int size)
      +
      Creates a matcher for arrays that matches when the length of the array + equals the specified size. + For example: +
      assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the length that an examined array must have for a positive match
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyArray

      +
      public static <E> Matcher<E[]> emptyArray()
      +
      Creates a matcher for arrays that matches when the length of the array + is zero. + For example: +
      assertThat(new String[0], emptyArray())
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsCollectionWithSize.html b/docs/javadoc/3.0/org/hamcrest/collection/IsCollectionWithSize.html new file mode 100644 index 000000000..83aede49c --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsCollectionWithSize.html @@ -0,0 +1,263 @@ + + + + +IsCollectionWithSize (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsCollectionWithSize<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Collection<? extends E>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Collection<? extends E>> +
org.hamcrest.FeatureMatcher<Collection<? extends E>,Integer> +
org.hamcrest.collection.IsCollectionWithSize<E>
+
+
+
+
+
+
+
Type Parameters:
+
E - the collection element type
+
+
+
All Implemented Interfaces:
+
Matcher<Collection<? extends E>>, SelfDescribing
+
+
+
public class IsCollectionWithSize<E> +extends FeatureMatcher<Collection<? extends E>,Integer>
+
Matches if collection size satisfies a nested matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsCollectionWithSize

      +
      public IsCollectionWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Constructor, best called from hasSize(int) or hasSize(Matcher).
      +
      +
      Parameters:
      +
      sizeMatcher - the expected size
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected Integer featureValueOf(Collection<? extends E> actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<Collection<? extends E>,Integer>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      hasSize

      +
      public static <E> Matcher<Collection<? extends E>> hasSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Collections that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the size of an examined Collection
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasSize

      +
      public static <E> Matcher<Collection<? extends E>> hasSize(int size)
      +
      Creates a matcher for Collections that matches when the size() method returns + a value equal to the specified size. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the expected size of an examined Collection
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyCollection.html b/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyCollection.html new file mode 100644 index 000000000..c80a8c2d0 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyCollection.html @@ -0,0 +1,297 @@ + + + + +IsEmptyCollection (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEmptyCollection<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Collection<? extends E>> +
org.hamcrest.TypeSafeMatcher<Collection<? extends E>> +
org.hamcrest.collection.IsEmptyCollection<E>
+
+
+
+
+
+
Type Parameters:
+
E - the collection element type
+
+
+
All Implemented Interfaces:
+
Matcher<Collection<? extends E>>, SelfDescribing
+
+
+
public class IsEmptyCollection<E> +extends TypeSafeMatcher<Collection<? extends E>>
+
Tests if a collection is empty.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Collection<? extends E> item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Collection<? extends E>>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Collection<? extends E> item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Collection<? extends E>>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      empty

      +
      public static <E> Matcher<Collection<? extends E>> empty()
      +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
      assertThat(new ArrayList<String>(), is(empty()))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyCollectionOf

      +
      public static <E> Matcher<Collection<E>> emptyCollectionOf(Class<E> unusedToForceReturnType)
      +
      Creates a matcher for Collections matching examined collections whose isEmpty + method returns true. + For example: +
      assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      unusedToForceReturnType - the type of the collection's content
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyIterable.html b/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyIterable.html new file mode 100644 index 000000000..971932ca9 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsEmptyIterable.html @@ -0,0 +1,293 @@ + + + + +IsEmptyIterable (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEmptyIterable<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? extends E>> +
org.hamcrest.TypeSafeMatcher<Iterable<? extends E>> +
org.hamcrest.collection.IsEmptyIterable<E>
+
+
+
+
+
+
Type Parameters:
+
E - the iterable element type
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? extends E>>, SelfDescribing
+
+
+
public class IsEmptyIterable<E> +extends TypeSafeMatcher<Iterable<? extends E>>
+
Tests if an iterable is empty.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Iterable<? extends E> iterable)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Iterable<? extends E>>
      +
      Parameters:
      +
      iterable - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Iterable<? extends E> iter, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Iterable<? extends E>>
      +
      Parameters:
      +
      iter - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      emptyIterable

      +
      public static <E> Matcher<Iterable<? extends E>> emptyIterable()
      +
      Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
      assertThat(new ArrayList<String>(), is(emptyIterable()))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyIterableOf

      +
      public static <E> Matcher<Iterable<E>> emptyIterableOf(Class<E> unusedToForceReturnType)
      +
      Creates a matcher for Iterables matching examined iterables that yield no items. + For example: +
      assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      unusedToForceReturnType - the type of the iterable's content
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsIn.html b/docs/javadoc/3.0/org/hamcrest/collection/IsIn.html new file mode 100644 index 000000000..c04543d4d --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsIn.html @@ -0,0 +1,409 @@ + + + + +IsIn (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIn<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.collection.IsIn<T>
+
+
+
+
+
Type Parameters:
+
T - the type of the objects in the collection
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsIn<T> +extends BaseMatcher<T>
+
Tests if a collection contains a matching object.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsIn

      +
      public IsIn(Collection<T> collection)
      +
      Constructor, best called from in(Collection).
      +
      +
      Parameters:
      +
      collection - the expected element matchers
      +
      +
      +
    • +
    • +
      +

      IsIn

      +
      public IsIn(T[] elements)
      +
      Constructor, best called from in(Object[]).
      +
      +
      Parameters:
      +
      elements - the expected elements
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      o - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description buffer)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      buffer - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      isIn

      +
      @Deprecated +public static <T> Matcher<T> isIn(Collection<T> collection)
      +
      Deprecated. +
      use is(in(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
      assertThat("foo", isIn(Arrays.asList("bar", "foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      collection - the collection in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      in

      +
      public static <T> Matcher<T> in(Collection<T> collection)
      +
      Creates a matcher that matches when the examined object is found within the + specified collection. + For example: +
      assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      collection - the collection in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isIn

      +
      @Deprecated +public static <T> Matcher<T> isIn(T[] elements)
      +
      Deprecated. +
      use is(in(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
      assertThat("foo", isIn(new String[]{"bar", "foo"}))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the array in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      in

      +
      public static <T> Matcher<T> in(T[] elements)
      +
      Creates a matcher that matches when the examined object is found within the + specified array. + For example: +
      assertThat("foo", is(in(new String[]{"bar", "foo"})))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the array in which matching items must be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isOneOf

      +
      @SafeVarargs +@Deprecated +public static <T> Matcher<T> isOneOf(T... elements)
      +
      Deprecated. +
      use is(oneOf(...)) instead
      +
      +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
      assertThat("foo", isOneOf("bar", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the elements amongst which matching items will be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      oneOf

      +
      @SafeVarargs +public static <T> Matcher<T> oneOf(T... elements)
      +
      Creates a matcher that matches when the examined object is equal to one of the + specified elements. + For example: +
      assertThat("foo", is(oneOf("bar", "foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      elements - the elements amongst which matching items will be found
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html new file mode 100644 index 000000000..6973b9d13 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInAnyOrder.html @@ -0,0 +1,352 @@ + + + + +IsIterableContainingInAnyOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIterableContainingInAnyOrder<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? extends T>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? extends T>> +
org.hamcrest.collection.IsIterableContainingInAnyOrder<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of items in the iterable.
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? extends T>>, SelfDescribing
+
+
+
public class IsIterableContainingInAnyOrder<T> +extends TypeSafeDiagnosingMatcher<Iterable<? extends T>>
+
Tests if an iterable contains matching elements in any order.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(Iterable<? extends T> items, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? extends T>>
      +
      Parameters:
      +
      items - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      @SafeVarargs +public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
      +

      + Creates an order agnostic matcher for Iterables that matches when a single pass over + the examined Iterable yields a series of items, each satisfying one matcher anywhere + in the specified matchers. For a positive match, the examined iterable must be of the same + length as the number of specified matchers. +

      +

      + N.B. each of the specified matchers will only be used once during a given examination, so be + careful when specifying matchers that may be satisfied by more than one entry in an examined + iterable. +

      +

      + For example: +

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      @SafeVarargs +public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(T... items)
      +

      + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. +

      +

      + N.B. each of the specified items will only be used once during a given examination, so be + careful when specifying items that may be equal to more than one entry in an examined + iterable. +

      +

      + For example: +

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items provided by an examined Iterable in any order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInAnyOrder

      +
      public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Collection<Matcher<? super T>> itemMatchers)
      +

      + Creates an order agnostic matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified collection of matchers. +

      +

      + N.B. each matcher in the specified collection will only be used once during a given + examination, so be careful when specifying matchers that may be satisfied by more than + one entry in an examined iterable. +

      +

      For example:

      +
      assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInOrder.html b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInOrder.html new file mode 100644 index 000000000..b4ed07292 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInOrder.html @@ -0,0 +1,352 @@ + + + + +IsIterableContainingInOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIterableContainingInOrder<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? extends E>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? extends E>> +
org.hamcrest.collection.IsIterableContainingInOrder<E>
+
+
+
+
+
+
Type Parameters:
+
E - the type of items in the iterable.
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? extends E>>, SelfDescribing
+
+
+
public class IsIterableContainingInOrder<E> +extends TypeSafeDiagnosingMatcher<Iterable<? extends E>>
+
Tests if an iterable contains matching elements in order.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(Iterable<? extends E> iterable, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? extends E>>
      +
      Parameters:
      +
      iterable - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> contains(E... items)
      +
      Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the number of specified items. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must equal the items provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      public static <E> Matcher<Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a single item that satisfies the specified matcher. + For a positive match, the examined iterable must only yield one item. + For example: +
      assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher that must be satisfied by the single item provided by an + examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, each satisfying the corresponding + matcher in the specified matchers. For a positive match, the examined iterable + must be of the same length as the number of specified matchers. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      contains

      +
      public static <E> Matcher<Iterable<? extends E>> contains(List<Matcher<? super E>> itemMatchers)
      +
      Creates a matcher for Iterables 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. For a positive match, the examined iterable + must be of the same length as the specified list of matchers. + For example: +
      assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by + an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html new file mode 100644 index 000000000..910dbd2cb --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableContainingInRelativeOrder.html @@ -0,0 +1,317 @@ + + + + +IsIterableContainingInRelativeOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIterableContainingInRelativeOrder<E>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? extends E>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? extends E>> +
org.hamcrest.collection.IsIterableContainingInRelativeOrder<E>
+
+
+
+
+
+
Type Parameters:
+
E - the type of items in the iterable.
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? extends E>>, SelfDescribing
+
+
+
public class IsIterableContainingInRelativeOrder<E> +extends TypeSafeDiagnosingMatcher<Iterable<? extends E>>
+
Tests if an iterable contains matching elements in relative order.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(Iterable<? extends E> iterable, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? extends E>>
      +
      Parameters:
      +
      iterable - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(E... items)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items logically equal to the + corresponding item in the specified items, in the same relative order + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      items - the items that must be contained within items provided by an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      @SafeVarargs +public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that each satisfying the corresponding + matcher in the specified matchers, in the same relative order. + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsInRelativeOrder

      +
      public static <E> Matcher<Iterable<? extends E>> containsInRelativeOrder(List<Matcher<? super E>> itemMatchers)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields a series of items, that contains items satisfying the corresponding + matcher in the specified list of matchers, in the same relative order. + For example: +
      assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      itemMatchers - a list of matchers, each of which must be satisfied by the items provided by + an examined Iterable in the same relative order
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsIterableWithSize.html b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableWithSize.html new file mode 100644 index 000000000..cf1ace854 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsIterableWithSize.html @@ -0,0 +1,269 @@ + + + + +IsIterableWithSize (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIterableWithSize<E>

+
+ +
+
+
Type Parameters:
+
E - the iterable element type
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<E>>, SelfDescribing
+
+
+
public class IsIterableWithSize<E> +extends FeatureMatcher<Iterable<E>,Integer>
+
Matches if iterable size satisfies a size matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected Integer featureValueOf(Iterable<E> actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<Iterable<E>,Integer>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      iterableWithSize

      +
      public static <E> Matcher<Iterable<E>> iterableWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that satisfies the specified + matcher. + For example: +
      assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      iterableWithSize

      +
      public static <E> Matcher<Iterable<E>> iterableWithSize(int size)
      +
      Creates a matcher for Iterables that matches when a single pass over the + examined Iterable yields an item count that is equal to the specified + size argument. + For example: +
      assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
      +
      +
      Type Parameters:
      +
      E - the matcher type.
      +
      Parameters:
      +
      size - the number of items that should be yielded by an examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsMapContaining.html b/docs/javadoc/3.0/org/hamcrest/collection/IsMapContaining.html new file mode 100644 index 000000000..7e2df5002 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsMapContaining.html @@ -0,0 +1,432 @@ + + + + +IsMapContaining (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsMapContaining<K,V>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Map<? extends K,? extends V>> +
org.hamcrest.TypeSafeMatcher<Map<? extends K,? extends V>> +
org.hamcrest.collection.IsMapContaining<K,V>
+
+
+
+
+
+
Type Parameters:
+
K - the type of the map keys
+
V - the type of the map values
+
+
+
All Implemented Interfaces:
+
Matcher<Map<? extends K,? extends V>>, SelfDescribing
+
+
+
public class IsMapContaining<K,V> +extends TypeSafeMatcher<Map<? extends K,? extends V>>
+
Matches if map keys, values or entries match the value matchers.
+
+
+
    + +
  • +
    +

    Constructor Summary

    +
    Constructors
    +
    +
    Constructor
    +
    Description
    +
    IsMapContaining(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher)
    +
    +
    Constructor, best called from one of the static factory methods (hasKey, hasValue, + or hasEntry).
    +
    +
    +
    +
  • + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    void
    +
    describeMismatchSafely(Map<? extends K,? extends V> map, + Description mismatchDescription)
    +
    +
    Describe the mismatch.
    +
    +
    void
    +
    describeTo(Description description)
    +
    +
    Generates a description of the object.
    +
    +
    static <K, +V> Matcher<Map<? extends K,? extends V>>
    +
    hasEntry(K key, + V value)
    +
    +
    Creates a matcher for Maps 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<Map<? extends K,? extends V>>
    +
    hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher.
    +
    +
    static <K> Matcher<Map<? extends K,?>>
    +
    hasKey(K key)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key.
    +
    +
    static <K> Matcher<Map<? extends K,?>>
    +
    hasKey(Matcher<? super K> keyMatcher)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher.
    +
    +
    static <V> Matcher<Map<?,? extends V>>
    +
    hasValue(Matcher<? super V> valueMatcher)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher.
    +
    +
    static <V> Matcher<Map<?,? extends V>>
    +
    hasValue(V value)
    +
    +
    Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value.
    +
    +
    boolean
    +
    matchesSafely(Map<? extends K,? extends V> map)
    +
    +
    Check if the item matches.
    +
    +
    +
    +
    +
    +

    Methods inherited from class org.hamcrest.TypeSafeMatcher

    +describeMismatch, matches
    + +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Map<? extends K,? extends V> map)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Map<? extends K,? extends V>>
      +
      Parameters:
      +
      map - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Map<? extends K,? extends V> map, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Map<? extends K,? extends V>>
      +
      Parameters:
      +
      map - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasEntry

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> hasEntry(Matcher<? super K> keyMatcher, + Matcher<? super V> valueMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key satisfies the specified keyMatcher and whose + value satisfies the specified valueMatcher. + For example: +
      assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
      +
      valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasEntry

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> hasEntry(K key, + V value)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one entry whose key equals the specified key and whose value equals the + specified value. + For example: +
      assertThat(myMap, hasEntry("bar", "foo"))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      key - the key that, in combination with the value, must be describe at least one entry
      +
      value - the value that, in combination with the key, must be describe at least one entry
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasKey

      +
      public static <K> Matcher<Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that satisfies the specified matcher. + For example: +
      assertThat(myMap, hasKey(equalTo("bar")))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      Parameters:
      +
      keyMatcher - the matcher that must be satisfied by at least one key
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasKey

      +
      public static <K> Matcher<Map<? extends K,?>> hasKey(K key)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one key that is equal to the specified key. + For example: +
      assertThat(myMap, hasKey("bar"))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      Parameters:
      +
      key - the key that satisfying maps must contain
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasValue

      +
      public static <V> Matcher<Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that satisfies the specified valueMatcher. + For example: +
      assertThat(myMap, hasValue(equalTo("foo")))
      +
      +
      Type Parameters:
      +
      V - the value type.
      +
      Parameters:
      +
      valueMatcher - the matcher that must be satisfied by at least one value
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasValue

      +
      public static <V> Matcher<Map<?,? extends V>> hasValue(V value)
      +
      Creates a matcher for Maps matching when the examined Map contains + at least one value that is equal to the specified value. + For example: +
      assertThat(myMap, hasValue("foo"))
      +
      +
      Type Parameters:
      +
      V - the value type.
      +
      Parameters:
      +
      value - the value that satisfying maps must contain
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/IsMapWithSize.html b/docs/javadoc/3.0/org/hamcrest/collection/IsMapWithSize.html new file mode 100644 index 000000000..2dc5ea842 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/IsMapWithSize.html @@ -0,0 +1,300 @@ + + + + +IsMapWithSize (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsMapWithSize<K,V>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Map<? extends K,? extends V>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Map<? extends K,? extends V>> +
org.hamcrest.FeatureMatcher<Map<? extends K,? extends V>,Integer> +
org.hamcrest.collection.IsMapWithSize<K,V>
+
+
+
+
+
+
+
Type Parameters:
+
K - the map key type.
+
V - the map value type.
+
+
+
All Implemented Interfaces:
+
Matcher<Map<? extends K,? extends V>>, SelfDescribing
+
+
+
public final class IsMapWithSize<K,V> +extends FeatureMatcher<Map<? extends K,? extends V>,Integer>
+
Matches if map size satisfies a nested matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected Integer featureValueOf(Map<? extends K,? extends V> actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<Map<? extends K,? extends V>,Integer>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      aMapWithSize

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> aMapWithSize(Matcher<? super Integer> sizeMatcher)
      +
      Creates a matcher for Maps that matches when the size() method returns + a value that satisfies the specified matcher. + For example: +
      assertThat(myMap, is(aMapWithSize(equalTo(2))))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      sizeMatcher - a matcher for the size of an examined Map
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      aMapWithSize

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> aMapWithSize(int size)
      +
      Creates a matcher for Maps that matches when the size() method returns + a value equal to the specified size. + For example: +
      assertThat(myMap, is(aMapWithSize(2)))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Parameters:
      +
      size - the expected size of an examined Map
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anEmptyMap

      +
      public static <K, +V> +Matcher<Map<? extends K,? extends V>> anEmptyMap()
      +
      Creates a matcher for Maps that matches when the size() method returns + zero. + For example: +
      assertThat(myMap, is(anEmptyMap()))
      +
      +
      Type Parameters:
      +
      K - the map key type.
      +
      V - the map value type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/package-summary.html b/docs/javadoc/3.0/org/hamcrest/collection/package-summary.html new file mode 100644 index 000000000..3a62f78c0 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/package-summary.html @@ -0,0 +1,174 @@ + + + + +org.hamcrest.collection (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.collection

+
+
+
package org.hamcrest.collection
+
+
Matchers of arrays and collections.
+
+
+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/collection/package-tree.html b/docs/javadoc/3.0/org/hamcrest/collection/package-tree.html new file mode 100644 index 000000000..ad2ef8582 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/collection/package-tree.html @@ -0,0 +1,103 @@ + + + + +org.hamcrest.collection Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.collection

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html b/docs/javadoc/3.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html new file mode 100644 index 000000000..95f8aa270 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/comparator/ComparatorMatcherBuilder.html @@ -0,0 +1,312 @@ + + + + +ComparatorMatcherBuilder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class ComparatorMatcherBuilder<T>

+
+
java.lang.Object +
org.hamcrest.comparator.ComparatorMatcherBuilder<T>
+
+
+
+
Type Parameters:
+
T - the type of the value being compared/matched.
+
+
+
public final class ComparatorMatcherBuilder<T> +extends Object
+
Builder for matchers that allow matchers to use a corresponding Compartor
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    + +
    comparedBy(Comparator<T> comparator)
    +
    +
    Creates a matcher factory for matchers of Comparatorss of T.
    +
    + + +
    +
    Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder.
    +
    + +
    greaterThan(T value)
    +
    +
    Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder.
    +
    + + +
    +
    Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder.
    +
    + +
    lessThan(T value)
    +
    +
    Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder.
    +
    + + +
    +
    Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder.
    +
    +
    static <T extends Comparable<T>>
    ComparatorMatcherBuilder<T>
    + +
    +
    Creates a matcher factory for matchers of Comparables.
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      usingNaturalOrdering

      +
      public static <T extends Comparable<T>> +ComparatorMatcherBuilder<T> usingNaturalOrdering()
      +
      Creates a matcher factory for matchers of Comparables. + For example: +
      assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      comparedBy

      +
      public static <T> ComparatorMatcherBuilder<T> comparedBy(Comparator<T> comparator)
      +
      Creates a matcher factory for matchers of Comparatorss of T. + For example: +
      assertThat(5, comparedBy(new Comparator<Integer>() {
      + public int compare(Integer o1, Integer o2) {
      + return -o1.compareTo(o2);
      + }
      + }).lessThan(4))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      comparator - the comparator for the matcher to use.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      comparesEqualTo

      +
      public Matcher<T> comparesEqualTo(T value)
      +
      Creates a matcher of T object that matches when the examined object is + equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
      assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1))
      +
      +
      Parameters:
      +
      value - the value which, when passed to the Comparator supplied to this builder, should return zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThan

      +
      public Matcher<T> greaterThan(T value)
      +
      Creates a matcher of T object that matches when the examined object is + greater than the specified value, as reported by the Comparator used to + create this builder. + For example: +
      assertThat(2, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThan(1))
      +
      +
      Parameters:
      +
      value - the value which, when passed to the Comparator supplied to this builder, should return greater + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThanOrEqualTo

      +
      public Matcher<T> greaterThanOrEqualTo(T value)
      +
      Creates a matcher of T object that matches when the examined object is + greater than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
      assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThanOrEqualTo(1))
      +
      +
      Parameters:
      +
      value - the value which, when passed to the Comparator supplied to this builder, should return greater + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThan

      +
      public Matcher<T> lessThan(T value)
      +
      Creates a matcher of T object that matches when the examined object is + less than the specified value, as reported by the Comparator used to + create this builder. + For example: +
      assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThan(2))
      +
      +
      Parameters:
      +
      value - the value which, when passed to the Comparator supplied to this builder, should return less + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThanOrEqualTo

      +
      public Matcher<T> lessThanOrEqualTo(T value)
      +
      Creates a matcher of T object that matches when the examined object is + less than or equal to the specified value, as reported by the Comparator used to + create this builder. + For example: +
      assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
      +
      +
      Parameters:
      +
      value - the value which, when passed to the Comparator supplied to this builder, should return less + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/comparator/package-summary.html b/docs/javadoc/3.0/org/hamcrest/comparator/package-summary.html new file mode 100644 index 000000000..50523b26f --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/comparator/package-summary.html @@ -0,0 +1,109 @@ + + + + +org.hamcrest.comparator (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.comparator

+
+
+
package org.hamcrest.comparator
+
+
Helper classes for building matcher comparators.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    Builder for matchers that allow matchers to use a corresponding Compartor
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/comparator/package-tree.html b/docs/javadoc/3.0/org/hamcrest/comparator/package-tree.html new file mode 100644 index 000000000..9d0072bce --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/comparator/package-tree.html @@ -0,0 +1,71 @@ + + + + +org.hamcrest.comparator Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.comparator

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/AllOf.html b/docs/javadoc/3.0/org/hamcrest/core/AllOf.html new file mode 100644 index 000000000..882615966 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/AllOf.html @@ -0,0 +1,306 @@ + + + + +AllOf (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class AllOf<T>

+
+ +
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class AllOf<T> +extends DiagnosingMatcher<T>
+
Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns false.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o, + Description mismatch)
      +
      Description copied from class: DiagnosingMatcher
      +
      Evaluates the matcher for argument item.
      +
      +
      Specified by:
      +
      matches in class DiagnosingMatcher<T>
      +
      Parameters:
      +
      o - the value to check
      +
      mismatch - the description for the matcher
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      public static <T> Matcher<T> allOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      allOf

      +
      @SafeVarargs +public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ALL of the specified matchers. + For example: +
      assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - all the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/AnyOf.html b/docs/javadoc/3.0/org/hamcrest/core/AnyOf.html new file mode 100644 index 000000000..7d77a6f51 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/AnyOf.html @@ -0,0 +1,354 @@ + + + + +AnyOf (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class AnyOf<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.AnyOf<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class AnyOf<T> +extends BaseMatcher<T>
+
Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so + subsequent matchers are not called if an earlier matcher returns true.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Specified by:
      +
      matches in interface Matcher<T>
      +
      Parameters:
      +
      o - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Specified by:
      +
      describeTo in interface SelfDescribing
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      public static <T> AnyOf<T> anyOf(Iterable<Matcher<? super T>> matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anyOf

      +
      @SafeVarargs +public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
      +
      Creates a matcher that matches if the examined object matches ANY of the specified matchers. + For example: +
      assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matchers - any the matchers must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matches

      +
      protected boolean matches(Object o, + boolean shortcut)
      +
      Evaluates the argument o against the delegate matchers. + + Evaluation will stop at the first matcher that evaluates to the value of the + shortcut argument.
      +
      +
      Parameters:
      +
      o - the value to check
      +
      shortcut - the match result to be checked against all delegate matchers
      +
      Returns:
      +
      the value of shortcut if all delegate matchers give the same value
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description, + String operator)
      +
      Describe this matcher to description
      +
      +
      Parameters:
      +
      description - the description target
      +
      operator - the separate to use when joining the matcher descriptions
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html new file mode 100644 index 000000000..7df176c03 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableBothMatcher.html @@ -0,0 +1,206 @@ + + + + +CombinableMatcher.CombinableBothMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class CombinableMatcher.CombinableBothMatcher<X>

+
+
java.lang.Object +
org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<X>
+
+
+
+
Type Parameters:
+
X - the combined matcher type
+
+
+
Enclosing class:
+
CombinableMatcher<T>
+
+
+
public static final class CombinableMatcher.CombinableBothMatcher<X> +extends Object
+
Allows syntactic sugar of using both and and.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      CombinableBothMatcher

      +
      public CombinableBothMatcher(Matcher<? super X> matcher)
      +
      Constructor, best called from CombinableMatcher.both(Matcher).
      +
      +
      Parameters:
      +
      matcher - the first matcher
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      and

      +
      public CombinableMatcher<X> and(Matcher<? super X> other)
      +
      Specify the second matcher in a CombinableMatcher pair.
      +
      +
      Parameters:
      +
      other - the second matcher
      +
      Returns:
      +
      the combined matcher
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html new file mode 100644 index 000000000..34ee8822c --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.CombinableEitherMatcher.html @@ -0,0 +1,206 @@ + + + + +CombinableMatcher.CombinableEitherMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class CombinableMatcher.CombinableEitherMatcher<X>

+
+
java.lang.Object +
org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<X>
+
+
+
+
Type Parameters:
+
X - the combined matcher type
+
+
+
Enclosing class:
+
CombinableMatcher<T>
+
+
+
public static final class CombinableMatcher.CombinableEitherMatcher<X> +extends Object
+
Allows syntactic sugar of using either and or.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      or

      +
      public CombinableMatcher<X> or(Matcher<? super X> other)
      +
      Specify the second matcher in a CombinableMatcher pair.
      +
      +
      Parameters:
      +
      other - the second matcher
      +
      Returns:
      +
      the combined matcher
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.html b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.html new file mode 100644 index 000000000..3d3df6c26 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/CombinableMatcher.html @@ -0,0 +1,365 @@ + + + + +CombinableMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class CombinableMatcher<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeDiagnosingMatcher<T> +
org.hamcrest.core.CombinableMatcher<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of matcher being combined.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class CombinableMatcher<T> +extends TypeSafeDiagnosingMatcher<T>
+
Allows matchers of the same type to be combined using + either/or, or + both/and. + + For example: + +
 import static org.hamcrest.core.CombinableMatcher.either;
+ import static org.hamcrest.core.CombinableMatcher.both;
+ import static org.hamcrest.Matchers.equalTo;
+ import static org.hamcrest.Matchers.not;
+
+ Matcher<Integer> either_3_or_4 = either(equalTo(3)).or(equalTo(4));
+ Matcher<Integer> neither_3_nor_4 = both(not(equalTo(3))).and(not(equalTo(4)));
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      CombinableMatcher

      +
      public CombinableMatcher(Matcher<? super T> matcher)
      +
      Constructor, best called from either or both.
      +
      +
      Parameters:
      +
      matcher - the starting matcher
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(T item, + Description mismatch)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<T>
      +
      Parameters:
      +
      item - the item.
      +
      mismatch - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      and

      +
      public CombinableMatcher<T> and(Matcher<? super T> other)
      +
      Specify the second matcher in a CombinableMatcher pair.
      +
      +
      Parameters:
      +
      other - the second matcher
      +
      Returns:
      +
      the combined matcher
      +
      +
      +
    • +
    • +
      +

      or

      +
      public CombinableMatcher<T> or(Matcher<? super T> other)
      +
      Specify the second matcher in a CombinableMatcher pair.
      +
      +
      Parameters:
      +
      other - the second matcher
      +
      Returns:
      +
      the combined matcher
      +
      +
      +
    • +
    • +
      +

      both

      +
      public static <LHS> +CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when both of the specified matchers match the examined object. + For example: +
      assertThat("fab", both(containsString("a")).and(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and both must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      either

      +
      public static <LHS> +CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
      +
      Creates a matcher that matches when either of the specified matchers match the examined object. + For example: +
      assertThat("fan", either(containsString("a")).or(containsString("b")))
      +
      +
      Type Parameters:
      +
      LHS - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to combine, and either must pass.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/DescribedAs.html b/docs/javadoc/3.0/org/hamcrest/core/DescribedAs.html new file mode 100644 index 000000000..01c73439d --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/DescribedAs.html @@ -0,0 +1,296 @@ + + + + +DescribedAs (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class DescribedAs<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.DescribedAs<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class DescribedAs<T> +extends BaseMatcher<T>
+
Provides a custom description to another matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      DescribedAs

      +
      public DescribedAs(String descriptionTemplate, + Matcher<T> matcher, + Object[] values)
      +
      Constructor, best called from describedAs(String, Matcher, Object...).
      +
      +
      Parameters:
      +
      descriptionTemplate - the new description for the wrapped matcher
      +
      matcher - the matcher to wrap
      +
      values - optional values to insert into the tokenised description
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      o - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public void describeMismatch(Object item, + Description description)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Overrides:
      +
      describeMismatch in class BaseMatcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      describedAs

      +
      public static <T> Matcher<T> describedAs(String descriptionTemplate, + Matcher<T> matcher, + Object... values)
      +
      Wraps an existing matcher, overriding its description with that specified. All other functions are + delegated to the decorated matcher, including its mismatch description. + For example: +
      describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      descriptionTemplate - the new description for the wrapped matcher
      +
      matcher - the matcher to wrap
      +
      values - optional values to insert into the tokenised description
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/Every.html b/docs/javadoc/3.0/org/hamcrest/core/Every.html new file mode 100644 index 000000000..e2711beb8 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/Every.html @@ -0,0 +1,259 @@ + + + + +Every (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class Every<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? extends T>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? extends T>> +
org.hamcrest.core.Every<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of the items in the iterable
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? extends T>>, SelfDescribing
+
+
+
public class Every<T> +extends TypeSafeDiagnosingMatcher<Iterable<? extends T>>
+
A matcher that applies a delegate matcher to every item in an Iterable.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      Every

      +
      public Every(Matcher<? super T> matcher)
      +
      Constructor, best called from everyItem(Matcher).
      +
      +
      Parameters:
      +
      matcher - a matcher used to check every item in the iterable.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Iterable<? extends T> collection, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? extends T>>
      +
      Parameters:
      +
      collection - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      everyItem

      +
      public static <U> Matcher<Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields items that are all matched by the specified + itemMatcher. + For example: +
      assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      U - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to every item provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/Is.html b/docs/javadoc/3.0/org/hamcrest/core/Is.html new file mode 100644 index 000000000..b6afb6ebd --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/Is.html @@ -0,0 +1,339 @@ + + + + +Is (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class Is<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.Is<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class Is<T> +extends BaseMatcher<T>
+
Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive. + + For example: assertThat(cheese, equalTo(smelly)) + vs. assertThat(cheese, is(equalTo(smelly)))
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object arg)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      arg - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      describeMismatch

      +
      public void describeMismatch(Object item, + Description mismatchDescription)
      +
      Description copied from interface: Matcher
      +
      Generate a description of why the matcher has not accepted the item. + The description will be part of a larger description of why a matching + failed, so it should be concise. + This method assumes that matches(item) is false, but + will not check this.
      +
      +
      Specified by:
      +
      describeMismatch in interface Matcher<T>
      +
      Overrides:
      +
      describeMismatch in class BaseMatcher<T>
      +
      Parameters:
      +
      item - The item that the Matcher has rejected.
      +
      mismatchDescription - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(Matcher<T> matcher)
      +
      Decorates another Matcher, retaining its behaviour, but allowing tests + to be slightly more expressive. + For example: +
      assertThat(cheese, is(equalTo(smelly)))
      + instead of: +
      assertThat(cheese, equalTo(smelly))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher to wrap.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      is

      +
      public static <T> Matcher<T> is(T value)
      +
      A shortcut to the frequently used is(equalTo(x)). + For example: +
      assertThat(cheese, is(smelly))
      + instead of: +
      assertThat(cheese, is(equalTo(smelly)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isA

      +
      public static <T> Matcher<T> isA(Class<?> type)
      +
      A shortcut to the frequently used is(instanceOf(SomeClass.class)). + For example: +
      assertThat(cheese, isA(Cheddar.class))
      + instead of: +
      assertThat(cheese, is(instanceOf(Cheddar.class)))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsAnything.html b/docs/javadoc/3.0/org/hamcrest/core/IsAnything.html new file mode 100644 index 000000000..e1749ab0f --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsAnything.html @@ -0,0 +1,274 @@ + + + + +IsAnything (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsAnything<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.IsAnything<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsAnything<T> +extends BaseMatcher<T>
+
A matcher that always returns true.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsAnything

      +
      public IsAnything()
      +
      Constructor, best called from anything().
      +
      +
    • +
    • +
      +

      IsAnything

      +
      public IsAnything(String message)
      +
      Constructor, best called from anything(String).
      +
      +
      Parameters:
      +
      message - matcher description
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o)
      +
      Always returns true.
      +
      +
      Parameters:
      +
      o - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything()
      +
      Creates a matcher that always matches, regardless of the examined object.
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      anything

      +
      public static Matcher<Object> anything(String description)
      +
      Creates a matcher that always matches, regardless of the examined object, but describes + itself with the specified String.
      +
      +
      Parameters:
      +
      description - a meaningful String used when describing itself
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsCollectionContaining.html b/docs/javadoc/3.0/org/hamcrest/core/IsCollectionContaining.html new file mode 100644 index 000000000..599d12f19 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsCollectionContaining.html @@ -0,0 +1,373 @@ + + + + +IsCollectionContaining (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsCollectionContaining<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? super T>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? super T>> +
org.hamcrest.core.IsCollectionContaining<T>
+
+
+
+
+
+
Type Parameters:
+
T - the collection element type
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? super T>>, SelfDescribing
+
+
+
@Deprecated +public class IsCollectionContaining<T> +extends TypeSafeDiagnosingMatcher<Iterable<? super T>>
+
Deprecated. +
As of release 2.1, replaced by IsIterableContaining.
+
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(Iterable<? super T> collection, + Description mismatchDescription)
      +
      Deprecated.
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? super T>>
      +
      Parameters:
      +
      collection - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Deprecated.
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
      +
      Deprecated. + +
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(T item)
      +
      Deprecated. +
      As of version 2.1, use IsIterableContaining.hasItem(Object).
      +
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      item - the item to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
      +
      Deprecated. + +
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(T... items)
      +
      Deprecated. + +
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsEqual.html b/docs/javadoc/3.0/org/hamcrest/core/IsEqual.html new file mode 100644 index 000000000..bb7d32307 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsEqual.html @@ -0,0 +1,294 @@ + + + + +IsEqual (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEqual<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.IsEqual<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsEqual<T> +extends BaseMatcher<T>
+
Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) method.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object actualValue)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      actualValue - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      equalTo

      +
      public static <T> Matcher<T> 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. + +

      If the specified operand is null then the created matcher will only match if + the examined object's equals method returns true when passed a + null (which would be a violation of the equals contract), unless the + examined object itself is null, in which case the matcher will return a positive + match.

      + +

      The created matcher provides a special behaviour when examining Arrays, whereby + it will match if both the operand and the examined object are arrays of the same length and + contain items that are equal to each other (according to the above rules) in the same + indexes.

      + For example: +
      + assertThat("foo", equalTo("foo"));
      + assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
      + 
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToObject

      +
      public static Matcher<Object> equalToObject(Object operand)
      +
      Creates an IsEqual matcher that does not enforce the values being + compared to be of the same static type.
      +
      +
      Parameters:
      +
      operand - the value to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsInstanceOf.html b/docs/javadoc/3.0/org/hamcrest/core/IsInstanceOf.html new file mode 100644 index 000000000..aaad5b2f2 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsInstanceOf.html @@ -0,0 +1,288 @@ + + + + +IsInstanceOf (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsInstanceOf

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<Object>, SelfDescribing
+
+
+
public class IsInstanceOf +extends DiagnosingMatcher<Object>
+
Tests whether the value is an instance of a class. + Classes of basic types will be converted to the relevant "Object" classes
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsInstanceOf

      +
      public IsInstanceOf(Class<?> expectedClass)
      +
      Creates a new instance of IsInstanceOf
      +
      +
      Parameters:
      +
      expectedClass - The predicate evaluates to true for instances of this class + or one of its subclasses.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      protected boolean matches(Object item, + Description mismatch)
      +
      Description copied from class: DiagnosingMatcher
      +
      Evaluates the matcher for argument item.
      +
      +
      Specified by:
      +
      matches in class DiagnosingMatcher<Object>
      +
      Parameters:
      +
      item - the value to check
      +
      mismatch - the description for the matcher
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      instanceOf

      +
      public static <T> Matcher<T> instanceOf(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. + +

      The created matcher assumes no relationship between specified type and the examined object.

      + For example: +
      assertThat(new Canoe(), instanceOf(Paddlable.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      any

      +
      public static <T> Matcher<T> any(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. + +

      The created matcher forces a relationship between specified type and the examined object, and should be + used when it is necessary to make generics conform, for example in the JMock clause + with(any(Thing.class))

      + For example: +
      assertThat(new Canoe(), instanceOf(Canoe.class));
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - the type to check.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsIterableContaining.html b/docs/javadoc/3.0/org/hamcrest/core/IsIterableContaining.html new file mode 100644 index 000000000..b7be42c62 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsIterableContaining.html @@ -0,0 +1,352 @@ + + + + +IsIterableContaining (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsIterableContaining<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Iterable<? super T>> +
org.hamcrest.TypeSafeDiagnosingMatcher<Iterable<? super T>> +
org.hamcrest.core.IsIterableContaining<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of items in the iterable
+
+
+
All Implemented Interfaces:
+
Matcher<Iterable<? super T>>, SelfDescribing
+
+
+
public class IsIterableContaining<T> +extends TypeSafeDiagnosingMatcher<Iterable<? super T>>
+
Tests if an iterable contains matching elements.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(Iterable<? super T> collection, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Iterable<? super T>>
      +
      Parameters:
      +
      collection - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is matched by the specified + itemMatcher. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatcher - the matcher to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItem

      +
      public static <T> Matcher<Iterable<? super T>> hasItem(T item)
      +
      Creates a matcher for Iterables that only matches when a single pass over the + examined Iterable yields at least one item that is equal to the specified + item. Whilst matching, the traversal of the examined Iterable + will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      item - the item to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of + the examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      itemMatchers - the matchers to apply to items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasItems

      +
      @SafeVarargs +public static <T> Matcher<Iterable<T>> hasItems(T... items)
      +
      Creates a matcher for Iterables 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. Whilst matching, each traversal of the + examined Iterable will stop as soon as a matching item is found. + For example: +
      assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      items - the items to compare against the items provided by the examined Iterable
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsNot.html b/docs/javadoc/3.0/org/hamcrest/core/IsNot.html new file mode 100644 index 000000000..48d746799 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsNot.html @@ -0,0 +1,283 @@ + + + + +IsNot (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsNot<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.IsNot<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsNot<T> +extends BaseMatcher<T>
+
Calculates the logical negation of a matcher.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsNot

      +
      public IsNot(Matcher<T> matcher)
      +
      Constructor, best called from not(Object) or + not(Matcher).
      +
      +
      Parameters:
      +
      matcher - the matcher to negate
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object arg)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      arg - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(Matcher<T> matcher)
      +
      Creates a matcher that wraps an existing matcher, but inverts the logic by which + it will match. + For example: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      matcher - the matcher whose sense should be inverted
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      not

      +
      public static <T> Matcher<T> not(T value)
      +
      A shortcut to the frequently used not(equalTo(x)). + For example: +
      assertThat(cheese, is(not(smelly)))
      + instead of: +
      assertThat(cheese, is(not(equalTo(smelly))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value that any examined object should not equal
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsNull.html b/docs/javadoc/3.0/org/hamcrest/core/IsNull.html new file mode 100644 index 000000000..cf7d317e0 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsNull.html @@ -0,0 +1,321 @@ + + + + +IsNull (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsNull<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.IsNull<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsNull<T> +extends BaseMatcher<T>
+
Is the value null?
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object o)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      o - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static Matcher<Object> nullValue()
      +

      Creates a matcher that matches if examined object is null. +

      + For example: +
      assertThat(cheese, is(nullValue())
      +
      +
      Returns:
      +
      The matcher
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static Matcher<Object> notNullValue()
      +
      A shortcut to the frequently used not(nullValue()). + For example: +
      assertThat(cheese, is(notNullValue()))
      + instead of: +
      assertThat(cheese, is(not(nullValue())))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      nullValue

      +
      public static <T> Matcher<T> nullValue(Class<T> type)
      +

      Creates a matcher that matches if examined object is null. + Accepts a single dummy argument to facilitate type inference. +

      + For example: +
      assertThat(cheese, is(nullValue(Cheese.class))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      notNullValue

      +
      public static <T> Matcher<T> notNullValue(Class<T> type)
      +
      A shortcut to the frequently used not(nullValue(X.class)). Accepts a + single dummy argument to facilitate type inference.. + For example: +
      assertThat(cheese, is(notNullValue(X.class)))
      + instead of: +
      assertThat(cheese, is(not(nullValue(X.class))))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      type - dummy parameter used to infer the generic type of the returned matcher
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/IsSame.html b/docs/javadoc/3.0/org/hamcrest/core/IsSame.html new file mode 100644 index 000000000..71f5650f7 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/IsSame.html @@ -0,0 +1,279 @@ + + + + +IsSame (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsSame<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.core.IsSame<T>
+
+
+
+
+
Type Parameters:
+
T - the matched value type
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class IsSame<T> +extends BaseMatcher<T>
+
Is the value the same object as another value?
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matches

      +
      public boolean matches(Object arg)
      +
      Description copied from interface: Matcher
      +
      Evaluates the matcher for argument item. + + This method matches against Object, instead of the generic type T. This is + because the caller of the Matcher does not know at runtime what the type is + (because of type erasure with Java generics). It is down to the implementations + to check the correct type.
      +
      +
      Parameters:
      +
      arg - the object against which the matcher is evaluated.
      +
      Returns:
      +
      true if item matches, otherwise false.
      +
      See Also:
      +
      + +
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      sameInstance

      +
      public static <T> Matcher<T> sameInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      theInstance

      +
      public static <T> Matcher<T> theInstance(T target)
      +
      Creates a matcher that matches only when the examined object is the same instance as + the specified target object.
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      target - the target instance against which others should be assessed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/StringContains.html b/docs/javadoc/3.0/org/hamcrest/core/StringContains.html new file mode 100644 index 000000000..6295c8071 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/StringContains.html @@ -0,0 +1,284 @@ + + + + +StringContains (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class StringContains

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class StringContains +extends SubstringMatcher
+
Tests if the argument is a string that contains a specific substring.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringContains

      +
      public StringContains(String substring)
      +
      Constructor, best used with containsString(String).
      +
      +
      Parameters:
      +
      substring - the expected substring.
      +
      +
      +
    • +
    • +
      +

      StringContains

      +
      public StringContains(boolean ignoringCase, + String substring)
      + +
      +
      Parameters:
      +
      ignoringCase - whether to ignore case when matching
      +
      substring - the expected substring.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      evalSubstringOf

      +
      protected boolean evalSubstringOf(String s)
      +
      Description copied from class: SubstringMatcher
      +
      Checks if the input matches the specific substring.
      +
      +
      Specified by:
      +
      evalSubstringOf in class SubstringMatcher
      +
      Parameters:
      +
      s - the string to check
      +
      Returns:
      +
      the result of the match
      +
      +
      +
    • +
    • +
      +

      containsString

      +
      public static Matcher<String> containsString(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere. + For example: +
      assertThat("myStringOfNote", containsString("ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      containsStringIgnoringCase

      +
      public static Matcher<String> containsStringIgnoringCase(String substring)
      +
      Creates a matcher that matches if the examined String contains the specified + String anywhere, ignoring case. + For example: +
      assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
      +
      +
      Parameters:
      +
      substring - the substring that the returned matcher will expect to find within any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/StringEndsWith.html b/docs/javadoc/3.0/org/hamcrest/core/StringEndsWith.html new file mode 100644 index 000000000..49ed7b92f --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/StringEndsWith.html @@ -0,0 +1,284 @@ + + + + +StringEndsWith (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class StringEndsWith

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class StringEndsWith +extends SubstringMatcher
+
Tests if the argument is a string that ends with a specific substring.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringEndsWith

      +
      public StringEndsWith(String suffix)
      +
      Constructor, best used with endsWith(String).
      +
      +
      Parameters:
      +
      suffix - the expected end of the string.
      +
      +
      +
    • +
    • +
      +

      StringEndsWith

      +
      public StringEndsWith(boolean ignoringCase, + String suffix)
      +
      Constructor, best used with endsWith(String) or + endsWithIgnoringCase(String).
      +
      +
      Parameters:
      +
      ignoringCase - whether to ignore case when matching
      +
      suffix - the expected end of the string.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      evalSubstringOf

      +
      protected boolean evalSubstringOf(String s)
      +
      Description copied from class: SubstringMatcher
      +
      Checks if the input matches the specific substring.
      +
      +
      Specified by:
      +
      evalSubstringOf in class SubstringMatcher
      +
      Parameters:
      +
      s - the string to check
      +
      Returns:
      +
      the result of the match
      +
      +
      +
    • +
    • +
      +

      endsWith

      +
      public static Matcher<String> endsWith(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String. + For example: +
      assertThat("myStringOfNote", endsWith("Note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      endsWithIgnoringCase

      +
      public static Matcher<String> endsWithIgnoringCase(String suffix)
      +
      Creates a matcher that matches if the examined String ends with the specified + String, ignoring case. + For example: +
      assertThat("myStringOfNote", endsWithIgnoringCase("note"))
      +
      +
      Parameters:
      +
      suffix - the substring that the returned matcher will expect at the end of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/StringRegularExpression.html b/docs/javadoc/3.0/org/hamcrest/core/StringRegularExpression.html new file mode 100644 index 000000000..b4f570358 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/StringRegularExpression.html @@ -0,0 +1,275 @@ + + + + +StringRegularExpression (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class StringRegularExpression

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class StringRegularExpression +extends TypeSafeDiagnosingMatcher<String>
+
A matcher that checks a string against a regular expression.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringRegularExpression

      +
      protected StringRegularExpression(Pattern pattern)
      +
      Constructor, best used from matchesRegex(String).
      +
      +
      Parameters:
      +
      pattern - the regular expression to match against
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(String actual, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<String>
      +
      Parameters:
      +
      actual - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      matchesRegex

      +
      public static Matcher<String> matchesRegex(Pattern pattern)
      +
      Creates a matcher that checks if the examined string matches a specified Pattern. + +
      + assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
      + 
      +
      +
      Parameters:
      +
      pattern - the pattern to be used.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesRegex

      +
      public static Matcher<String> matchesRegex(String regex)
      +
      Creates a matcher that checks if the examined string matches a specified regex. + +
      + assertThat("abc", matchesRegex("ˆ[a-z]+$"));
      + 
      +
      +
      Parameters:
      +
      regex - The regex to be used for the validation.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/StringStartsWith.html b/docs/javadoc/3.0/org/hamcrest/core/StringStartsWith.html new file mode 100644 index 000000000..6aceecf8d --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/StringStartsWith.html @@ -0,0 +1,290 @@ + + + + +StringStartsWith (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class StringStartsWith

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class StringStartsWith +extends SubstringMatcher
+
Tests if the argument is a string that starts with a specific substring.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringStartsWith

      +
      public StringStartsWith(String prefix)
      +
      Constructor, best used with startsWith(String).
      +
      +
      Parameters:
      +
      prefix - the expected start of the string.
      +
      +
      +
    • +
    • +
      +

      StringStartsWith

      +
      public StringStartsWith(boolean ignoringCase, + String prefix)
      +
      Constructor, best used with startsWith(String) or + startsWithIgnoringCase(String).
      +
      +
      Parameters:
      +
      ignoringCase - whether to ignore case when matching
      +
      prefix - the expected start of the string.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      evalSubstringOf

      +
      protected boolean evalSubstringOf(String s)
      +
      Description copied from class: SubstringMatcher
      +
      Checks if the input matches the specific substring.
      +
      +
      Specified by:
      +
      evalSubstringOf in class SubstringMatcher
      +
      Parameters:
      +
      s - the string to check
      +
      Returns:
      +
      the result of the match
      +
      +
      +
    • +
    • +
      +

      startsWith

      +
      public static Matcher<String> startsWith(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String. +

      + For example: +
      assertThat("myStringOfNote", startsWith("my"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      startsWithIgnoringCase

      +
      public static Matcher<String> startsWithIgnoringCase(String prefix)
      +

      + Creates a matcher that matches if the examined String starts with the specified + String, ignoring case +

      + For example: +
      assertThat("myStringOfNote", startsWithIgnoringCase("My"))
      +
      +
      Parameters:
      +
      prefix - the substring that the returned matcher will expect at the start of any examined string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/SubstringMatcher.html b/docs/javadoc/3.0/org/hamcrest/core/SubstringMatcher.html new file mode 100644 index 000000000..156602d5f --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/SubstringMatcher.html @@ -0,0 +1,339 @@ + + + + +SubstringMatcher (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class SubstringMatcher

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
Direct Known Subclasses:
+
StringContains, StringEndsWith, StringStartsWith
+
+
+
public abstract class SubstringMatcher +extends TypeSafeMatcher<String>
+
Common behaviour for matchers that check substrings.
+
+
See Also:
+
+ +
+
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    +
      +
    • +
      +

      substring

      +
      protected final String substring
      +
      The substring to match
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      SubstringMatcher

      +
      protected SubstringMatcher(String relationship, + boolean ignoringCase, + String substring)
      +
      Build a SubstringMatcher.
      +
      +
      Parameters:
      +
      relationship - a description of the matcher, such as "containing", "ending with", or "starting with"
      +
      ignoringCase - true for case-insensitive match
      +
      substring - the substring to match
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(String item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      converted

      +
      protected String converted(String arg)
      +
      Helper method to allow subclasses to handle case insensitivity.
      +
      +
      Parameters:
      +
      arg - the string to adjust for case
      +
      Returns:
      +
      the input string in lowercase if ignoring case, otherwise the original string
      +
      +
      +
    • +
    • +
      +

      evalSubstringOf

      +
      protected abstract boolean evalSubstringOf(String string)
      +
      Checks if the input matches the specific substring.
      +
      +
      Parameters:
      +
      string - the string to check
      +
      Returns:
      +
      the result of the match
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/package-summary.html b/docs/javadoc/3.0/org/hamcrest/core/package-summary.html new file mode 100644 index 000000000..6a8329d08 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/package-summary.html @@ -0,0 +1,193 @@ + + + + +org.hamcrest.core (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.core

+
+
+
package org.hamcrest.core
+
+
Fundamental matchers of objects and values, and composite matchers.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    Calculates the logical conjunction of multiple matchers.
    +
    + +
    +
    Calculates the logical disjunction of multiple matchers.
    +
    + +
    +
    Allows matchers of the same type to be combined using + either/or, or + both/and.
    +
    + +
    +
    Allows syntactic sugar of using both and and.
    +
    + +
    +
    Allows syntactic sugar of using either and or.
    +
    + +
    +
    Provides a custom description to another matcher.
    +
    + +
    +
    A matcher that applies a delegate matcher to every item in an Iterable.
    +
    +
    Is<T>
    +
    +
    Decorates another Matcher, retaining the behaviour but allowing tests + to be slightly more expressive.
    +
    + +
    +
    A matcher that always returns true.
    +
    + +
    Deprecated. +
    As of release 2.1, replaced by IsIterableContaining.
    +
    + +
    +
    Is the value equal to another value, as tested by the + Object.equals(java.lang.Object) method.
    +
    + +
    +
    Tests whether the value is an instance of a class.
    +
    + +
    +
    Tests if an iterable contains matching elements.
    +
    + +
    +
    Calculates the logical negation of a matcher.
    +
    + +
    +
    Is the value null?
    +
    + +
    +
    Is the value the same object as another value?
    +
    + +
    +
    Tests if the argument is a string that contains a specific substring.
    +
    + +
    +
    Tests if the argument is a string that ends with a specific substring.
    +
    + +
    +
    A matcher that checks a string against a regular expression.
    +
    + +
    +
    Tests if the argument is a string that starts with a specific substring.
    +
    + +
    +
    Common behaviour for matchers that check substrings.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/core/package-tree.html b/docs/javadoc/3.0/org/hamcrest/core/package-tree.html new file mode 100644 index 000000000..b9d0c4ec7 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/core/package-tree.html @@ -0,0 +1,110 @@ + + + + +org.hamcrest.core Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.core

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.FileStatus.html b/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.FileStatus.html new file mode 100644 index 000000000..ff213f13f --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.FileStatus.html @@ -0,0 +1,152 @@ + + + + +FileMatchers.FileStatus (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Interface FileMatchers.FileStatus

+
+
+
+
Enclosing class:
+
FileMatchers
+
+
+
public static interface FileMatchers.FileStatus
+
Checks the status of a File.
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    boolean
    +
    check(File actual)
    +
    +
    Checks the give file against a status.
    +
    +
    +
    +
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      check

      +
      boolean check(File actual)
      +
      Checks the give file against a status.
      +
      +
      Parameters:
      +
      actual - the file to check
      +
      Returns:
      +
      true if the file status matches, otherwise false.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.html b/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.html new file mode 100644 index 000000000..f186de0c5 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/io/FileMatchers.html @@ -0,0 +1,404 @@ + + + + +FileMatchers (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class FileMatchers

+
+
java.lang.Object +
org.hamcrest.io.FileMatchers
+
+
+
+
public final class FileMatchers +extends Object
+
Matchers for properties of files.
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      anExistingDirectory

      +
      public static Matcher<File> anExistingDirectory()
      +
      A matcher that checks if a directory exists.
      +
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      anExistingFileOrDirectory

      +
      public static Matcher<File> anExistingFileOrDirectory()
      +
      A matcher that checks if a file or directory exists.
      +
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      anExistingFile

      +
      public static Matcher<File> anExistingFile()
      +
      A matcher that checks if a file exists.
      +
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aReadableFile

      +
      public static Matcher<File> aReadableFile()
      +
      A matcher that checks if a file is readable.
      +
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aWritableFile

      +
      public static Matcher<File> aWritableFile()
      +
      A matcher that checks if a directory is writable.
      +
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aFileWithSize

      +
      public static Matcher<File> aFileWithSize(long size)
      +
      A matcher that checks if a file has a specific size.
      +
      +
      Parameters:
      +
      size - the expected size
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aFileWithSize

      +
      public static Matcher<File> aFileWithSize(Matcher<Long> expected)
      +
      A matcher that checks if a file size matches an expected size.
      +
      +
      Parameters:
      +
      expected - matcher for the expected size
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aFileNamed

      +
      public static Matcher<File> aFileNamed(Matcher<String> expected)
      +
      A matcher that checks if a file name matches an expected name.
      +
      +
      Parameters:
      +
      expected - the expected name
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aFileWithCanonicalPath

      +
      public static Matcher<File> aFileWithCanonicalPath(Matcher<String> expected)
      +
      A matcher that checks if a file canonical path matches an expected path.
      +
      +
      Parameters:
      +
      expected - the expected path
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    • +
      +

      aFileWithAbsolutePath

      +
      public static Matcher<File> aFileWithAbsolutePath(Matcher<String> expected)
      +
      A matcher that checks if a file absolute path matches an expected path.
      +
      +
      Parameters:
      +
      expected - the expected path
      +
      Returns:
      +
      the file matcher
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/io/package-summary.html b/docs/javadoc/3.0/org/hamcrest/io/package-summary.html new file mode 100644 index 000000000..5f4c03420 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/io/package-summary.html @@ -0,0 +1,115 @@ + + + + +org.hamcrest.io (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.io

+
+
+
package org.hamcrest.io
+
+
Matchers that perform file comparisons.
+
+
+
    +
  • + +
  • +
  • +
    +
    +
    +
    +
    Class
    +
    Description
    + +
    +
    Matchers for properties of files.
    +
    + +
    +
    Checks the status of a File.
    +
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/io/package-tree.html b/docs/javadoc/3.0/org/hamcrest/io/package-tree.html new file mode 100644 index 000000000..5e1e62c87 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/io/package-tree.html @@ -0,0 +1,77 @@ + + + + +org.hamcrest.io Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.io

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+

Interface Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/BigDecimalCloseTo.html b/docs/javadoc/3.0/org/hamcrest/number/BigDecimalCloseTo.html new file mode 100644 index 000000000..96e537eb8 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/BigDecimalCloseTo.html @@ -0,0 +1,284 @@ + + + + +BigDecimalCloseTo (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class BigDecimalCloseTo

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<BigDecimal>, SelfDescribing
+
+
+
public class BigDecimalCloseTo +extends TypeSafeMatcher<BigDecimal>
+
A matcher that checks a BigDecimal is close to an expected value.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(BigDecimal item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<BigDecimal>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(BigDecimal item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<BigDecimal>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      closeTo

      +
      public static Matcher<BigDecimal> closeTo(BigDecimal operand, + BigDecimal error)
      +
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal + to the specified operand, within a range of +/- error. The comparison for equality + is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method. + For example: +
      assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
      +
      +
      Parameters:
      +
      operand - the expected value of matching BigDecimals
      +
      error - the delta (+/-) within which matches will be allowed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/IsCloseTo.html b/docs/javadoc/3.0/org/hamcrest/number/IsCloseTo.html new file mode 100644 index 000000000..9ff9665c4 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/IsCloseTo.html @@ -0,0 +1,277 @@ + + + + +IsCloseTo (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsCloseTo

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<Double>, SelfDescribing
+
+
+
public class IsCloseTo +extends TypeSafeMatcher<Double>
+
Is the value a number equal to a value within some range of acceptable error?
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsCloseTo

      +
      public IsCloseTo(double value, + double error)
      +
      Constructor, best called from closeTo(double, double).
      +
      +
      Parameters:
      +
      value - the expected value
      +
      error - the acceptable difference from the expected value
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Double item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Double>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Double item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Double>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      closeTo

      +
      public static Matcher<Double> closeTo(double operand, + double error)
      +
      Creates a matcher of Doubles that matches when an examined double is equal + to the specified operand, within a range of +/- error. + For example: +
      assertThat(1.03, is(closeTo(1.0, 0.03)))
      +
      +
      Parameters:
      +
      operand - the expected value of matching doubles
      +
      error - the delta (+/-) within which matches will be allowed
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/IsNaN.html b/docs/javadoc/3.0/org/hamcrest/number/IsNaN.html new file mode 100644 index 000000000..47a763cf5 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/IsNaN.html @@ -0,0 +1,233 @@ + + + + +IsNaN (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsNaN

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<Double>, SelfDescribing
+
+
+
public final class IsNaN +extends TypeSafeMatcher<Double>
+
Is the value a number actually not a number (NaN)?
+
+
+ +
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Double item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Double>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Double item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Double>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      notANumber

      +
      public static Matcher<Double> notANumber()
      +
      Creates a matcher of Doubles that matches when an examined double is not a number. + For example: +
      assertThat(Double.NaN, is(notANumber()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/OrderingComparison.html b/docs/javadoc/3.0/org/hamcrest/number/OrderingComparison.html new file mode 100644 index 000000000..3ca0dc6c0 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/OrderingComparison.html @@ -0,0 +1,271 @@ + + + + +OrderingComparison (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class OrderingComparison

+
+
java.lang.Object +
org.hamcrest.number.OrderingComparison
+
+
+
+
public class OrderingComparison +extends Object
+
Static methods for building ordering comparisons.
+
+
+
    + +
  • +
    +

    Method Summary

    +
    +
    +
    +
    +
    Modifier and Type
    +
    Method
    +
    Description
    +
    static <T extends Comparable<T>>
    Matcher<T>
    +
    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 Comparable<T>>
    Matcher<T>
    +
    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 Comparable<T>>
    Matcher<T>
    + +
    +
    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 Comparable<T>>
    Matcher<T>
    +
    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 Comparable<T>>
    Matcher<T>
    + +
    +
    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.
    +
    +
    +
    +
    +
    +

    Methods inherited from class java.lang.Object

    +clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    +
    +
  • +
+
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      comparesEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, comparesEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThan

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(2, greaterThan(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return greater + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      greaterThanOrEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, greaterThanOrEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return greater + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThan

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, lessThan(2))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return less + than zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      lessThanOrEqualTo

      +
      public static <T extends Comparable<T>> Matcher<T> 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. + For example: +
      assertThat(1, lessThanOrEqualTo(1))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      value - the value which, when passed to the compareTo method of the examined object, should return less + than or equal to zero
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/package-summary.html b/docs/javadoc/3.0/org/hamcrest/number/package-summary.html new file mode 100644 index 000000000..161032ab7 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/package-summary.html @@ -0,0 +1,121 @@ + + + + +org.hamcrest.number (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.number

+
+
+
package org.hamcrest.number
+
+
Matchers that perform numeric comparisons.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    A matcher that checks a BigDecimal is close to an expected value.
    +
    + +
    +
    Is the value a number equal to a value within some range of acceptable error?
    +
    + +
    +
    Is the value a number actually not a number (NaN)?
    +
    + +
    +
    Static methods for building ordering comparisons.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/number/package-tree.html b/docs/javadoc/3.0/org/hamcrest/number/package-tree.html new file mode 100644 index 000000000..e816bfcbd --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/number/package-tree.html @@ -0,0 +1,82 @@ + + + + +org.hamcrest.number Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.number

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/HasEqualValues.html b/docs/javadoc/3.0/org/hamcrest/object/HasEqualValues.html new file mode 100644 index 000000000..47e170ceb --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/HasEqualValues.html @@ -0,0 +1,233 @@ + + + + +HasEqualValues (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasEqualValues<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<T> +
org.hamcrest.TypeSafeDiagnosingMatcher<T> +
org.hamcrest.object.HasEqualValues<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of the object being matched.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class HasEqualValues<T> +extends TypeSafeDiagnosingMatcher<T>
+
A matcher that checks if an object as equal fields values to an expected object.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      HasEqualValues

      +
      public HasEqualValues(T expectedObject)
      +
      Constructor
      +
      +
      Parameters:
      +
      expectedObject - the object with expected field values.
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(T item, + Description mismatch)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<T>
      +
      Parameters:
      +
      item - the item.
      +
      mismatch - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/HasToString.html b/docs/javadoc/3.0/org/hamcrest/object/HasToString.html new file mode 100644 index 000000000..b7b65c131 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/HasToString.html @@ -0,0 +1,263 @@ + + + + +HasToString (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasToString<T>

+
+ +
+
+
Type Parameters:
+
T - The Matcher type.
+
+
+
All Implemented Interfaces:
+
Matcher<T>, SelfDescribing
+
+
+
public class HasToString<T> +extends FeatureMatcher<T,String>
+
A Matcher that checks the output of the toString() method.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected String featureValueOf(T actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<T,String>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      hasToString

      +
      public static <T> Matcher<T> hasToString(Matcher<? super String> toStringMatcher)
      +
      Creates a matcher that matches any examined object whose toString method + returns a value that satisfies the specified matcher. + For example: +
      assertThat(true, hasToString(equalTo("TRUE")))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      toStringMatcher - the matcher used to verify the toString result
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasToString

      +
      public static <T> Matcher<T> hasToString(String expectedToString)
      +
      Creates a matcher that matches any examined object whose toString method + returns a value equalTo the specified string. + For example: +
      assertThat(true, hasToString("TRUE"))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      expectedToString - the expected toString result
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/IsCompatibleType.html b/docs/javadoc/3.0/org/hamcrest/object/IsCompatibleType.html new file mode 100644 index 000000000..7d2a4f398 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/IsCompatibleType.html @@ -0,0 +1,277 @@ + + + + +IsCompatibleType (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsCompatibleType<T>

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<Class<?>> +
org.hamcrest.TypeSafeMatcher<Class<?>> +
org.hamcrest.object.IsCompatibleType<T>
+
+
+
+
+
+
Type Parameters:
+
T - the type of the class
+
+
+
All Implemented Interfaces:
+
Matcher<Class<?>>, SelfDescribing
+
+
+
public class IsCompatibleType<T> +extends TypeSafeMatcher<Class<?>>
+
A matcher of Class that matches when the specified baseType is assignable from the examined class.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsCompatibleType

      +
      public IsCompatibleType(Class<T> type)
      +
      Constructor, best called from typeCompatibleWith(Class).
      +
      +
      Parameters:
      +
      type - the expected type
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Class<?> cls)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<Class<?>>
      +
      Parameters:
      +
      cls - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(Class<?> cls, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<Class<?>>
      +
      Parameters:
      +
      cls - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      typeCompatibleWith

      +
      public static <T> Matcher<Class<?>> typeCompatibleWith(Class<T> baseType)
      +
      Creates a matcher of Class that matches when the specified baseType is + assignable from the examined class. + For example: +
      assertThat(Integer.class, typeCompatibleWith(Number.class))
      +
      +
      Type Parameters:
      +
      T - the matcher type.
      +
      Parameters:
      +
      baseType - the base class to examine classes against
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/IsEventFrom.html b/docs/javadoc/3.0/org/hamcrest/object/IsEventFrom.html new file mode 100644 index 000000000..3fea01691 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/IsEventFrom.html @@ -0,0 +1,279 @@ + + + + +IsEventFrom (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEventFrom

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<EventObject>, SelfDescribing
+
+
+
public class IsEventFrom +extends TypeSafeDiagnosingMatcher<EventObject>
+
Tests if the value is an event announced by a specific object.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsEventFrom

      +
      public IsEventFrom(Class<?> eventClass, + Object source)
      +
      Constructor, best called from eventFrom(Object) or eventFrom(Class, Object).
      +
      +
      Parameters:
      +
      eventClass - the expected class of the event
      +
      source - the expected source of the event
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(EventObject item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<EventObject>
      +
      Parameters:
      +
      item - the item.
      +
      mismatchDescription - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      eventFrom

      +
      public static Matcher<EventObject> eventFrom(Class<? extends EventObject> eventClass, + Object source)
      +
      Creates a matcher of EventObject that matches any object + derived from eventClass announced by source. + For example: +
      assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
      +
      +
      Parameters:
      +
      eventClass - the class of the event to match on
      +
      source - the source of the event
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      eventFrom

      +
      public static Matcher<EventObject> eventFrom(Object source)
      +
      Creates a matcher of EventObject that matches any EventObject + announced by source. + For example: +
      assertThat(myEvent, is(eventFrom(myBean)))
      +
      +
      Parameters:
      +
      source - the source of the event
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/package-summary.html b/docs/javadoc/3.0/org/hamcrest/object/package-summary.html new file mode 100644 index 000000000..bb7739717 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/package-summary.html @@ -0,0 +1,121 @@ + + + + +org.hamcrest.object (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.object

+
+
+
package org.hamcrest.object
+
+
Matchers that inspect objects and classes.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    A matcher that checks if an object as equal fields values to an expected object.
    +
    + +
    +
    A Matcher that checks the output of the toString() method.
    +
    + +
    +
    A matcher of Class that matches when the specified baseType is assignable from the examined class.
    +
    + +
    +
    Tests if the value is an event announced by a specific object.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/object/package-tree.html b/docs/javadoc/3.0/org/hamcrest/object/package-tree.html new file mode 100644 index 000000000..63917865e --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/object/package-tree.html @@ -0,0 +1,90 @@ + + + + +org.hamcrest.object Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.object

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/package-summary.html b/docs/javadoc/3.0/org/hamcrest/package-summary.html new file mode 100644 index 000000000..a1aaa8966 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/package-summary.html @@ -0,0 +1,215 @@ + + + + +org.hamcrest (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest

+
+
+
package org.hamcrest
+
+
Top level matcher classes and interfaces.
+
+
+
    +
  • + +
  • +
  • +
    +
    +
    +
    +
    Class
    +
    Description
    + +
    +
    A Description that is stored as a string.
    +
    + +
    +
    BaseClass for all Matcher implementations.
    +
    + +
    +
    A Condition implements part of a multi-step match.
    +
    + +
    +
    Represents a single step in a multi-step sequence
    +
    + +
    +
    Builder methods for various matchers.
    +
    + +
    +
    Utility class for writing one off matchers.
    +
    + +
    +
    Utility class for writing one off matchers (with type safety and null checks).
    +
    + +
    +
    A description of a Matcher.
    +
    + +
    +
    A description that consumes input but does nothing.
    +
    + +
    +
    Convenient base class for Matchers of a specific type and that will report why the + received value has been rejected.
    +
    + +
    +
    Supporting class for matching a feature of an object.
    +
    + +
    +
    + A matcher over acceptable values.
    +
    + +
    +
    The Hamcrest entrypoint, static methods to check if matchers match a + given value.
    +
    + +
    +
    Builder methods for various matchers.
    +
    + +
    +
    The ability of an object to describe itself.
    +
    + +
    +
    A Description that is stored as a string.
    +
    + +
    +
    Convenient base class for Matchers that require a non-null value of a specific type + and that will report why the received value has been rejected.
    +
    + +
    +
    Convenient base class for Matchers that require a non-null value of a specific type.
    +
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/package-tree.html b/docs/javadoc/3.0/org/hamcrest/package-tree.html new file mode 100644 index 000000000..0bdef8a1e --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/package-tree.html @@ -0,0 +1,108 @@ + + + + +org.hamcrest Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+

Interface Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/CharSequenceLength.html b/docs/javadoc/3.0/org/hamcrest/text/CharSequenceLength.html new file mode 100644 index 000000000..54c716148 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/CharSequenceLength.html @@ -0,0 +1,265 @@ + + + + +CharSequenceLength (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class CharSequenceLength

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<CharSequence>, SelfDescribing
+
+
+
public class CharSequenceLength +extends FeatureMatcher<CharSequence,Integer>
+
A Matcher that checks the length of a string.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      featureValueOf

      +
      protected Integer featureValueOf(CharSequence actual)
      +
      Description copied from class: FeatureMatcher
      +
      Implement this to extract the interesting feature.
      +
      +
      Specified by:
      +
      featureValueOf in class FeatureMatcher<CharSequence,Integer>
      +
      Parameters:
      +
      actual - the target object
      +
      Returns:
      +
      the feature to be matched
      +
      +
      +
    • +
    • +
      +

      hasLength

      +
      public static Matcher<CharSequence> hasLength(int length)
      +
      Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
      + assertThat("text", hasLength(4))
      + 
      +
      +
      Parameters:
      +
      length - the expected length of the string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasLength

      +
      public static Matcher<CharSequence> hasLength(Matcher<? super Integer> lengthMatcher)
      +
      Creates a matcher of CharSequence that matches when a char sequence has the given length + For example: + +
      + assertThat("text", hasLength(lessThan(4)))
      + 
      +
      +
      Parameters:
      +
      lengthMatcher - the expected length of the string
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/IsBlankString.html b/docs/javadoc/3.0/org/hamcrest/text/IsBlankString.html new file mode 100644 index 000000000..1dd80e738 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/IsBlankString.html @@ -0,0 +1,232 @@ + + + + +IsBlankString (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsBlankString

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public final class IsBlankString +extends TypeSafeMatcher<String>
+
Matches blank Strings (and null).
+
+
+ +
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      blankString

      +
      public static Matcher<String> blankString()
      +
      Creates a matcher of String that matches when the examined string contains + zero or more whitespace characters and nothing else. + For example: +
      assertThat("  ", is(blankString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      blankOrNullString

      +
      public static Matcher<String> blankOrNullString()
      +
      Creates a matcher of String that matches when the examined string is null, or + contains zero or more whitespace characters and nothing else. + For example: +
      assertThat(((String)null), is(blankOrNullString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/IsEmptyString.html b/docs/javadoc/3.0/org/hamcrest/text/IsEmptyString.html new file mode 100644 index 000000000..ad434f897 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/IsEmptyString.html @@ -0,0 +1,279 @@ + + + + +IsEmptyString (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEmptyString

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public final class IsEmptyString +extends TypeSafeMatcher<String>
+
Matches empty Strings (and null).
+
+
+ +
+
+
    + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      isEmptyString

      +
      @Deprecated +public static Matcher<String> isEmptyString()
      +
      Deprecated. +
      use is(emptyString()) instead
      +
      +
      Creates a matcher of String that matches when the examined string has zero length. + For example: +
      assertThat("", isEmptyString())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyString

      +
      public static Matcher<String> emptyString()
      +
      Creates a matcher of String that matches when the examined string has zero length. + For example: +
      assertThat("", is(emptyString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      isEmptyOrNullString

      +
      @Deprecated +public static Matcher<String> isEmptyOrNullString()
      +
      Deprecated. +
      use is(emptyOrNullString()) instead
      +
      +
      Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
      assertThat(((String)null), isEmptyOrNullString())
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      emptyOrNullString

      +
      public static Matcher<String> emptyOrNullString()
      +
      Creates a matcher of String that matches when the examined string is null, or + has zero length. + For example: +
      assertThat(((String)null), is(emptyOrNullString()))
      +
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/IsEqualCompressingWhiteSpace.html b/docs/javadoc/3.0/org/hamcrest/text/IsEqualCompressingWhiteSpace.html new file mode 100644 index 000000000..40b63d11a --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/IsEqualCompressingWhiteSpace.html @@ -0,0 +1,332 @@ + + + + +IsEqualCompressingWhiteSpace (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEqualCompressingWhiteSpace

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<String> +
org.hamcrest.TypeSafeMatcher<String> +
org.hamcrest.text.IsEqualCompressingWhiteSpace
+
+
+
+
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class IsEqualCompressingWhiteSpace +extends TypeSafeMatcher<String>
+
Tests if a string is equal to another string, compressing any changes in whitespace.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsEqualCompressingWhiteSpace

      +
      public IsEqualCompressingWhiteSpace(String string)
      +
      Constructor, best called from equalToCompressingWhiteSpace(String).
      +
      +
      Parameters:
      +
      string - the expected string
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      getString

      +
      protected String getString()
      +
      Gets the string
      +
      +
      Returns:
      +
      the string
      +
      +
      +
    • +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(String item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      stripSpaces

      +
      public String stripSpaces(String toBeStripped)
      +
      Strips spaces
      +
      +
      Parameters:
      +
      toBeStripped - the string to be stripped
      +
      Returns:
      +
      the stripped string
      +
      +
      +
    • +
    • +
      +

      equalToIgnoringWhiteSpace

      +
      public static Matcher<String> equalToIgnoringWhiteSpace(String expectedString)
      + +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      equalToCompressingWhiteSpace

      +
      public static Matcher<String> equalToCompressingWhiteSpace(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. To be + exact, the following whitespace rules are applied: +
        +
      • all leading and trailing whitespace of both the expectedString and the examined string are ignored
      • +
      • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
      • +
      + For example: +
      assertThat("   my\tfoo  bar ", equalToCompressingWhiteSpace(" my  foo bar"))
      +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/IsEqualIgnoringCase.html b/docs/javadoc/3.0/org/hamcrest/text/IsEqualIgnoringCase.html new file mode 100644 index 000000000..1e2b07a4e --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/IsEqualIgnoringCase.html @@ -0,0 +1,271 @@ + + + + +IsEqualIgnoringCase (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class IsEqualIgnoringCase

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class IsEqualIgnoringCase +extends TypeSafeMatcher<String>
+
Tests if a string is equal to another string, regardless of the case.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      IsEqualIgnoringCase

      +
      public IsEqualIgnoringCase(String string)
      +
      Constructor, best called from equalToIgnoringCase(String).
      +
      +
      Parameters:
      +
      string - the expected string
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(String item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      equalToIgnoringCase

      +
      public static Matcher<String> equalToIgnoringCase(String expectedString)
      +
      Creates a matcher of String that matches when the examined string is equal to + the specified expectedString, ignoring case. + For example: +
      assertThat("Foo", equalToIgnoringCase("FOO"))
      +
      +
      Parameters:
      +
      expectedString - the expected value of matched strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/MatchesPattern.html b/docs/javadoc/3.0/org/hamcrest/text/MatchesPattern.html new file mode 100644 index 000000000..13f8e0dcd --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/MatchesPattern.html @@ -0,0 +1,268 @@ + + + + +MatchesPattern (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class MatchesPattern

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class MatchesPattern +extends TypeSafeMatcher<String>
+
Tests if a string matches a regular expression.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    + +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      protected boolean matchesSafely(String item)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      matchesPattern

      +
      public static Matcher<String> matchesPattern(Pattern pattern)
      +
      Creates a matcher of String that matches when the examined string + exactly matches the given Pattern.
      +
      +
      Parameters:
      +
      pattern - the text pattern to match.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      matchesPattern

      +
      public static Matcher<String> matchesPattern(String regex)
      +
      Creates a matcher of String that matches when the examined string + exactly matches the given regular expression, treated as a Pattern.
      +
      +
      Parameters:
      +
      regex - the regex to match.
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/StringContainsInOrder.html b/docs/javadoc/3.0/org/hamcrest/text/StringContainsInOrder.html new file mode 100644 index 000000000..e8a088c77 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/StringContainsInOrder.html @@ -0,0 +1,295 @@ + + + + +StringContainsInOrder (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class StringContainsInOrder

+
+
java.lang.Object +
org.hamcrest.BaseMatcher<String> +
org.hamcrest.TypeSafeMatcher<String> +
org.hamcrest.text.StringContainsInOrder
+
+
+
+
+
+
All Implemented Interfaces:
+
Matcher<String>, SelfDescribing
+
+
+
public class StringContainsInOrder +extends TypeSafeMatcher<String>
+
Tests if a string contains the given substrings in order.
+
+
+ +
+
+
    + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      StringContainsInOrder

      +
      public StringContainsInOrder(Iterable<String> substrings)
      +
      Constructor, best called from stringContainsInOrder(Iterable)
      +
      +
      Parameters:
      +
      substrings - the substrings that must be contained within matching strings
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(String s)
      +
      Description copied from class: TypeSafeMatcher
      +
      Check if the item matches. The item will already have been checked for + the specific type and will never be null. Subclasses should implement this.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      s - the type safe item to match against.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeMismatchSafely

      +
      public void describeMismatchSafely(String item, + Description mismatchDescription)
      +
      Description copied from class: TypeSafeMatcher
      +
      Describe the mismatch. The item will already have been checked for + the specific type and will never be null. Subclasses should override this.
      +
      +
      Overrides:
      +
      describeMismatchSafely in class TypeSafeMatcher<String>
      +
      Parameters:
      +
      item - the type safe item to match against.
      +
      mismatchDescription - the mismatch description.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      stringContainsInOrder

      +
      public static Matcher<String> stringContainsInOrder(Iterable<String> substrings)
      +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
      assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
      + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
      +
      +
      Parameters:
      +
      substrings - the substrings that must be contained within matching strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      stringContainsInOrder

      +
      public static Matcher<String> stringContainsInOrder(String... substrings)
      +
      Creates a matcher of String that matches when the examined string contains all of + the specified substrings, considering the order of their appearance. + For example: +
      assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
      + fails as "foo" occurs before "bar" in the string "myfoobarbaz"
      +
      +
      Parameters:
      +
      substrings - the substrings that must be contained within matching strings
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/package-summary.html b/docs/javadoc/3.0/org/hamcrest/text/package-summary.html new file mode 100644 index 000000000..555cde169 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/package-summary.html @@ -0,0 +1,133 @@ + + + + +org.hamcrest.text (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.text

+
+
+
package org.hamcrest.text
+
+
Matchers that perform text comparisons.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    A Matcher that checks the length of a string.
    +
    + +
    +
    Matches blank Strings (and null).
    +
    + +
    +
    Matches empty Strings (and null).
    +
    + +
    +
    Tests if a string is equal to another string, compressing any changes in whitespace.
    +
    + +
    +
    Tests if a string is equal to another string, regardless of the case.
    +
    + +
    +
    Tests if a string matches a regular expression.
    +
    + +
    +
    Tests if a string contains the given substrings in order.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/text/package-tree.html b/docs/javadoc/3.0/org/hamcrest/text/package-tree.html new file mode 100644 index 000000000..6648b3cb6 --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/text/package-tree.html @@ -0,0 +1,93 @@ + + + + +org.hamcrest.text Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.text

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/xml/HasXPath.html b/docs/javadoc/3.0/org/hamcrest/xml/HasXPath.html new file mode 100644 index 000000000..3c1cdfcfa --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/xml/HasXPath.html @@ -0,0 +1,389 @@ + + + + +HasXPath (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+ +
+ +

Class HasXPath

+
+ +
+
+
All Implemented Interfaces:
+
Matcher<Node>, SelfDescribing
+
+
+
public class HasXPath +extends TypeSafeDiagnosingMatcher<Node>
+
Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
+
+
+ +
+
+
    + +
  • +
    +

    Field Details

    +
      +
    • +
      +

      NO_NAMESPACE_CONTEXT

      +
      public static final NamespaceContext NO_NAMESPACE_CONTEXT
      +
      Null NamespaceContext, used to document deliberate use + of no namespace.
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Constructor Details

    +
      +
    • +
      +

      HasXPath

      +
      public HasXPath(String xPathExpression, + Matcher<String> valueMatcher)
      +
      Constructor, best called from one of the hasXPath static factory methods.
      +
      +
      Parameters:
      +
      xPathExpression - the target xpath
      +
      valueMatcher - matcher for the expected value
      +
      +
      +
    • +
    • +
      +

      HasXPath

      +
      public HasXPath(String xPathExpression, + NamespaceContext namespaceContext, + Matcher<String> valueMatcher)
      +
      Constructor, best called from one of the hasXPath static factory methods.
      +
      +
      Parameters:
      +
      xPathExpression - the target xpath
      +
      namespaceContext - the namespace for matching nodes
      +
      valueMatcher - matcher for the expected value
      +
      +
      +
    • +
    +
    +
  • + +
  • +
    +

    Method Details

    +
      +
    • +
      +

      matchesSafely

      +
      public boolean matchesSafely(Node item, + Description mismatch)
      +
      Description copied from class: TypeSafeDiagnosingMatcher
      +
      Subclasses should implement this. The item will already have been checked + for the specific type and will never be null.
      +
      +
      Specified by:
      +
      matchesSafely in class TypeSafeDiagnosingMatcher<Node>
      +
      Parameters:
      +
      item - the item.
      +
      mismatch - the mismatch description.
      +
      Returns:
      +
      boolean true/false depending if item matches matcher.
      +
      +
      +
    • +
    • +
      +

      describeTo

      +
      public void describeTo(Description description)
      +
      Description copied from interface: SelfDescribing
      +
      Generates a description of the object. The description may be part of a + description of a larger object of which this is just a component, so it + should be worded appropriately.
      +
      +
      Parameters:
      +
      description - The description to be built or appended to.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + Matcher<String> valueMatcher)
      +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath that satisfies the specified valueMatcher. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      valueMatcher - matcher for the value at the specified xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + NamespaceContext namespaceContext, + Matcher<String> valueMatcher)
      +
      Creates a matcher of Nodes that matches when the examined node has a value at the + specified xPath, within the specified namespaceContext, that satisfies + the specified valueMatcher. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      namespaceContext - the namespace for matching nodes
      +
      valueMatcher - matcher for the value at the specified xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath)
      +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath, with any content. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese"))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    • +
      +

      hasXPath

      +
      public static Matcher<Node> hasXPath(String xPath, + NamespaceContext namespaceContext)
      +
      Creates a matcher of Nodes that matches when the examined node contains a node + at the specified xPath within the specified namespace context, with any content. + For example: +
      assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
      +
      +
      Parameters:
      +
      xPath - the target xpath
      +
      namespaceContext - the namespace for matching nodes
      +
      Returns:
      +
      The matcher.
      +
      +
      +
    • +
    +
    +
  • +
+
+ +
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/xml/package-summary.html b/docs/javadoc/3.0/org/hamcrest/xml/package-summary.html new file mode 100644 index 000000000..32c760dec --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/xml/package-summary.html @@ -0,0 +1,109 @@ + + + + +org.hamcrest.xml (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Package org.hamcrest.xml

+
+
+
package org.hamcrest.xml
+
+
Matchers of XML documents.
+
+
+
    +
  • + +
  • +
  • +
    +
    Classes
    +
    +
    Class
    +
    Description
    + +
    +
    Applies a Matcher to a given XML Node in an existing XML Node tree, specified by an XPath expression.
    +
    +
    +
    +
  • +
+
+
+
+
+ + diff --git a/docs/javadoc/3.0/org/hamcrest/xml/package-tree.html b/docs/javadoc/3.0/org/hamcrest/xml/package-tree.html new file mode 100644 index 000000000..56b9e6a6a --- /dev/null +++ b/docs/javadoc/3.0/org/hamcrest/xml/package-tree.html @@ -0,0 +1,79 @@ + + + + +org.hamcrest.xml Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For Package org.hamcrest.xml

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/overview-summary.html b/docs/javadoc/3.0/overview-summary.html new file mode 100644 index 000000000..cfbd1deb4 --- /dev/null +++ b/docs/javadoc/3.0/overview-summary.html @@ -0,0 +1,25 @@ + + + + +Hamcrest 3.0 API + + + + + + + + + + +
+ +

index.html

+
+ + diff --git a/docs/javadoc/3.0/overview-tree.html b/docs/javadoc/3.0/overview-tree.html new file mode 100644 index 000000000..bdd32170b --- /dev/null +++ b/docs/javadoc/3.0/overview-tree.html @@ -0,0 +1,187 @@ + + + + +Class Hierarchy (Hamcrest 3.0 API) + + + + + + + + + + + + + +
+ +
+
+
+

Hierarchy For All Packages

+
+Package Hierarchies: + +
+

Class Hierarchy

+ +
+
+

Interface Hierarchy

+ +
+
+
+
+ + diff --git a/docs/javadoc/3.0/package-search-index.js b/docs/javadoc/3.0/package-search-index.js new file mode 100644 index 000000000..300a4e7f8 --- /dev/null +++ b/docs/javadoc/3.0/package-search-index.js @@ -0,0 +1 @@ +packageSearchIndex = [{"l":"All Packages","u":"allpackages-index.html"},{"l":"org.hamcrest"},{"l":"org.hamcrest.beans"},{"l":"org.hamcrest.collection"},{"l":"org.hamcrest.comparator"},{"l":"org.hamcrest.core"},{"l":"org.hamcrest.io"},{"l":"org.hamcrest.number"},{"l":"org.hamcrest.object"},{"l":"org.hamcrest.text"},{"l":"org.hamcrest.xml"}];updateSearchResults(); \ No newline at end of file diff --git a/docs/javadoc/3.0/resources/glass.png b/docs/javadoc/3.0/resources/glass.png new file mode 100644 index 000000000..a7f591f46 Binary files /dev/null and b/docs/javadoc/3.0/resources/glass.png differ diff --git a/docs/javadoc/3.0/resources/x.png b/docs/javadoc/3.0/resources/x.png new file mode 100644 index 000000000..30548a756 Binary files /dev/null and b/docs/javadoc/3.0/resources/x.png differ diff --git a/docs/javadoc/3.0/script-dir/jquery-3.6.1.min.js b/docs/javadoc/3.0/script-dir/jquery-3.6.1.min.js new file mode 100644 index 000000000..2c69bc908 --- /dev/null +++ b/docs/javadoc/3.0/script-dir/jquery-3.6.1.min.js @@ -0,0 +1,2 @@ +/*! jQuery v3.6.1 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,y=n.hasOwnProperty,a=y.toString,l=a.call(Object),v={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.1",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&v(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!y||!y.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ve(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ye(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ve(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],y=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&y.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||y.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||y.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||y.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||y.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||y.push(".#.+[+~]"),e.querySelectorAll("\\\f"),y.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&y.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&y.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&y.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),y.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),y=y.length&&new RegExp(y.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),v=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&v(p,e)?-1:t==C||t.ownerDocument==p&&v(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!y||!y.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),v.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",v.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",v.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ye(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ve(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+Ct.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+r):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),v.createHTMLDocument=((Ut=E.implementation.createHTMLDocument("").body).innerHTML="
",2===Ut.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(v.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return B(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=_e(v.pixelPosition,function(e,t){if(t)return t=Be(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return B(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,e){e=x(e||this.defaultElement||this)[0],this.element=x(e),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=x(),this.hoverable=x(),this.focusable=x(),this.classesElementLookup={},e!==this&&(x.data(e,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===e&&this.destroy()}}),this.document=x(e.style?e.ownerDocument:e.document||e),this.window=x(this.document[0].defaultView||this.document[0].parentWindow)),this.options=x.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:x.noop,_create:x.noop,_init:x.noop,destroy:function(){var i=this;this._destroy(),x.each(this.classesElementLookup,function(t,e){i._removeClass(e,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:x.noop,widget:function(){return this.element},option:function(t,e){var i,s,n,o=t;if(0===arguments.length)return x.widget.extend({},this.options);if("string"==typeof t)if(o={},t=(i=t.split(".")).shift(),i.length){for(s=o[t]=x.widget.extend({},this.options[t]),n=0;n
"),i=e.children()[0];return x("body").append(e),t=i.offsetWidth,e.css("overflow","scroll"),t===(i=i.offsetWidth)&&(i=e[0].clientWidth),e.remove(),s=t-i},getScrollInfo:function(t){var e=t.isWindow||t.isDocument?"":t.element.css("overflow-x"),i=t.isWindow||t.isDocument?"":t.element.css("overflow-y"),e="scroll"===e||"auto"===e&&t.widthC(E(s),E(n))?o.important="horizontal":o.important="vertical",c.using.call(this,t,o)}),l.offset(x.extend(u,{using:t}))})},x.ui.position={fit:{left:function(t,e){var i=e.within,s=i.isWindow?i.scrollLeft:i.offset.left,n=i.width,o=t.left-e.collisionPosition.marginLeft,l=s-o,a=o+e.collisionWidth-n-s;e.collisionWidth>n?0n?0",delay:300,options:{icons:{submenu:"ui-icon-caret-1-e"},items:"> *",menus:"ul",position:{my:"left top",at:"right top"},role:"menu",blur:null,focus:null,select:null},_create:function(){this.activeMenu=this.element,this.mouseHandled=!1,this.lastMousePosition={x:null,y:null},this.element.uniqueId().attr({role:this.options.role,tabIndex:0}),this._addClass("ui-menu","ui-widget ui-widget-content"),this._on({"mousedown .ui-menu-item":function(t){t.preventDefault(),this._activateItem(t)},"click .ui-menu-item":function(t){var e=x(t.target),i=x(x.ui.safeActiveElement(this.document[0]));!this.mouseHandled&&e.not(".ui-state-disabled").length&&(this.select(t),t.isPropagationStopped()||(this.mouseHandled=!0),e.has(".ui-menu").length?this.expand(t):!this.element.is(":focus")&&i.closest(".ui-menu").length&&(this.element.trigger("focus",[!0]),this.active&&1===this.active.parents(".ui-menu").length&&clearTimeout(this.timer)))},"mouseenter .ui-menu-item":"_activateItem","mousemove .ui-menu-item":"_activateItem",mouseleave:"collapseAll","mouseleave .ui-menu":"collapseAll",focus:function(t,e){var i=this.active||this._menuItems().first();e||this.focus(t,i)},blur:function(t){this._delay(function(){x.contains(this.element[0],x.ui.safeActiveElement(this.document[0]))||this.collapseAll(t)})},keydown:"_keydown"}),this.refresh(),this._on(this.document,{click:function(t){this._closeOnDocumentClick(t)&&this.collapseAll(t,!0),this.mouseHandled=!1}})},_activateItem:function(t){var e,i;this.previousFilter||t.clientX===this.lastMousePosition.x&&t.clientY===this.lastMousePosition.y||(this.lastMousePosition={x:t.clientX,y:t.clientY},e=x(t.target).closest(".ui-menu-item"),i=x(t.currentTarget),e[0]===i[0]&&(i.is(".ui-state-active")||(this._removeClass(i.siblings().children(".ui-state-active"),null,"ui-state-active"),this.focus(t,i))))},_destroy:function(){var t=this.element.find(".ui-menu-item").removeAttr("role aria-disabled").children(".ui-menu-item-wrapper").removeUniqueId().removeAttr("tabIndex role aria-haspopup");this.element.removeAttr("aria-activedescendant").find(".ui-menu").addBack().removeAttr("role aria-labelledby aria-expanded aria-hidden aria-disabled tabIndex").removeUniqueId().show(),t.children().each(function(){var t=x(this);t.data("ui-menu-submenu-caret")&&t.remove()})},_keydown:function(t){var e,i,s,n=!0;switch(t.keyCode){case x.ui.keyCode.PAGE_UP:this.previousPage(t);break;case x.ui.keyCode.PAGE_DOWN:this.nextPage(t);break;case x.ui.keyCode.HOME:this._move("first","first",t);break;case x.ui.keyCode.END:this._move("last","last",t);break;case x.ui.keyCode.UP:this.previous(t);break;case x.ui.keyCode.DOWN:this.next(t);break;case x.ui.keyCode.LEFT:this.collapse(t);break;case x.ui.keyCode.RIGHT:this.active&&!this.active.is(".ui-state-disabled")&&this.expand(t);break;case x.ui.keyCode.ENTER:case x.ui.keyCode.SPACE:this._activate(t);break;case x.ui.keyCode.ESCAPE:this.collapse(t);break;default:e=this.previousFilter||"",s=n=!1,i=96<=t.keyCode&&t.keyCode<=105?(t.keyCode-96).toString():String.fromCharCode(t.keyCode),clearTimeout(this.filterTimer),i===e?s=!0:i=e+i,e=this._filterMenuItems(i),(e=s&&-1!==e.index(this.active.next())?this.active.nextAll(".ui-menu-item"):e).length||(i=String.fromCharCode(t.keyCode),e=this._filterMenuItems(i)),e.length?(this.focus(t,e),this.previousFilter=i,this.filterTimer=this._delay(function(){delete this.previousFilter},1e3)):delete this.previousFilter}n&&t.preventDefault()},_activate:function(t){this.active&&!this.active.is(".ui-state-disabled")&&(this.active.children("[aria-haspopup='true']").length?this.expand(t):this.select(t))},refresh:function(){var t,e,s=this,n=this.options.icons.submenu,i=this.element.find(this.options.menus);this._toggleClass("ui-menu-icons",null,!!this.element.find(".ui-icon").length),e=i.filter(":not(.ui-menu)").hide().attr({role:this.options.role,"aria-hidden":"true","aria-expanded":"false"}).each(function(){var t=x(this),e=t.prev(),i=x("").data("ui-menu-submenu-caret",!0);s._addClass(i,"ui-menu-icon","ui-icon "+n),e.attr("aria-haspopup","true").prepend(i),t.attr("aria-labelledby",e.attr("id"))}),this._addClass(e,"ui-menu","ui-widget ui-widget-content ui-front"),(t=i.add(this.element).find(this.options.items)).not(".ui-menu-item").each(function(){var t=x(this);s._isDivider(t)&&s._addClass(t,"ui-menu-divider","ui-widget-content")}),i=(e=t.not(".ui-menu-item, .ui-menu-divider")).children().not(".ui-menu").uniqueId().attr({tabIndex:-1,role:this._itemRole()}),this._addClass(e,"ui-menu-item")._addClass(i,"ui-menu-item-wrapper"),t.filter(".ui-state-disabled").attr("aria-disabled","true"),this.active&&!x.contains(this.element[0],this.active[0])&&this.blur()},_itemRole:function(){return{menu:"menuitem",listbox:"option"}[this.options.role]},_setOption:function(t,e){var i;"icons"===t&&(i=this.element.find(".ui-menu-icon"),this._removeClass(i,null,this.options.icons.submenu)._addClass(i,null,e.submenu)),this._super(t,e)},_setOptionDisabled:function(t){this._super(t),this.element.attr("aria-disabled",String(t)),this._toggleClass(null,"ui-state-disabled",!!t)},focus:function(t,e){var i;this.blur(t,t&&"focus"===t.type),this._scrollIntoView(e),this.active=e.first(),i=this.active.children(".ui-menu-item-wrapper"),this._addClass(i,null,"ui-state-active"),this.options.role&&this.element.attr("aria-activedescendant",i.attr("id")),i=this.active.parent().closest(".ui-menu-item").children(".ui-menu-item-wrapper"),this._addClass(i,null,"ui-state-active"),t&&"keydown"===t.type?this._close():this.timer=this._delay(function(){this._close()},this.delay),(i=e.children(".ui-menu")).length&&t&&/^mouse/.test(t.type)&&this._startOpening(i),this.activeMenu=e.parent(),this._trigger("focus",t,{item:e})},_scrollIntoView:function(t){var e,i,s;this._hasScroll()&&(i=parseFloat(x.css(this.activeMenu[0],"borderTopWidth"))||0,s=parseFloat(x.css(this.activeMenu[0],"paddingTop"))||0,e=t.offset().top-this.activeMenu.offset().top-i-s,i=this.activeMenu.scrollTop(),s=this.activeMenu.height(),t=t.outerHeight(),e<0?this.activeMenu.scrollTop(i+e):s",options:{appendTo:null,autoFocus:!1,delay:300,minLength:1,position:{my:"left top",at:"left bottom",collision:"none"},source:null,change:null,close:null,focus:null,open:null,response:null,search:null,select:null},requestIndex:0,pending:0,liveRegionTimer:null,_create:function(){var i,s,n,t=this.element[0].nodeName.toLowerCase(),e="textarea"===t,t="input"===t;this.isMultiLine=e||!t&&this._isContentEditable(this.element),this.valueMethod=this.element[e||t?"val":"text"],this.isNewMenu=!0,this._addClass("ui-autocomplete-input"),this.element.attr("autocomplete","off"),this._on(this.element,{keydown:function(t){if(this.element.prop("readOnly"))s=n=i=!0;else{s=n=i=!1;var e=x.ui.keyCode;switch(t.keyCode){case e.PAGE_UP:i=!0,this._move("previousPage",t);break;case e.PAGE_DOWN:i=!0,this._move("nextPage",t);break;case e.UP:i=!0,this._keyEvent("previous",t);break;case e.DOWN:i=!0,this._keyEvent("next",t);break;case e.ENTER:this.menu.active&&(i=!0,t.preventDefault(),this.menu.select(t));break;case e.TAB:this.menu.active&&this.menu.select(t);break;case e.ESCAPE:this.menu.element.is(":visible")&&(this.isMultiLine||this._value(this.term),this.close(t),t.preventDefault());break;default:s=!0,this._searchTimeout(t)}}},keypress:function(t){if(i)return i=!1,void(this.isMultiLine&&!this.menu.element.is(":visible")||t.preventDefault());if(!s){var e=x.ui.keyCode;switch(t.keyCode){case e.PAGE_UP:this._move("previousPage",t);break;case e.PAGE_DOWN:this._move("nextPage",t);break;case e.UP:this._keyEvent("previous",t);break;case e.DOWN:this._keyEvent("next",t)}}},input:function(t){if(n)return n=!1,void t.preventDefault();this._searchTimeout(t)},focus:function(){this.selectedItem=null,this.previous=this._value()},blur:function(t){clearTimeout(this.searching),this.close(t),this._change(t)}}),this._initSource(),this.menu=x("
    ").appendTo(this._appendTo()).menu({role:null}).hide().attr({unselectable:"on"}).menu("instance"),this._addClass(this.menu.element,"ui-autocomplete","ui-front"),this._on(this.menu.element,{mousedown:function(t){t.preventDefault()},menufocus:function(t,e){var i,s;if(this.isNewMenu&&(this.isNewMenu=!1,t.originalEvent&&/^mouse/.test(t.originalEvent.type)))return this.menu.blur(),void this.document.one("mousemove",function(){x(t.target).trigger(t.originalEvent)});s=e.item.data("ui-autocomplete-item"),!1!==this._trigger("focus",t,{item:s})&&t.originalEvent&&/^key/.test(t.originalEvent.type)&&this._value(s.value),(i=e.item.attr("aria-label")||s.value)&&String.prototype.trim.call(i).length&&(clearTimeout(this.liveRegionTimer),this.liveRegionTimer=this._delay(function(){this.liveRegion.html(x("
    ").text(i))},100))},menuselect:function(t,e){var i=e.item.data("ui-autocomplete-item"),s=this.previous;this.element[0]!==x.ui.safeActiveElement(this.document[0])&&(this.element.trigger("focus"),this.previous=s,this._delay(function(){this.previous=s,this.selectedItem=i})),!1!==this._trigger("select",t,{item:i})&&this._value(i.value),this.term=this._value(),this.close(t),this.selectedItem=i}}),this.liveRegion=x("
    ",{role:"status","aria-live":"assertive","aria-relevant":"additions"}).appendTo(this.document[0].body),this._addClass(this.liveRegion,null,"ui-helper-hidden-accessible"),this._on(this.window,{beforeunload:function(){this.element.removeAttr("autocomplete")}})},_destroy:function(){clearTimeout(this.searching),this.element.removeAttr("autocomplete"),this.menu.element.remove(),this.liveRegion.remove()},_setOption:function(t,e){this._super(t,e),"source"===t&&this._initSource(),"appendTo"===t&&this.menu.element.appendTo(this._appendTo()),"disabled"===t&&e&&this.xhr&&this.xhr.abort()},_isEventTargetInWidget:function(t){var e=this.menu.element[0];return t.target===this.element[0]||t.target===e||x.contains(e,t.target)},_closeOnClickOutside:function(t){this._isEventTargetInWidget(t)||this.close()},_appendTo:function(){var t=this.options.appendTo;return t=!(t=!(t=t&&(t.jquery||t.nodeType?x(t):this.document.find(t).eq(0)))||!t[0]?this.element.closest(".ui-front, dialog"):t).length?this.document[0].body:t},_initSource:function(){var i,s,n=this;Array.isArray(this.options.source)?(i=this.options.source,this.source=function(t,e){e(x.ui.autocomplete.filter(i,t.term))}):"string"==typeof this.options.source?(s=this.options.source,this.source=function(t,e){n.xhr&&n.xhr.abort(),n.xhr=x.ajax({url:s,data:t,dataType:"json",success:function(t){e(t)},error:function(){e([])}})}):this.source=this.options.source},_searchTimeout:function(s){clearTimeout(this.searching),this.searching=this._delay(function(){var t=this.term===this._value(),e=this.menu.element.is(":visible"),i=s.altKey||s.ctrlKey||s.metaKey||s.shiftKey;t&&(e||i)||(this.selectedItem=null,this.search(null,s))},this.options.delay)},search:function(t,e){return t=null!=t?t:this._value(),this.term=this._value(),t.length").append(x("
    ").text(e.label)).appendTo(t)},_move:function(t,e){if(this.menu.element.is(":visible"))return this.menu.isFirstItem()&&/^previous/.test(t)||this.menu.isLastItem()&&/^next/.test(t)?(this.isMultiLine||this._value(this.term),void this.menu.blur()):void this.menu[t](e);this.search(null,e)},widget:function(){return this.menu.element},_value:function(){return this.valueMethod.apply(this.element,arguments)},_keyEvent:function(t,e){this.isMultiLine&&!this.menu.element.is(":visible")||(this._move(t,e),e.preventDefault())},_isContentEditable:function(t){if(!t.length)return!1;var e=t.prop("contentEditable");return"inherit"===e?this._isContentEditable(t.parent()):"true"===e}}),x.extend(x.ui.autocomplete,{escapeRegex:function(t){return t.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")},filter:function(t,e){var i=new RegExp(x.ui.autocomplete.escapeRegex(e),"i");return x.grep(t,function(t){return i.test(t.label||t.value||t)})}}),x.widget("ui.autocomplete",x.ui.autocomplete,{options:{messages:{noResults:"No search results.",results:function(t){return t+(1").text(e))},100))}});x.ui.autocomplete}); \ No newline at end of file diff --git a/docs/javadoc/3.0/script.js b/docs/javadoc/3.0/script.js new file mode 100644 index 000000000..bb9c8a241 --- /dev/null +++ b/docs/javadoc/3.0/script.js @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +var moduleSearchIndex; +var packageSearchIndex; +var typeSearchIndex; +var memberSearchIndex; +var tagSearchIndex; + +var oddRowColor = "odd-row-color"; +var evenRowColor = "even-row-color"; +var sortAsc = "sort-asc"; +var sortDesc = "sort-desc"; +var tableTab = "table-tab"; +var activeTableTab = "active-table-tab"; + +function loadScripts(doc, tag) { + createElem(doc, tag, 'search.js'); + + createElem(doc, tag, 'module-search-index.js'); + createElem(doc, tag, 'package-search-index.js'); + createElem(doc, tag, 'type-search-index.js'); + createElem(doc, tag, 'member-search-index.js'); + createElem(doc, tag, 'tag-search-index.js'); +} + +function createElem(doc, tag, path) { + var script = doc.createElement(tag); + var scriptElement = doc.getElementsByTagName(tag)[0]; + script.src = pathtoroot + path; + scriptElement.parentNode.insertBefore(script, scriptElement); +} + +// Helper for making content containing release names comparable lexicographically +function makeComparable(s) { + return s.toLowerCase().replace(/(\d+)/g, + function(n, m) { + return ("000" + m).slice(-4); + }); +} + +// Switches between two styles depending on a condition +function toggleStyle(classList, condition, trueStyle, falseStyle) { + if (condition) { + classList.remove(falseStyle); + classList.add(trueStyle); + } else { + classList.remove(trueStyle); + classList.add(falseStyle); + } +} + +// Sorts the rows in a table lexicographically by the content of a specific column +function sortTable(header, columnIndex, columns) { + var container = header.parentElement; + var descending = header.classList.contains(sortAsc); + container.querySelectorAll("div.table-header").forEach( + function(header) { + header.classList.remove(sortAsc); + header.classList.remove(sortDesc); + } + ) + var cells = container.children; + var rows = []; + for (var i = columns; i < cells.length; i += columns) { + rows.push(Array.prototype.slice.call(cells, i, i + columns)); + } + var comparator = function(a, b) { + var ka = makeComparable(a[columnIndex].textContent); + var kb = makeComparable(b[columnIndex].textContent); + if (ka < kb) + return descending ? 1 : -1; + if (ka > kb) + return descending ? -1 : 1; + return 0; + }; + var sorted = rows.sort(comparator); + var visible = 0; + sorted.forEach(function(row) { + if (row[0].style.display !== 'none') { + var isEvenRow = visible++ % 2 === 0; + } + row.forEach(function(cell) { + toggleStyle(cell.classList, isEvenRow, evenRowColor, oddRowColor); + container.appendChild(cell); + }) + }); + toggleStyle(header.classList, descending, sortDesc, sortAsc); +} + +// Toggles the visibility of a table category in all tables in a page +function toggleGlobal(checkbox, selected, columns) { + var display = checkbox.checked ? '' : 'none'; + document.querySelectorAll("div.table-tabs").forEach(function(t) { + var id = t.parentElement.getAttribute("id"); + var selectedClass = id + "-tab" + selected; + // if selected is empty string it selects all uncategorized entries + var selectUncategorized = !Boolean(selected); + var visible = 0; + document.querySelectorAll('div.' + id) + .forEach(function(elem) { + if (selectUncategorized) { + if (elem.className.indexOf(selectedClass) === -1) { + elem.style.display = display; + } + } else if (elem.classList.contains(selectedClass)) { + elem.style.display = display; + } + if (elem.style.display === '') { + var isEvenRow = visible++ % (columns * 2) < columns; + toggleStyle(elem.classList, isEvenRow, evenRowColor, oddRowColor); + } + }); + var displaySection = visible === 0 ? 'none' : ''; + t.parentElement.style.display = displaySection; + document.querySelector("li#contents-" + id).style.display = displaySection; + }) +} + +// Shows the elements of a table belonging to a specific category +function show(tableId, selected, columns) { + if (tableId !== selected) { + document.querySelectorAll('div.' + tableId + ':not(.' + selected + ')') + .forEach(function(elem) { + elem.style.display = 'none'; + }); + } + document.querySelectorAll('div.' + selected) + .forEach(function(elem, index) { + elem.style.display = ''; + var isEvenRow = index % (columns * 2) < columns; + toggleStyle(elem.classList, isEvenRow, evenRowColor, oddRowColor); + }); + updateTabs(tableId, selected); +} + +function updateTabs(tableId, selected) { + document.getElementById(tableId + '.tabpanel') + .setAttribute('aria-labelledby', selected); + document.querySelectorAll('button[id^="' + tableId + '"]') + .forEach(function(tab, index) { + if (selected === tab.id || (tableId === selected && index === 0)) { + tab.className = activeTableTab; + tab.setAttribute('aria-selected', true); + tab.setAttribute('tabindex',0); + } else { + tab.className = tableTab; + tab.setAttribute('aria-selected', false); + tab.setAttribute('tabindex',-1); + } + }); +} + +function switchTab(e) { + var selected = document.querySelector('[aria-selected=true]'); + if (selected) { + if ((e.keyCode === 37 || e.keyCode === 38) && selected.previousSibling) { + // left or up arrow key pressed: move focus to previous tab + selected.previousSibling.click(); + selected.previousSibling.focus(); + e.preventDefault(); + } else if ((e.keyCode === 39 || e.keyCode === 40) && selected.nextSibling) { + // right or down arrow key pressed: move focus to next tab + selected.nextSibling.click(); + selected.nextSibling.focus(); + e.preventDefault(); + } + } +} + +var updateSearchResults = function() {}; + +function indexFilesLoaded() { + return moduleSearchIndex + && packageSearchIndex + && typeSearchIndex + && memberSearchIndex + && tagSearchIndex; +} +// Copy the contents of the local snippet to the clipboard +function copySnippet(button) { + copyToClipboard(button.nextElementSibling.innerText); + switchCopyLabel(button, button.firstElementChild); +} +function copyToClipboard(content) { + var textarea = document.createElement("textarea"); + textarea.style.height = 0; + document.body.appendChild(textarea); + textarea.value = content; + textarea.select(); + document.execCommand("copy"); + document.body.removeChild(textarea); +} +function switchCopyLabel(button, span) { + var copied = span.getAttribute("data-copied"); + button.classList.add("visible"); + var initialLabel = span.innerHTML; + span.innerHTML = copied; + setTimeout(function() { + button.classList.remove("visible"); + setTimeout(function() { + if (initialLabel !== copied) { + span.innerHTML = initialLabel; + } + }, 100); + }, 1900); +} +// Workaround for scroll position not being included in browser history (8249133) +document.addEventListener("DOMContentLoaded", function(e) { + var contentDiv = document.querySelector("div.flex-content"); + window.addEventListener("popstate", function(e) { + if (e.state !== null) { + contentDiv.scrollTop = e.state; + } + }); + window.addEventListener("hashchange", function(e) { + history.replaceState(contentDiv.scrollTop, document.title); + }); + var timeoutId; + contentDiv.addEventListener("scroll", function(e) { + if (timeoutId) { + clearTimeout(timeoutId); + } + timeoutId = setTimeout(function() { + history.replaceState(contentDiv.scrollTop, document.title); + }, 100); + }); + if (!location.hash) { + history.replaceState(contentDiv.scrollTop, document.title); + } +}); diff --git a/docs/javadoc/3.0/search-page.js b/docs/javadoc/3.0/search-page.js new file mode 100644 index 000000000..540c90f57 --- /dev/null +++ b/docs/javadoc/3.0/search-page.js @@ -0,0 +1,284 @@ +/* + * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +"use strict"; +$(function() { + var copy = $("#page-search-copy"); + var expand = $("#page-search-expand"); + var searchLink = $("span#page-search-link"); + var redirect = $("input#search-redirect"); + function setSearchUrlTemplate() { + var href = document.location.href.split(/[#?]/)[0]; + href += "?q=" + "%s"; + if (redirect.is(":checked")) { + href += "&r=1"; + } + searchLink.html(href); + copy[0].onmouseenter(); + } + function copyLink(e) { + copyToClipboard(this.previousSibling.innerText); + switchCopyLabel(this, this.lastElementChild); + } + copy.click(copyLink); + copy[0].onmouseenter = function() {}; + redirect.click(setSearchUrlTemplate); + setSearchUrlTemplate(); + copy.prop("disabled", false); + redirect.prop("disabled", false); + expand.click(function (e) { + var searchInfo = $("div.page-search-info"); + if(this.parentElement.hasAttribute("open")) { + searchInfo.attr("style", "border-width: 0;"); + } else { + searchInfo.attr("style", "border-width: 1px;").height(searchInfo.prop("scrollHeight")); + } + }); +}); +$(window).on("load", function() { + var input = $("#page-search-input"); + var reset = $("#page-search-reset"); + var notify = $("#page-search-notify"); + var resultSection = $("div#result-section"); + var resultContainer = $("div#result-container"); + var searchTerm = ""; + var activeTab = ""; + var fixedTab = false; + var visibleTabs = []; + var feelingLucky = false; + function renderResults(result) { + if (!result.length) { + notify.html(messages.noResult); + } else if (result.length === 1) { + notify.html(messages.oneResult); + } else { + notify.html(messages.manyResults.replace("{0}", result.length)); + } + resultContainer.empty(); + var r = { + "types": [], + "members": [], + "packages": [], + "modules": [], + "searchTags": [] + }; + for (var i in result) { + var item = result[i]; + var arr = r[item.category]; + arr.push(item); + } + if (!activeTab || r[activeTab].length === 0 || !fixedTab) { + Object.keys(r).reduce(function(prev, curr) { + if (r[curr].length > 0 && r[curr][0].score > prev) { + activeTab = curr; + return r[curr][0].score; + } + return prev; + }, 0); + } + if (feelingLucky && activeTab) { + notify.html(messages.redirecting) + var firstItem = r[activeTab][0]; + window.location = getURL(firstItem.indexItem, firstItem.category); + return; + } + if (result.length > 20) { + if (searchTerm[searchTerm.length - 1] === ".") { + if (activeTab === "types" && r["members"].length > r["types"].length) { + activeTab = "members"; + } else if (activeTab === "packages" && r["types"].length > r["packages"].length) { + activeTab = "types"; + } + } + } + var categoryCount = Object.keys(r).reduce(function(prev, curr) { + return prev + (r[curr].length > 0 ? 1 : 0); + }, 0); + visibleTabs = []; + var tabContainer = $("
    ").appendTo(resultContainer); + for (var key in r) { + var id = "#result-tab-" + key.replace("searchTags", "search_tags"); + if (r[key].length) { + var count = r[key].length >= 1000 ? "999+" : r[key].length; + if (result.length > 20 && categoryCount > 1) { + var button = $("").appendTo(tabContainer); + button.click(key, function(e) { + fixedTab = true; + renderResult(e.data, $(this)); + }); + visibleTabs.push(key); + } else { + $("" + categories[key] + + " (" + count + ")").appendTo(tabContainer); + renderTable(key, r[key]).appendTo(resultContainer); + tabContainer = $("
    ").appendTo(resultContainer); + + } + } + } + if (activeTab && result.length > 20 && categoryCount > 1) { + $("button#result-tab-" + activeTab).addClass("active-table-tab"); + renderTable(activeTab, r[activeTab]).appendTo(resultContainer); + } + resultSection.show(); + function renderResult(category, button) { + activeTab = category; + setSearchUrl(); + resultContainer.find("div.summary-table").remove(); + renderTable(activeTab, r[activeTab]).appendTo(resultContainer); + button.siblings().removeClass("active-table-tab"); + button.addClass("active-table-tab"); + } + } + function selectTab(category) { + $("button#result-tab-" + category).click(); + } + function renderTable(category, items) { + var table = $("
    ") + .addClass(category === "modules" + ? "one-column-search-results" + : "two-column-search-results"); + var col1, col2; + if (category === "modules") { + col1 = "Module"; + } else if (category === "packages") { + col1 = "Module"; + col2 = "Package"; + } else if (category === "types") { + col1 = "Package"; + col2 = "Class" + } else if (category === "members") { + col1 = "Class"; + col2 = "Member"; + } else if (category === "searchTags") { + col1 = "Location"; + col2 = "Name"; + } + $("
    " + col1 + "
    ").appendTo(table); + if (category !== "modules") { + $("
    " + col2 + "
    ").appendTo(table); + } + $.each(items, function(index, item) { + var rowColor = index % 2 ? "odd-row-color" : "even-row-color"; + renderItem(item, table, rowColor); + }); + return table; + } + function renderItem(item, table, rowColor) { + var label = getHighlightedText(item.input, item.boundaries, item.prefix.length, item.input.length); + var link = $("") + .attr("href", getURL(item.indexItem, item.category)) + .attr("tabindex", "0") + .addClass("search-result-link") + .html(label); + var container = getHighlightedText(item.input, item.boundaries, 0, item.prefix.length - 1); + if (item.category === "searchTags") { + container = item.indexItem.h || ""; + } + if (item.category !== "modules") { + $("
    ").html(container).addClass("col-plain").addClass(rowColor).appendTo(table); + } + $("
    ").html(link).addClass("col-last").addClass(rowColor).appendTo(table); + } + var timeout; + function schedulePageSearch() { + if (timeout) { + clearTimeout(timeout); + } + timeout = setTimeout(function () { + doPageSearch() + }, 100); + } + function doPageSearch() { + setSearchUrl(); + var term = searchTerm = input.val().trim(); + if (term === "") { + notify.html(messages.enterTerm); + activeTab = ""; + fixedTab = false; + resultContainer.empty(); + resultSection.hide(); + } else { + notify.html(messages.searching); + doSearch({ term: term, maxResults: 1200 }, renderResults); + } + } + function setSearchUrl() { + var query = input.val().trim(); + var url = document.location.pathname; + if (query) { + url += "?q=" + encodeURI(query); + if (activeTab && fixedTab) { + url += "&c=" + activeTab; + } + } + history.replaceState({query: query}, "", url); + } + input.on("input", function(e) { + feelingLucky = false; + schedulePageSearch(); + }); + $(document).keydown(function(e) { + if ((e.ctrlKey || e.metaKey) && (e.key === "ArrowLeft" || e.key === "ArrowRight")) { + if (activeTab && visibleTabs.length > 1) { + var idx = visibleTabs.indexOf(activeTab); + idx += e.key === "ArrowLeft" ? visibleTabs.length - 1 : 1; + selectTab(visibleTabs[idx % visibleTabs.length]); + return false; + } + } + }); + reset.click(function() { + notify.html(messages.enterTerm); + resultSection.hide(); + activeTab = ""; + fixedTab = false; + resultContainer.empty(); + input.val('').focus(); + setSearchUrl(); + }); + input.prop("disabled", false); + reset.prop("disabled", false); + + var urlParams = new URLSearchParams(window.location.search); + if (urlParams.has("q")) { + input.val(urlParams.get("q")) + } + if (urlParams.has("c")) { + activeTab = urlParams.get("c"); + fixedTab = true; + } + if (urlParams.get("r")) { + feelingLucky = true; + } + if (input.val()) { + doPageSearch(); + } else { + notify.html(messages.enterTerm); + } + input.select().focus(); +}); diff --git a/docs/javadoc/3.0/search.html b/docs/javadoc/3.0/search.html new file mode 100644 index 000000000..8d8b84126 --- /dev/null +++ b/docs/javadoc/3.0/search.html @@ -0,0 +1,72 @@ + + + + +Search (Hamcrest 3.0 API) + + + + + + + + + + + + + +
    + +
    +
    +

    Search

    +
    + + +
    +Additional resources +
    +
    +
    +

    The help page provides an introduction to the scope and syntax of JavaDoc search.

    +

    You can use the <ctrl> or <cmd> keys in combination with the left and right arrow keys to switch between result tabs in this page.

    +

    The URL template below may be used to configure this page as a search engine in browsers that support this feature. It has been tested to work in Google Chrome and Mozilla Firefox. Note that other browsers may not support this feature or require a different URL format.

    +link +

    + +

    +
    +

    Loading search index...

    + +
    +
    +
    + + diff --git a/docs/javadoc/3.0/search.js b/docs/javadoc/3.0/search.js new file mode 100644 index 000000000..d3986705e --- /dev/null +++ b/docs/javadoc/3.0/search.js @@ -0,0 +1,458 @@ +/* + * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +"use strict"; +const messages = { + enterTerm: "Enter a search term", + noResult: "No results found", + oneResult: "Found one result", + manyResults: "Found {0} results", + loading: "Loading search index...", + searching: "Searching...", + redirecting: "Redirecting to first result...", + linkIcon: "Link icon", + linkToSection: "Link to this section" +} +const categories = { + modules: "Modules", + packages: "Packages", + types: "Classes and Interfaces", + members: "Members", + searchTags: "Search Tags" +}; +const highlight = "$&"; +const NO_MATCH = {}; +const MAX_RESULTS = 300; +function checkUnnamed(name, separator) { + return name === "" || !name ? "" : name + separator; +} +function escapeHtml(str) { + return str.replace(//g, ">"); +} +function getHighlightedText(str, boundaries, from, to) { + var start = from; + var text = ""; + for (var i = 0; i < boundaries.length; i += 2) { + var b0 = boundaries[i]; + var b1 = boundaries[i + 1]; + if (b0 >= to || b1 <= from) { + continue; + } + text += escapeHtml(str.slice(start, Math.max(start, b0))); + text += ""; + text += escapeHtml(str.slice(Math.max(start, b0), Math.min(to, b1))); + text += ""; + start = Math.min(to, b1); + } + text += escapeHtml(str.slice(start, to)); + return text; +} +function getURLPrefix(item, category) { + var urlPrefix = ""; + var slash = "/"; + if (category === "modules") { + return item.l + slash; + } else if (category === "packages" && item.m) { + return item.m + slash; + } else if (category === "types" || category === "members") { + if (item.m) { + urlPrefix = item.m + slash; + } else { + $.each(packageSearchIndex, function(index, it) { + if (it.m && item.p === it.l) { + urlPrefix = it.m + slash; + } + }); + } + } + return urlPrefix; +} +function getURL(item, category) { + if (item.url) { + return item.url; + } + var url = getURLPrefix(item, category); + if (category === "modules") { + url += "module-summary.html"; + } else if (category === "packages") { + if (item.u) { + url = item.u; + } else { + url += item.l.replace(/\./g, '/') + "/package-summary.html"; + } + } else if (category === "types") { + if (item.u) { + url = item.u; + } else { + url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.l + ".html"; + } + } else if (category === "members") { + url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.c + ".html" + "#"; + if (item.u) { + url += item.u; + } else { + url += item.l; + } + } else if (category === "searchTags") { + url += item.u; + } + item.url = url; + return url; +} +function createMatcher(term, camelCase) { + if (camelCase && !isUpperCase(term)) { + return null; // no need for camel-case matcher for lower case query + } + var pattern = ""; + var upperCase = []; + term.trim().split(/\s+/).forEach(function(w, index, array) { + var tokens = w.split(/(?=[A-Z,.()<>?[\/])/); + for (var i = 0; i < tokens.length; i++) { + var s = tokens[i]; + // ',' and '?' are the only delimiters commonly followed by space in java signatures + pattern += "(" + $.ui.autocomplete.escapeRegex(s).replace(/[,?]/g, "$&\\s*?") + ")"; + upperCase.push(false); + var isWordToken = /\w$/.test(s); + if (isWordToken) { + if (i === tokens.length - 1 && index < array.length - 1) { + // space in query string matches all delimiters + pattern += "(.*?)"; + upperCase.push(isUpperCase(s[0])); + } else { + if (!camelCase && isUpperCase(s) && s.length === 1) { + pattern += "()"; + } else { + pattern += "([a-z0-9$<>?[\\]]*?)"; + } + upperCase.push(isUpperCase(s[0])); + } + } else { + pattern += "()"; + upperCase.push(false); + } + } + }); + var re = new RegExp(pattern, "gi"); + re.upperCase = upperCase; + return re; +} +function findMatch(matcher, input, startOfName, endOfName) { + var from = startOfName; + matcher.lastIndex = from; + var match = matcher.exec(input); + // Expand search area until we get a valid result or reach the beginning of the string + while (!match || match.index + match[0].length < startOfName || endOfName < match.index) { + if (from === 0) { + return NO_MATCH; + } + from = input.lastIndexOf(".", from - 2) + 1; + matcher.lastIndex = from; + match = matcher.exec(input); + } + var boundaries = []; + var matchEnd = match.index + match[0].length; + var score = 5; + var start = match.index; + var prevEnd = -1; + for (var i = 1; i < match.length; i += 2) { + var isUpper = isUpperCase(input[start]); + var isMatcherUpper = matcher.upperCase[i]; + // capturing groups come in pairs, match and non-match + boundaries.push(start, start + match[i].length); + // make sure groups are anchored on a left word boundary + var prevChar = input[start - 1] || ""; + var nextChar = input[start + 1] || ""; + if (start !== 0 && !/[\W_]/.test(prevChar) && !/[\W_]/.test(input[start])) { + if (isUpper && (isLowerCase(prevChar) || isLowerCase(nextChar))) { + score -= 0.1; + } else if (isMatcherUpper && start === prevEnd) { + score -= isUpper ? 0.1 : 1.0; + } else { + return NO_MATCH; + } + } + prevEnd = start + match[i].length; + start += match[i].length + match[i + 1].length; + + // lower score for parts of the name that are missing + if (match[i + 1] && prevEnd < endOfName) { + score -= rateNoise(match[i + 1]); + } + } + // lower score if a type name contains unmatched camel-case parts + if (input[matchEnd - 1] !== "." && endOfName > matchEnd) + score -= rateNoise(input.slice(matchEnd, endOfName)); + score -= rateNoise(input.slice(0, Math.max(startOfName, match.index))); + + if (score <= 0) { + return NO_MATCH; + } + return { + input: input, + score: score, + boundaries: boundaries + }; +} +function isUpperCase(s) { + return s !== s.toLowerCase(); +} +function isLowerCase(s) { + return s !== s.toUpperCase(); +} +function rateNoise(str) { + return (str.match(/([.(])/g) || []).length / 5 + + (str.match(/([A-Z]+)/g) || []).length / 10 + + str.length / 20; +} +function doSearch(request, response) { + var term = request.term.trim(); + var maxResults = request.maxResults || MAX_RESULTS; + if (term.length === 0) { + return this.close(); + } + var matcher = { + plainMatcher: createMatcher(term, false), + camelCaseMatcher: createMatcher(term, true) + } + var indexLoaded = indexFilesLoaded(); + + function getPrefix(item, category) { + switch (category) { + case "packages": + return checkUnnamed(item.m, "/"); + case "types": + return checkUnnamed(item.p, "."); + case "members": + return checkUnnamed(item.p, ".") + item.c + "."; + default: + return ""; + } + } + function useQualifiedName(category) { + switch (category) { + case "packages": + return /[\s/]/.test(term); + case "types": + case "members": + return /[\s.]/.test(term); + default: + return false; + } + } + function searchIndex(indexArray, category) { + var matches = []; + if (!indexArray) { + if (!indexLoaded) { + matches.push({ l: messages.loading, category: category }); + } + return matches; + } + $.each(indexArray, function (i, item) { + var prefix = getPrefix(item, category); + var simpleName = item.l; + var qualifiedName = prefix + simpleName; + var useQualified = useQualifiedName(category); + var input = useQualified ? qualifiedName : simpleName; + var startOfName = useQualified ? prefix.length : 0; + var endOfName = category === "members" && input.indexOf("(", startOfName) > -1 + ? input.indexOf("(", startOfName) : input.length; + var m = findMatch(matcher.plainMatcher, input, startOfName, endOfName); + if (m === NO_MATCH && matcher.camelCaseMatcher) { + m = findMatch(matcher.camelCaseMatcher, input, startOfName, endOfName); + } + if (m !== NO_MATCH) { + m.indexItem = item; + m.prefix = prefix; + m.category = category; + if (!useQualified) { + m.input = qualifiedName; + m.boundaries = m.boundaries.map(function(b) { + return b + prefix.length; + }); + } + matches.push(m); + } + return true; + }); + return matches.sort(function(e1, e2) { + return e2.score - e1.score; + }).slice(0, maxResults); + } + + var result = searchIndex(moduleSearchIndex, "modules") + .concat(searchIndex(packageSearchIndex, "packages")) + .concat(searchIndex(typeSearchIndex, "types")) + .concat(searchIndex(memberSearchIndex, "members")) + .concat(searchIndex(tagSearchIndex, "searchTags")); + + if (!indexLoaded) { + updateSearchResults = function() { + doSearch(request, response); + } + } else { + updateSearchResults = function() {}; + } + response(result); +} +// JQuery search menu implementation +$.widget("custom.catcomplete", $.ui.autocomplete, { + _create: function() { + this._super(); + this.widget().menu("option", "items", "> .result-item"); + // workaround for search result scrolling + this.menu._scrollIntoView = function _scrollIntoView( item ) { + var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight; + if ( this._hasScroll() ) { + borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0; + paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0; + offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop; + scroll = this.activeMenu.scrollTop(); + elementHeight = this.activeMenu.height() - 26; + itemHeight = item.outerHeight(); + + if ( offset < 0 ) { + this.activeMenu.scrollTop( scroll + offset ); + } else if ( offset + itemHeight > elementHeight ) { + this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight ); + } + } + }; + }, + _renderMenu: function(ul, items) { + var currentCategory = ""; + var widget = this; + widget.menu.bindings = $(); + $.each(items, function(index, item) { + if (item.category && item.category !== currentCategory) { + ul.append("
  • " + categories[item.category] + "
  • "); + currentCategory = item.category; + } + var li = widget._renderItemData(ul, item); + if (item.category) { + li.attr("aria-label", categories[item.category] + " : " + item.l); + } else { + li.attr("aria-label", item.l); + } + li.attr("class", "result-item"); + }); + ul.append(""); + }, + _renderItem: function(ul, item) { + var li = $("
  • ").appendTo(ul); + var div = $("
    ").appendTo(li); + var label = item.l + ? item.l + : getHighlightedText(item.input, item.boundaries, 0, item.input.length); + var idx = item.indexItem; + if (item.category === "searchTags" && idx && idx.h) { + if (idx.d) { + div.html(label + " (" + idx.h + ")
    " + + idx.d + "
    "); + } else { + div.html(label + " (" + idx.h + ")"); + } + } else { + div.html(label); + } + return li; + } +}); +$(function() { + var expanded = false; + var windowWidth; + function collapse() { + if (expanded) { + $("div#navbar-top").removeAttr("style"); + $("button#navbar-toggle-button") + .removeClass("expanded") + .attr("aria-expanded", "false"); + expanded = false; + } + } + $("button#navbar-toggle-button").click(function (e) { + if (expanded) { + collapse(); + } else { + var navbar = $("div#navbar-top"); + navbar.height(navbar.prop("scrollHeight")); + $("button#navbar-toggle-button") + .addClass("expanded") + .attr("aria-expanded", "true"); + expanded = true; + windowWidth = window.innerWidth; + } + }); + $("ul.sub-nav-list-small li a").click(collapse); + $("input#search-input").focus(collapse); + $("main").click(collapse); + $("section[id] > :header, :header[id], :header:has(a[id])").each(function(idx, el) { + // Create anchor links for headers with an associated id attribute + var hdr = $(el); + var id = hdr.attr("id") || hdr.parent("section").attr("id") || hdr.children("a").attr("id"); + if (id) { + hdr.append(" " + messages.linkIcon +""); + } + }); + $(window).on("orientationchange", collapse).on("resize", function(e) { + if (expanded && windowWidth !== window.innerWidth) collapse(); + }); + var search = $("#search-input"); + var reset = $("#reset-button"); + search.catcomplete({ + minLength: 1, + delay: 200, + source: doSearch, + response: function(event, ui) { + if (!ui.content.length) { + ui.content.push({ l: messages.noResult }); + } else { + $("#search-input").empty(); + } + }, + autoFocus: true, + focus: function(event, ui) { + return false; + }, + position: { + collision: "flip" + }, + select: function(event, ui) { + if (ui.item.indexItem) { + var url = getURL(ui.item.indexItem, ui.item.category); + window.location.href = pathtoroot + url; + $("#search-input").focus(); + } + } + }); + search.val(''); + search.prop("disabled", false); + reset.prop("disabled", false); + reset.click(function() { + search.val('').focus(); + }); + search.focus(); +}); diff --git a/docs/javadoc/3.0/stylesheet.css b/docs/javadoc/3.0/stylesheet.css new file mode 100644 index 000000000..f71489f86 --- /dev/null +++ b/docs/javadoc/3.0/stylesheet.css @@ -0,0 +1,1272 @@ +/* + * Javadoc style sheet + */ + +@import url('resources/fonts/dejavu.css'); + +/* + * These CSS custom properties (variables) define the core color and font + * properties used in this stylesheet. + */ +:root { + /* body, block and code fonts */ + --body-font-family: 'DejaVu Sans', Arial, Helvetica, sans-serif; + --block-font-family: 'DejaVu Serif', Georgia, "Times New Roman", Times, serif; + --code-font-family: 'DejaVu Sans Mono', monospace; + /* Base font sizes for body and code elements */ + --body-font-size: 14px; + --code-font-size: 14px; + /* Text colors for body and block elements */ + --body-text-color: #353833; + --block-text-color: #474747; + /* Background colors for various structural elements */ + --body-background-color: #ffffff; + --section-background-color: #f8f8f8; + --detail-background-color: #ffffff; + /* Colors for navigation bar and table captions */ + --navbar-background-color: #4D7A97; + --navbar-text-color: #ffffff; + /* Background color for subnavigation and various headers */ + --subnav-background-color: #dee3e9; + /* Background and text colors for selected tabs and navigation items */ + --selected-background-color: #f8981d; + --selected-text-color: #253441; + --selected-link-color: #1f389c; + /* Background colors for generated tables */ + --even-row-color: #ffffff; + --odd-row-color: #eeeeef; + /* Text color for page title */ + --title-color: #2c4557; + /* Text colors for links */ + --link-color: #4A6782; + --link-color-active: #bb7a2a; + /* Snippet colors */ + --snippet-background-color: #ebecee; + --snippet-text-color: var(--block-text-color); + --snippet-highlight-color: #f7c590; + /* Border colors for structural elements and user defined tables */ + --border-color: #ededed; + --table-border-color: #000000; + /* Search input colors */ + --search-input-background-color: #ffffff; + --search-input-text-color: #000000; + --search-input-placeholder-color: #909090; + /* Highlight color for active search tag target */ + --search-tag-highlight-color: #ffff00; + /* Adjustments for icon and active background colors of copy-to-clipboard buttons */ + --copy-icon-brightness: 100%; + --copy-button-background-color-active: rgba(168, 168, 176, 0.3); + /* Colors for invalid tag notifications */ + --invalid-tag-background-color: #ffe6e6; + --invalid-tag-text-color: #000000; +} +/* + * Styles for individual HTML elements. + * + * These are styles that are specific to individual HTML elements. Changing them affects the style of a particular + * HTML element throughout the page. + */ +body { + background-color:var(--body-background-color); + color:var(--body-text-color); + font-family:var(--body-font-family); + font-size:var(--body-font-size); + margin:0; + padding:0; + height:100%; + width:100%; +} +iframe { + margin:0; + padding:0; + height:100%; + width:100%; + overflow-y:scroll; + border:none; +} +a:link, a:visited { + text-decoration:none; + color:var(--link-color); +} +a[href]:hover, a[href]:focus { + text-decoration:none; + color:var(--link-color-active); +} +pre { + font-family:var(--code-font-family); + font-size:1em; +} +h1 { + font-size:1.428em; +} +h2 { + font-size:1.285em; +} +h3 { + font-size:1.14em; +} +h4 { + font-size:1.072em; +} +h5 { + font-size:1.001em; +} +h6 { + font-size:0.93em; +} +/* Disable font boosting for selected elements */ +h1, h2, h3, h4, h5, h6, div.member-signature { + max-height: 1000em; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:var(--code-font-family); +} +:not(h1, h2, h3, h4, h5, h6) > code, +:not(h1, h2, h3, h4, h5, h6) > tt { + font-size:var(--code-font-size); + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:var(--code-font-family); + font-size:1em; + padding-top:4px; +} +.summary-table dt code { + font-family:var(--code-font-family); + font-size:1em; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} +button { + font-family: var(--body-font-family); + font-size: 1em; +} +/* + * Styles for HTML generated by javadoc. + * + * These are style classes that are used by the standard doclet to generate HTML documentation. + */ + +/* + * Styles for document title and copyright. + */ +.about-language { + float:right; + padding:0 21px 8px 8px; + font-size:0.915em; + margin-top:-9px; + height:2.9em; +} +.legal-copy { + margin-left:.5em; +} +/* + * Styles for navigation bar. + */ +@media screen { + div.flex-box { + position:fixed; + display:flex; + flex-direction:column; + height: 100%; + width: 100%; + } + header.flex-header { + flex: 0 0 auto; + } + div.flex-content { + flex: 1 1 auto; + overflow-y: auto; + } +} +.top-nav { + background-color:var(--navbar-background-color); + color:var(--navbar-text-color); + float:left; + width:100%; + clear:right; + min-height:2.8em; + padding:10px 0 0 0; + overflow:hidden; + font-size:0.857em; +} +button#navbar-toggle-button { + display:none; +} +ul.sub-nav-list-small { + display: none; +} +.sub-nav { + background-color:var(--subnav-background-color); + float:left; + width:100%; + overflow:hidden; + font-size:0.857em; +} +.sub-nav div { + clear:left; + float:left; + padding:6px; + text-transform:uppercase; +} +.sub-nav .sub-nav-list { + padding-top:4px; +} +ul.nav-list { + display:block; + margin:0 25px 0 0; + padding:0; +} +ul.sub-nav-list { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.nav-list li { + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +.sub-nav .nav-list-search { + float:right; + margin:0; + padding:6px; + clear:none; + text-align:right; + position:relative; +} +ul.sub-nav-list li { + list-style:none; + float:left; +} +.top-nav a:link, .top-nav a:active, .top-nav a:visited { + color:var(--navbar-text-color); + text-decoration:none; + text-transform:uppercase; +} +.top-nav a:hover { + color:var(--link-color-active); +} +.nav-bar-cell1-rev { + background-color:var(--selected-background-color); + color:var(--selected-text-color); + margin: auto 5px; +} +.skip-nav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* + * Hide navigation links and search box in print layout + */ +@media print { + ul.nav-list, div.sub-nav { + display:none; + } +} +/* + * Styles for page header. + */ +.title { + color:var(--title-color); + margin:10px 0; +} +.sub-title { + margin:5px 0 0 0; +} +ul.contents-list { + margin: 0 0 15px 0; + padding: 0; + list-style: none; +} +ul.contents-list li { + font-size:0.93em; +} +/* + * Styles for headings. + */ +body.class-declaration-page .summary h2, +body.class-declaration-page .details h2, +body.class-use-page h2, +body.module-declaration-page .block-list h2 { + font-style: italic; + padding:0; + margin:15px 0; +} +body.class-declaration-page .summary h3, +body.class-declaration-page .details h3, +body.class-declaration-page .summary .inherited-list h2 { + background-color:var(--subnav-background-color); + border:1px solid var(--border-color); + margin:0 0 6px -8px; + padding:7px 5px; +} +/* + * Styles for page layout containers. + */ +main { + clear:both; + padding:10px 20px; + position:relative; +} +dl.notes > dt { + font-family: var(--body-font-family); + font-size:0.856em; + font-weight:bold; + margin:10px 0 0 0; + color:var(--body-text-color); +} +dl.notes > dd { + margin:5px 10px 10px 0; + font-size:1em; + font-family:var(--block-font-family) +} +dl.name-value > dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +dl.name-value > dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* + * Styles for lists. + */ +li.circle { + list-style:circle; +} +ul.horizontal li { + display:inline; + font-size:0.9em; +} +div.inheritance { + margin:0; + padding:0; +} +div.inheritance div.inheritance { + margin-left:2em; +} +ul.block-list, +ul.details-list, +ul.member-list, +ul.summary-list { + margin:10px 0 10px 0; + padding:0; +} +ul.block-list > li, +ul.details-list > li, +ul.member-list > li, +ul.summary-list > li { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.ref-list { + padding:0; + margin:0; +} +ul.ref-list > li { + list-style:none; +} +.summary-table dl, .summary-table dl dt, .summary-table dl dd { + margin-top:0; + margin-bottom:1px; +} +ul.tag-list, ul.tag-list-long { + padding-left: 0; + list-style: none; +} +ul.tag-list li { + display: inline; +} +ul.tag-list li:not(:last-child):after, +ul.tag-list-long li:not(:last-child):after +{ + content: ", "; + white-space: pre-wrap; +} +ul.preview-feature-list { + list-style: none; + margin:0; + padding:0.1em; + line-height: 1.6em; +} +/* + * Styles for tables. + */ +.summary-table, .details-table { + width:100%; + border-spacing:0; + border:1px solid var(--border-color); + border-top:0; + padding:0; +} +.caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:var(--selected-text-color); + clear:none; + overflow:hidden; + padding: 10px 0 0 1px; + margin:0; +} +.caption a:link, .caption a:visited { + color:var(--selected-link-color); +} +.caption a:hover, +.caption a:active { + color:var(--navbar-text-color); +} +.caption span { + font-weight:bold; + white-space:nowrap; + padding:5px 12px 7px 12px; + display:inline-block; + float:left; + background-color:var(--selected-background-color); + border: none; + height:16px; +} +div.table-tabs { + padding:10px 0 0 1px; + margin:10px 0 0 0; +} +div.table-tabs > button { + border: none; + cursor: pointer; + padding: 5px 12px 7px 12px; + font-weight: bold; + margin-right: 8px; +} +div.table-tabs > .active-table-tab { + background: var(--selected-background-color); + color: var(--selected-text-color); +} +div.table-tabs > button.table-tab { + background: var(--navbar-background-color); + color: var(--navbar-text-color); +} +.two-column-search-results { + display: grid; + grid-template-columns: minmax(400px, max-content) minmax(400px, auto); +} +div.checkboxes { + line-height: 2em; +} +div.checkboxes > span { + margin-left: 10px; +} +div.checkboxes > label { + margin-left: 8px; + white-space: nowrap; +} +div.checkboxes > label > input { + margin: 0 2px; +} +.two-column-summary { + display: grid; + grid-template-columns: minmax(25%, max-content) minmax(25%, auto); +} +.three-column-summary { + display: grid; + grid-template-columns: minmax(15%, max-content) minmax(20%, max-content) minmax(20%, auto); +} +.three-column-release-summary { + display: grid; + grid-template-columns: minmax(40%, max-content) minmax(10%, max-content) minmax(40%, auto); +} +.four-column-summary { + display: grid; + grid-template-columns: minmax(10%, max-content) minmax(15%, max-content) minmax(15%, max-content) minmax(15%, auto); +} +@media screen and (max-width: 1000px) { + .four-column-summary { + display: grid; + grid-template-columns: minmax(15%, max-content) minmax(15%, auto); + } +} +@media screen and (max-width: 800px) { + .two-column-search-results { + display: grid; + grid-template-columns: minmax(40%, max-content) minmax(40%, auto); + } + .three-column-summary { + display: grid; + grid-template-columns: minmax(10%, max-content) minmax(25%, auto); + } + .three-column-release-summary { + display: grid; + grid-template-columns: minmax(70%, max-content) minmax(30%, max-content) + } + .three-column-summary .col-last, + .three-column-release-summary .col-last{ + grid-column-end: span 2; + } +} +@media screen and (max-width: 600px) { + .two-column-summary { + display: grid; + grid-template-columns: 1fr; + } +} +.summary-table > div, .details-table > div { + text-align:left; + padding: 8px 3px 3px 7px; + overflow-x: auto; + scrollbar-width: thin; +} +.col-first, .col-second, .col-last, .col-constructor-name, .col-summary-item-name { + vertical-align:top; + padding-right:0; + padding-top:8px; + padding-bottom:3px; +} +.table-header { + background:var(--subnav-background-color); + font-weight: bold; +} +/* Sortable table columns */ +.table-header[onclick] { + cursor: pointer; +} +.table-header[onclick]::after { + content:""; + display:inline-block; + background-image:url('data:image/svg+xml; utf8, \ + \ + '); + background-size:100% 100%; + width:9px; + height:14px; + margin-left:4px; + margin-bottom:-3px; +} +.table-header[onclick].sort-asc::after { + background-image:url('data:image/svg+xml; utf8, \ + \ + \ + '); + +} +.table-header[onclick].sort-desc::after { + background-image:url('data:image/svg+xml; utf8, \ + \ + \ + '); +} +.col-first, .col-first { + font-size:0.93em; +} +.col-second, .col-second, .col-last, .col-constructor-name, .col-summary-item-name, .col-last { + font-size:0.93em; +} +.col-first, .col-second, .col-constructor-name { + vertical-align:top; + overflow: auto; +} +.col-last { + white-space:normal; +} +.col-first a:link, .col-first a:visited, +.col-second a:link, .col-second a:visited, +.col-first a:link, .col-first a:visited, +.col-second a:link, .col-second a:visited, +.col-constructor-name a:link, .col-constructor-name a:visited, +.col-summary-item-name a:link, .col-summary-item-name a:visited { + font-weight:bold; +} +.even-row-color, .even-row-color .table-header { + background-color:var(--even-row-color); +} +.odd-row-color, .odd-row-color .table-header { + background-color:var(--odd-row-color); +} +/* + * Styles for contents. + */ +div.block { + font-size:var(--body-font-size); + font-family:var(--block-font-family); +} +.col-last div { + padding-top:0; +} +.col-last a { + padding-bottom:3px; +} +.module-signature, +.package-signature, +.type-signature, +.member-signature { + font-family:var(--code-font-family); + font-size:1em; + margin:14px 0; + white-space: pre-wrap; +} +.module-signature, +.package-signature, +.type-signature { + margin-top: 0; +} +.member-signature .type-parameters-long, +.member-signature .parameters, +.member-signature .exceptions { + display: inline-block; + vertical-align: top; + white-space: pre; +} +.member-signature .type-parameters { + white-space: normal; +} +/* + * Styles for formatting effect. + */ +.source-line-no { + /* Color of line numbers in source pages can be set via custom property below */ + color:var(--source-linenumber-color, green); + padding:0 30px 0 0; +} +.block { + display:block; + margin:0 10px 5px 0; + color:var(--block-text-color); +} +.deprecated-label, .description-from-type-label, .implementation-label, .member-name-link, +.module-label-in-package, .module-label-in-type, .package-label-in-type, +.package-hierarchy-label, .type-name-label, .type-name-link, .search-tag-link, .preview-label { + font-weight:bold; +} +.deprecation-comment, .help-footnote, .preview-comment { + font-style:italic; +} +.deprecation-block { + font-size:1em; + font-family:var(--block-font-family); + border-style:solid; + border-width:thin; + border-radius:10px; + padding:10px; + margin-bottom:10px; + margin-right:10px; + display:inline-block; +} +.preview-block { + font-size:1em; + font-family:var(--block-font-family); + border-style:solid; + border-width:thin; + border-radius:10px; + padding:10px; + margin-bottom:10px; + margin-right:10px; + display:inline-block; +} +div.block div.deprecation-comment { + font-style:normal; +} +details.invalid-tag, span.invalid-tag { + font-size:1em; + font-family:var(--block-font-family); + color: var(--invalid-tag-text-color); + background: var(--invalid-tag-background-color); + border: thin solid var(--table-border-color); + border-radius:2px; + padding: 2px 4px; + display:inline-block; +} +details summary { + cursor: pointer; +} +/* + * Styles specific to HTML5 elements. + */ +main, nav, header, footer, section { + display:block; +} +/* + * Styles for javadoc search. + */ +.ui-state-active { + /* Overrides the color of selection used in jQuery UI */ + background: var(--selected-background-color); + border: 1px solid var(--selected-background-color); + color: var(--selected-text-color); +} +.ui-autocomplete-category { + font-weight:bold; + font-size:15px; + padding:7px 0 7px 3px; + background-color:var(--navbar-background-color); + color:var(--navbar-text-color); +} +.ui-autocomplete { + max-height:85%; + max-width:65%; + overflow-y:auto; + overflow-x:auto; + scrollbar-width: thin; + white-space:nowrap; + box-shadow: 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23); +} +ul.ui-autocomplete { + position:fixed; + z-index:1; + background-color: var(--body-background-color); +} +ul.ui-autocomplete li { + float:left; + clear:both; + min-width:100%; +} +ul.ui-autocomplete li.ui-static-link { + position:sticky; + bottom:0; + left:0; + background: var(--subnav-background-color); + padding: 5px 0; + font-family: var(--body-font-family); + font-size: 0.93em; + font-weight: bolder; + z-index: 2; +} +li.ui-static-link a, li.ui-static-link a:visited { + text-decoration:none; + color:var(--link-color); + float:right; + margin-right:20px; +} +.ui-autocomplete .result-item { + font-size: inherit; +} +.ui-autocomplete .result-highlight { + font-weight:bold; +} +#search-input, #page-search-input { + background-image:url('resources/glass.png'); + background-size:13px; + background-repeat:no-repeat; + background-position:2px 3px; + background-color: var(--search-input-background-color); + color: var(--search-input-text-color); + border-color: var(--border-color); + padding-left:20px; + width: 250px; + margin: 0; +} +#search-input { + margin-left: 4px; +} +#reset-button { + background-color: transparent; + background-image:url('resources/x.png'); + background-repeat:no-repeat; + background-size:contain; + border:0; + border-radius:0; + width:12px; + height:12px; + position:absolute; + right:12px; + top:10px; + font-size:0; +} +::placeholder { + color:var(--search-input-placeholder-color); + opacity: 1; +} +.search-tag-desc-result { + font-style:italic; + font-size:11px; +} +.search-tag-holder-result { + font-style:italic; + font-size:12px; +} +.search-tag-result:target { + background-color:var(--search-tag-highlight-color); +} +details.page-search-details { + display: inline-block; +} +div#result-container { + font-size: 1em; +} +div#result-container a.search-result-link { + padding: 0; + margin: 4px 0; + width: 100%; +} +#result-container .result-highlight { + font-weight:bolder; +} +.page-search-info { + background-color: var(--subnav-background-color); + border-radius: 3px; + border: 0 solid var(--border-color); + padding: 0 8px; + overflow: hidden; + height: 0; + transition: all 0.2s ease; +} +div.table-tabs > button.table-tab { + background: var(--navbar-background-color); + color: var(--navbar-text-color); +} +.page-search-header { + padding: 5px 12px 7px 12px; + font-weight: bold; + margin-right: 3px; + background-color:var(--navbar-background-color); + color:var(--navbar-text-color); + display: inline-block; +} +button.page-search-header { + border: none; + cursor: pointer; +} +span#page-search-link { + text-decoration: underline; +} +.module-graph span, .sealed-graph span { + display:none; + position:absolute; +} +.module-graph:hover span, .sealed-graph:hover span { + display:block; + margin: -100px 0 0 100px; + z-index: 1; +} +.inherited-list { + margin: 10px 0 10px 0; +} +section.class-description { + line-height: 1.4; +} +.summary section[class$="-summary"], .details section[class$="-details"], +.class-uses .detail, .serialized-class-details { + padding: 0 20px 5px 10px; + border: 1px solid var(--border-color); + background-color: var(--section-background-color); +} +.inherited-list, section[class$="-details"] .detail { + padding:0 0 5px 8px; + background-color:var(--detail-background-color); + border:none; +} +.vertical-separator { + padding: 0 5px; +} +ul.help-section-list { + margin: 0; +} +ul.help-subtoc > li { + display: inline-block; + padding-right: 5px; + font-size: smaller; +} +ul.help-subtoc > li::before { + content: "\2022" ; + padding-right:2px; +} +.help-note { + font-style: italic; +} +/* + * Indicator icon for external links. + */ +main a[href*="://"]::after { + content:""; + display:inline-block; + background-image:url('data:image/svg+xml; utf8, \ + \ + \ + '); + background-size:100% 100%; + width:7px; + height:7px; + margin-left:2px; + margin-bottom:4px; +} +main a[href*="://"]:hover::after, +main a[href*="://"]:focus::after { + background-image:url('data:image/svg+xml; utf8, \ + \ + \ + '); +} +/* + * Styles for header/section anchor links + */ +a.anchor-link { + opacity: 0; + transition: opacity 0.1s; +} +:hover > a.anchor-link { + opacity: 80%; +} +a.anchor-link:hover, +a.anchor-link:focus-visible, +a.anchor-link.visible { + opacity: 100%; +} +a.anchor-link > img { + width: 0.9em; + height: 0.9em; +} +/* + * Styles for copy-to-clipboard buttons + */ +button.copy { + opacity: 70%; + border: none; + border-radius: 3px; + position: relative; + background:none; + transition: opacity 0.3s; + cursor: pointer; +} +:hover > button.copy { + opacity: 80%; +} +button.copy:hover, +button.copy:active, +button.copy:focus-visible, +button.copy.visible { + opacity: 100%; +} +button.copy img { + position: relative; + background: none; + filter: brightness(var(--copy-icon-brightness)); +} +button.copy:active { + background-color: var(--copy-button-background-color-active); +} +button.copy span { + color: var(--body-text-color); + position: relative; + top: -0.1em; + transition: all 0.1s; + font-size: 0.76rem; + line-height: 1.2em; + opacity: 0; +} +button.copy:hover span, +button.copy:focus-visible span, +button.copy.visible span { + opacity: 100%; +} +/* search page copy button */ +button#page-search-copy { + margin-left: 0.4em; + padding:0.3em; + top:0.13em; +} +button#page-search-copy img { + width: 1.2em; + height: 1.2em; + padding: 0.01em 0; + top: 0.15em; +} +button#page-search-copy span { + color: var(--body-text-color); + line-height: 1.2em; + padding: 0.2em; + top: -0.18em; +} +div.page-search-info:hover button#page-search-copy span { + opacity: 100%; +} +/* snippet copy button */ +button.snippet-copy { + position: absolute; + top: 6px; + right: 6px; + height: 1.7em; + padding: 2px; +} +button.snippet-copy img { + width: 18px; + height: 18px; + padding: 0.05em 0; +} +button.snippet-copy span { + line-height: 1.2em; + padding: 0.2em; + position: relative; + top: -0.5em; +} +div.snippet-container:hover button.snippet-copy span { + opacity: 100%; +} +/* + * Styles for user-provided tables. + * + * borderless: + * No borders, vertical margins, styled caption. + * This style is provided for use with existing doc comments. + * In general, borderless tables should not be used for layout purposes. + * + * plain: + * Plain borders around table and cells, vertical margins, styled caption. + * Best for small tables or for complex tables for tables with cells that span + * rows and columns, when the "striped" style does not work well. + * + * striped: + * Borders around the table and vertical borders between cells, striped rows, + * vertical margins, styled caption. + * Best for tables that have a header row, and a body containing a series of simple rows. + */ + +table.borderless, +table.plain, +table.striped { + margin-top: 10px; + margin-bottom: 10px; +} +table.borderless > caption, +table.plain > caption, +table.striped > caption { + font-weight: bold; + font-size: smaller; +} +table.borderless th, table.borderless td, +table.plain th, table.plain td, +table.striped th, table.striped td { + padding: 2px 5px; +} +table.borderless, +table.borderless > thead > tr > th, table.borderless > tbody > tr > th, table.borderless > tr > th, +table.borderless > thead > tr > td, table.borderless > tbody > tr > td, table.borderless > tr > td { + border: none; +} +table.borderless > thead > tr, table.borderless > tbody > tr, table.borderless > tr { + background-color: transparent; +} +table.plain { + border-collapse: collapse; + border: 1px solid var(--table-border-color); +} +table.plain > thead > tr, table.plain > tbody tr, table.plain > tr { + background-color: transparent; +} +table.plain > thead > tr > th, table.plain > tbody > tr > th, table.plain > tr > th, +table.plain > thead > tr > td, table.plain > tbody > tr > td, table.plain > tr > td { + border: 1px solid var(--table-border-color); +} +table.striped { + border-collapse: collapse; + border: 1px solid var(--table-border-color); +} +table.striped > thead { + background-color: var(--subnav-background-color); +} +table.striped > thead > tr > th, table.striped > thead > tr > td { + border: 1px solid var(--table-border-color); +} +table.striped > tbody > tr:nth-child(even) { + background-color: var(--odd-row-color) +} +table.striped > tbody > tr:nth-child(odd) { + background-color: var(--even-row-color) +} +table.striped > tbody > tr > th, table.striped > tbody > tr > td { + border-left: 1px solid var(--table-border-color); + border-right: 1px solid var(--table-border-color); +} +table.striped > tbody > tr > th { + font-weight: normal; +} +/** + * Tweak style for small screens. + */ +@media screen and (max-width: 920px) { + header.flex-header { + max-height: 100vh; + overflow-y: auto; + } + div#navbar-top { + height: 2.8em; + transition: height 0.35s ease; + } + ul.nav-list { + display: block; + width: 40%; + float:left; + clear: left; + margin: 10px 0 0 0; + padding: 0; + } + ul.nav-list li { + float: none; + padding: 6px; + margin-left: 10px; + margin-top: 2px; + } + ul.sub-nav-list-small { + display:block; + height: 100%; + width: 50%; + float: right; + clear: right; + background-color: var(--subnav-background-color); + color: var(--body-text-color); + margin: 6px 0 0 0; + padding: 0; + } + ul.sub-nav-list-small ul { + padding-left: 20px; + } + ul.sub-nav-list-small a:link, ul.sub-nav-list-small a:visited { + color:var(--link-color); + } + ul.sub-nav-list-small a:hover { + color:var(--link-color-active); + } + ul.sub-nav-list-small li { + list-style:none; + float:none; + padding: 6px; + margin-top: 1px; + text-transform:uppercase; + } + ul.sub-nav-list-small > li { + margin-left: 10px; + } + ul.sub-nav-list-small li p { + margin: 5px 0; + } + div#navbar-sub-list { + display: none; + } + .top-nav a:link, .top-nav a:active, .top-nav a:visited { + display: block; + } + button#navbar-toggle-button { + width: 3.4em; + height: 2.8em; + background-color: transparent; + display: block; + float: left; + border: 0; + margin: 0 10px; + cursor: pointer; + font-size: 10px; + } + button#navbar-toggle-button .nav-bar-toggle-icon { + display: block; + width: 24px; + height: 3px; + margin: 1px 0 4px 0; + border-radius: 2px; + transition: all 0.1s; + background-color: var(--navbar-text-color); + } + button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(1) { + transform: rotate(45deg); + transform-origin: 10% 10%; + width: 26px; + } + button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(2) { + opacity: 0; + } + button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(3) { + transform: rotate(-45deg); + transform-origin: 10% 90%; + width: 26px; + } +} +@media screen and (max-width: 800px) { + .about-language { + padding-right: 16px; + } + ul.nav-list li { + margin-left: 5px; + } + ul.sub-nav-list-small > li { + margin-left: 5px; + } + main { + padding: 10px; + } + .summary section[class$="-summary"], .details section[class$="-details"], + .class-uses .detail, .serialized-class-details { + padding: 0 8px 5px 8px; + } + body { + -webkit-text-size-adjust: none; + } +} +@media screen and (max-width: 400px) { + .about-language { + font-size: 10px; + padding-right: 12px; + } +} +@media screen and (max-width: 400px) { + .nav-list-search { + width: 94%; + } + #search-input, #page-search-input { + width: 70%; + } +} +@media screen and (max-width: 320px) { + .nav-list-search > label { + display: none; + } + .nav-list-search { + width: 90%; + } + #search-input, #page-search-input { + width: 80%; + } +} + +pre.snippet { + background-color: var(--snippet-background-color); + color: var(--snippet-text-color); + padding: 10px; + margin: 12px 0; + overflow: auto; + white-space: pre; +} +div.snippet-container { + position: relative; +} +@media screen and (max-width: 800px) { + pre.snippet { + padding-top: 26px; + } + button.snippet-copy { + top: 4px; + right: 4px; + } +} +pre.snippet .italic { + font-style: italic; +} +pre.snippet .bold { + font-weight: bold; +} +pre.snippet .highlighted { + background-color: var(--snippet-highlight-color); + border-radius: 10%; +} diff --git a/docs/javadoc/3.0/tag-search-index.js b/docs/javadoc/3.0/tag-search-index.js new file mode 100644 index 000000000..6fc375cea --- /dev/null +++ b/docs/javadoc/3.0/tag-search-index.js @@ -0,0 +1 @@ +tagSearchIndex = [{"l":"Example Usage","h":"class org.hamcrest.beans.HasPropertyWithValue","d":"Section","u":"org/hamcrest/beans/HasPropertyWithValue.html#example-usage-heading"}];updateSearchResults(); \ No newline at end of file diff --git a/docs/javadoc/3.0/type-search-index.js b/docs/javadoc/3.0/type-search-index.js new file mode 100644 index 000000000..08f78aaa5 --- /dev/null +++ b/docs/javadoc/3.0/type-search-index.js @@ -0,0 +1 @@ +typeSearchIndex = [{"l":"All Classes and Interfaces","u":"allclasses-index.html"},{"p":"org.hamcrest.core","l":"AllOf"},{"p":"org.hamcrest.core","l":"AnyOf"},{"p":"org.hamcrest.collection","l":"ArrayAsIterableMatcher"},{"p":"org.hamcrest.collection","l":"ArrayMatching"},{"p":"org.hamcrest","l":"BaseDescription"},{"p":"org.hamcrest","l":"BaseMatcher"},{"p":"org.hamcrest.number","l":"BigDecimalCloseTo"},{"p":"org.hamcrest.text","l":"CharSequenceLength"},{"p":"org.hamcrest.core","l":"CombinableMatcher.CombinableBothMatcher"},{"p":"org.hamcrest.core","l":"CombinableMatcher.CombinableEitherMatcher"},{"p":"org.hamcrest.core","l":"CombinableMatcher"},{"p":"org.hamcrest.comparator","l":"ComparatorMatcherBuilder"},{"p":"org.hamcrest","l":"Condition"},{"p":"org.hamcrest","l":"CoreMatchers"},{"p":"org.hamcrest","l":"CustomMatcher"},{"p":"org.hamcrest","l":"CustomTypeSafeMatcher"},{"p":"org.hamcrest.core","l":"DescribedAs"},{"p":"org.hamcrest","l":"Description"},{"p":"org.hamcrest","l":"DiagnosingMatcher"},{"p":"org.hamcrest.core","l":"Every"},{"p":"org.hamcrest","l":"FeatureMatcher"},{"p":"org.hamcrest.io","l":"FileMatchers"},{"p":"org.hamcrest.io","l":"FileMatchers.FileStatus"},{"p":"org.hamcrest.object","l":"HasEqualValues"},{"p":"org.hamcrest.collection","l":"HasItemInArray"},{"p":"org.hamcrest.beans","l":"HasProperty"},{"p":"org.hamcrest.beans","l":"HasPropertyWithValue"},{"p":"org.hamcrest.object","l":"HasToString"},{"p":"org.hamcrest.xml","l":"HasXPath"},{"p":"org.hamcrest.core","l":"Is"},{"p":"org.hamcrest.core","l":"IsAnything"},{"p":"org.hamcrest.collection","l":"IsArray"},{"p":"org.hamcrest.collection","l":"IsArrayContainingInAnyOrder"},{"p":"org.hamcrest.collection","l":"IsArrayContainingInOrder"},{"p":"org.hamcrest.collection","l":"IsArrayWithSize"},{"p":"org.hamcrest.text","l":"IsBlankString"},{"p":"org.hamcrest.number","l":"IsCloseTo"},{"p":"org.hamcrest.core","l":"IsCollectionContaining"},{"p":"org.hamcrest.collection","l":"IsCollectionWithSize"},{"p":"org.hamcrest.object","l":"IsCompatibleType"},{"p":"org.hamcrest.collection","l":"IsEmptyCollection"},{"p":"org.hamcrest.collection","l":"IsEmptyIterable"},{"p":"org.hamcrest.text","l":"IsEmptyString"},{"p":"org.hamcrest.core","l":"IsEqual"},{"p":"org.hamcrest.text","l":"IsEqualCompressingWhiteSpace"},{"p":"org.hamcrest.text","l":"IsEqualIgnoringCase"},{"p":"org.hamcrest.object","l":"IsEventFrom"},{"p":"org.hamcrest.collection","l":"IsIn"},{"p":"org.hamcrest.core","l":"IsInstanceOf"},{"p":"org.hamcrest.core","l":"IsIterableContaining"},{"p":"org.hamcrest.collection","l":"IsIterableContainingInAnyOrder"},{"p":"org.hamcrest.collection","l":"IsIterableContainingInOrder"},{"p":"org.hamcrest.collection","l":"IsIterableContainingInRelativeOrder"},{"p":"org.hamcrest.collection","l":"IsIterableWithSize"},{"p":"org.hamcrest.collection","l":"IsMapContaining"},{"p":"org.hamcrest.collection","l":"IsMapWithSize"},{"p":"org.hamcrest.number","l":"IsNaN"},{"p":"org.hamcrest.core","l":"IsNot"},{"p":"org.hamcrest.core","l":"IsNull"},{"p":"org.hamcrest.core","l":"IsSame"},{"p":"org.hamcrest","l":"Matcher"},{"p":"org.hamcrest","l":"MatcherAssert"},{"p":"org.hamcrest","l":"Matchers"},{"p":"org.hamcrest.text","l":"MatchesPattern"},{"p":"org.hamcrest","l":"Description.NullDescription"},{"p":"org.hamcrest.number","l":"OrderingComparison"},{"p":"org.hamcrest.beans","l":"PropertyUtil"},{"p":"org.hamcrest.beans","l":"SamePropertyValuesAs"},{"p":"org.hamcrest","l":"SelfDescribing"},{"p":"org.hamcrest","l":"Condition.Step"},{"p":"org.hamcrest.core","l":"StringContains"},{"p":"org.hamcrest.text","l":"StringContainsInOrder"},{"p":"org.hamcrest","l":"StringDescription"},{"p":"org.hamcrest.core","l":"StringEndsWith"},{"p":"org.hamcrest.core","l":"StringRegularExpression"},{"p":"org.hamcrest.core","l":"StringStartsWith"},{"p":"org.hamcrest.core","l":"SubstringMatcher"},{"p":"org.hamcrest","l":"TypeSafeDiagnosingMatcher"},{"p":"org.hamcrest","l":"TypeSafeMatcher"}];updateSearchResults(); \ No newline at end of file diff --git a/docs/javadoc/index.html b/docs/javadoc/index.html new file mode 100644 index 000000000..c12c7ea34 --- /dev/null +++ b/docs/javadoc/index.html @@ -0,0 +1,92 @@ + + + + + + + + + + Java Hamcrest + + + + +
    +

    Java Hamcrest

    +

    Matchers that can be combined to create flexible expressions of intent

    +

    API Reference Documentation (JavaDoc)

    +

    Lastest Version

    + +

    Previous Versions

    + + +
    + Fork me on GitHub + + + diff --git a/docs/related.md b/docs/related.md new file mode 100644 index 000000000..5c208afb3 --- /dev/null +++ b/docs/related.md @@ -0,0 +1,31 @@ +--- +title: Hamcrest Related Projects +layout: default +--- +[Java Hamcrest Home](index) + +# Related Projects + +Here are some projects that provide additional features and matchers + +* [Awaitility](https://github.com/jayway/awaitility) (a DSL that allows you to express expectations of an asynchronous system in a concise and easy to read manner) +* [Hamcrest 1.3 Utility Matchers](https://github.com/NitorCreations/matchers) (Java matchers like CollectionMatchers, MapMatchers, FieldMatcher, SerializableMatcher etc) +* [Hamcrest auto matcher](https://github.com/itsallcode/hamcrest-auto-matcher) (uses reflection to automatically match model classes) +* [Hamcrest Composites](https://github.com/Cornutum/hamcrest-composites) (for comparing complex Java objects with better testability) +* [Hamcrest Date](https://github.com/modularit/hamcrest-date) (for comparing dates) +* [Hamcrest HAR](https://github.com/roydekleijn/har-assert) (for HTTP archive files) +* [Hamcrest Java Extras](https://github.com/sf105/hamcrest-java-extras) (currently only a couple of Json matchers) +* [Hamcrest JSON](https://github.com/hertzsprung/hamcrest-json) (for comparing entire JSON documents) +* [Hamcrest Mail](https://github.com/devopsix/hamcrest-mail) (for comparing types from the `javax.mail` package) +* [Hamcrest Path](https://github.com/seinesoftware/hamcrest-path) (for testing path existence and permissions) +* [Hamcrest Querydsl](https://github.com/beloglazov/hamcrest-querydsl) (for checking query results: hasResultSize, hasColumnRange, hasColumnMax, hasColumnMin, hasColumnContainingAll, hasColumnContainingAny) +* [Hamcrest Result Set Matcher](https://github.com/exasol/hamcrest-resultset-matcher) (comparing JDBC result set against each other or structures) +* [Hamcrest Text Patterns](http://code.google.com/p/hamcrest-text-patterns/) +* [hamcrest-pojo-matcher-generator](https://github.com/yandex-qatools/hamcrest-pojo-matcher-generator) (Annotation processor to generate feature-matchers based on your POJOs) +* [http-matchers](https://github.com/valid4j/http-matchers) (Matchers to test your web service via the standard Java API for RESTful Services (JAX-RS)) +* [json-path-matchers](https://github.com/jayway/JsonPath/tree/master/json-path-assert) (for evaluating JSON path expressions) +* [JsonUnit](https://github.com/lukas-krecan/JsonUnit) (for comparing JSON structures jsonEquals, jsonPartEquals) +* [Proboscis](https://github.com/sf105/proboscis) (a tiny java library for polling for a result, originally intended for tested asynchronous systems) +* [Shazamcrest](https://github.com/shazam/shazamcrest) (Matchers for beans with custom field matching and nice failure messages) +* [Spotify's hamcrest matchers](https://github.com/spotify/java-hamcrest) (Matchers for POJOs, JSON, and some of the types introduced in Java 8) +* [valid4j](https://github.com/valid4j/valid4j) (assertion and validation library, i.e supporting design-by-contract style and/or recoverable input validation) diff --git a/docs/tutorial.md b/docs/tutorial.md new file mode 100644 index 000000000..4a9489103 --- /dev/null +++ b/docs/tutorial.md @@ -0,0 +1,177 @@ +--- +title: Hamcrest Tutorial +layout: default +--- +[Java Hamcrest Home](index) + +# Hamcrest Tutorial + +## Introduction +Hamcrest is a framework for writing matcher objects allowing 'match' rules to be defined declaratively. There are a number of situations where matchers are invaluable, such as UI validation or data filtering, but it is in the area of writing flexible tests that matchers are most commonly used. This tutorial shows you how to use Hamcrest for unit testing. + +When writing tests it is sometimes difficult to get the balance right between over specifying the test (and making it brittle to changes), and not specifying enough (making the test less valuable since it continues to pass even when the thing being tested is broken). Having a tool that allows you to pick out precisely the aspect under test and describe the values it should have, to a controlled level of precision, helps greatly in writing tests that are "just right". Such tests fail when the behaviour of the aspect under test deviates from the expected behaviour, yet continue to pass when minor, unrelated changes to the behaviour are made. + +### My first Hamcrest test +We'll start by writing a very simple JUnit 5 test, but instead of using JUnit's `assertEquals` methods, we use Hamcrest's `assertThat` construct and the standard set of matchers, both of which we statically import: + +```java +import org.junit.jupiter.api.Test; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +public class BiscuitTest { + @Test + public void testEquals() { + Biscuit theBiscuit = new Biscuit("Ginger"); + Biscuit myBiscuit = new Biscuit("Ginger"); + assertThat(theBiscuit, equalTo(myBiscuit)); + } +} +``` + +The `assertThat` method is a stylized sentence for making a test assertion. In this example, the subject of the assertion is the object biscuit that is the first method parameter. The second method parameter is a matcher for Biscuit objects, here a matcher that checks one object is equal to another using the Object equals method. The test passes since the Biscuit class defines an equals method. + +If you have more than one assertion in your test you can include an identifier for the tested value in the assertion: + +```java +assertThat("chocolate chips", + theBiscuit.getChocolateChipCount(), equalTo(10)); + +assertThat("hazelnuts", + theBiscuit.getHazelnutCount(), equalTo(3)); +``` + +### Other test frameworks +Hamcrest has been designed from the outset to integrate with different unit testing frameworks. For example, Hamcrest can be used with JUnit (all versions) and TestNG. (For details have a look at the examples that come with the full Hamcrest distribution.) It is easy enough to migrate to using Hamcrest-style assertions in an existing test suite, since other assertion styles can co-exist with Hamcrest's. + +Hamcrest can also be used with mock objects frameworks by using adaptors to bridge from the mock objects framework's concept of a matcher to a Hamcrest matcher. For example, JMock 1's constraints are Hamcrest's matchers. Hamcrest provides a JMock 1 adaptor to allow you to use Hamcrest matchers in your JMock 1 tests. JMock 2 doesn't need such an adaptor layer since it is designed to use Hamcrest as its matching library. Hamcrest also provides adaptors for EasyMock 2. Again, see the Hamcrest examples for more details. + +### A tour of common matchers +Hamcrest comes with a library of useful matchers. Here are some of the most important ones. + +#### Core +`anything` - always matches, useful if you don't care what the object under test is + +`describedAs` - decorator to adding custom failure description + +`is` - decorator to improve readability - see "Sugar", below + +#### Logical +`allOf` - matches if all matchers match, short circuits (like Java &&) + +`anyOf` - matches if any matchers match, short circuits (like Java \|\|) + +`not` - matches if the wrapped matcher doesn't match and vice versa + +#### Object +`equalTo` - test object equality using Object.equals + +`hasToString` - test Object.toString + +`instanceOf`, `isCompatibleType` - test type + +`notNullValue`, `nullValue` - test for null + +`sameInstance` - test object identity + +#### Beans +`hasProperty` - test JavaBeans properties + +#### Collections +`array` - test an array's elements against an array of matchers + +`hasEntry`, `hasKey`, `hasValue` - test a map contains an entry, key or value + +`hasItem`, `hasItems` - test a collection contains elements + +`hasItemInArray` - test an array contains an element + +#### Number +`closeTo` - test floating point values are close to a given value + +`greaterThan`, `greaterThanOrEqualTo`, `lessThan`, `lessThanOrEqualTo` - test ordering + +#### Text +`equalToIgnoringCase` - test string equality ignoring case + +`equalToIgnoringWhiteSpace` - test string equality ignoring differences in runs of whitespace + +`containsString`, `endsWith`, `startsWith` - test string matching + +#### Sugar +Hamcrest strives to make your tests as readable as possible. For example, the `is` matcher is a wrapper that doesn't add any extra behavior to the underlying matcher. The following assertions are all equivalent: + +```java +assertThat(theBiscuit, equalTo(myBiscuit)); +assertThat(theBiscuit, is(equalTo(myBiscuit))); +assertThat(theBiscuit, is(myBiscuit)); +``` + +The last form is allowed since `is(T value)` is overloaded to return `is(equalTo(value))`. + +### Writing custom matchers +Hamcrest comes bundled with lots of useful matchers, but you'll probably find that you need to create your own from time to time to fit your testing needs. This commonly occurs when you find a fragment of code that tests the same set of properties over and over again (and in different tests), and you want to bundle the fragment into a single assertion. By writing your own matcher you'll eliminate code duplication and make your tests more readable! + +Let's write our own matcher for testing if a double value has the value NaN (not a number). This is the test we want to write: + +```java +@Test +public void testSquareRootOfMinusOneIsNotANumber() { + assertThat(Math.sqrt(-1), is(notANumber())); +} +``` + +And here's the implementation: + +```java +package org.hamcrest.examples; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; + +public class IsNotANumber extends TypeSafeMatcher { + + @Override + public boolean matchesSafely(Double number) { + return number.isNaN(); + } + + public void describeTo(Description description) { + description.appendText("not a number"); + } + + public static Matcher notANumber() { + return new IsNotANumber(); + } + +} +``` + +The `assertThat` method is a generic method which takes a Matcher parameterized by the type of the subject of the assertion. We are asserting things about Double values, so we know that we need a `Matcher`. For our Matcher implementation it is most convenient to subclass `TypeSafeMatcher`, which does the cast to a Double for us. We need only implement the `matchesSafely` method - which simply checks to see if the Double is NaN - and the `describeTo` method - which is used to produce a failure message when a test fails. Here's an example of how the failure message looks: + +```java +assertThat(1.0, is(notANumber())); + +// fails with the message + +java.lang.AssertionError: Expected: is not a number got : <1.0> + +``` +The third method in our matcher is a convenience factory method. We statically import this method to use the matcher in our test: + +```java +import org.junit.jupiter.api.Test; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; +import static org.hamcrest.examples.IsNotANumber.notANumber; + +public class NumberTest { + @Test + public void testSquareRootOfMinusOneIsNotANumber() { + assertThat(Math.sqrt(-1), is(notANumber())); + } +} +``` + +Even though the `notANumber` method creates a new matcher each time it is called, you should not assume this is the only usage pattern for your matcher. Therefore you should make sure your matcher is stateless, so a single instance can be reused between matches. diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml new file mode 100644 index 000000000..40e1c4485 --- /dev/null +++ b/gradle/libs.versions.toml @@ -0,0 +1,7 @@ +# https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format + +[versions] +junit-jupiter = "5.11.3" + +[libraries] +junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } diff --git a/gradle/versioning.gradle b/gradle/versioning.gradle new file mode 100644 index 000000000..9960e0d11 --- /dev/null +++ b/gradle/versioning.gradle @@ -0,0 +1,25 @@ +ext.getGitVersion = { -> + def stdout = new ByteArrayOutputStream() + exec { + commandLine "git", "describe", "--tags" + standardOutput = stdout + } + return stdout.toString().trim().replaceAll("v", "") +} + +ext.getMavenVersion = { -> + def gitVersion = getGitVersion() + if (!gitVersion.contains("-")) { + // We're directly on a tagged commit + return gitVersion + } + + def match = gitVersion =~ /^(\d+)\.(\d+)-.*$/ + // Make sure we're only using the major.minor version. + assert match : "Unexpected version from git: ${gitVersion}" + + // We're not directly on a tagged commit, so increment the minor version and call it a snapshot + def (_, major, minor) = match[0] + def mvnMinor = minor.toInteger() + 1 + return "${major}.${mvnMinor}-SNAPSHOT" +} diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index c97a8bdb9..2c3521197 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index b571382a8..0aaefbcaf 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,7 @@ -#Tue Apr 07 18:28:48 CEST 2015 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip +networkTimeout=10000 +validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-bin.zip diff --git a/gradlew b/gradlew index 91a7e269e..f5feea6d6 100755 --- a/gradlew +++ b/gradlew @@ -1,79 +1,130 @@ -#!/usr/bin/env bash +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# ############################################################################## -## -## Gradle start up script for UN*X -## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# ############################################################################## -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS="" +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done -APP_NAME="Gradle" -APP_BASE_NAME=`basename "$0"` +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s +' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD="maximum" +MAX_FD=maximum -warn ( ) { +warn () { echo "$*" -} +} >&2 -die ( ) { +die () { echo echo "$*" echo exit 1 -} +} >&2 # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false -case "`uname`" in - CYGWIN* ) - cygwin=true - ;; - Darwin* ) - darwin=true - ;; - MINGW* ) - msys=true - ;; +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; esac -# For Cygwin, ensure paths are in UNIX format before anything is touched. -if $cygwin ; then - [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` -fi - -# Attempt to set APP_HOME -# Resolve links: $0 may be a link -PRG="$0" -# Need this for relative symlinks. -while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then - PRG="$link" - else - PRG=`dirname "$PRG"`"/$link" - fi -done -SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >&- -APP_HOME="`pwd -P`" -cd "$SAVED" >&- - CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables - JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACMD=$JAVA_HOME/jre/sh/java else - JAVACMD="$JAVA_HOME/bin/java" + JAVACMD=$JAVA_HOME/bin/java fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME @@ -82,83 +133,120 @@ Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else - JAVACMD="java" - which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." + fi fi # Increase the maximum file descriptors if we can. -if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then - MAX_FD_LIMIT=`ulimit -H -n` - if [ $? -eq 0 ] ; then - if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then - MAX_FD="$MAX_FD_LIMIT" - fi - ulimit -n $MAX_FD - if [ $? -ne 0 ] ; then - warn "Could not set maximum file descriptor limit: $MAX_FD" - fi - else - warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" - fi +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac fi -# For Darwin, add options to specify how the application appears in the dock -if $darwin; then - GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" -fi +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) -# For Cygwin, switch paths to Windows format before running java -if $cygwin ; then - APP_HOME=`cygpath --path --mixed "$APP_HOME"` - CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` - - # We build the pattern for arguments to be converted via cygpath - ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` - SEP="" - for dir in $ROOTDIRSRAW ; do - ROOTDIRS="$ROOTDIRS$SEP$dir" - SEP="|" - done - OURCYGPATTERN="(^($ROOTDIRS))" - # Add a user-defined pattern to the cygpath arguments - if [ "$GRADLE_CYGPATTERN" != "" ] ; then - OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" - fi # Now convert the arguments - kludge to limit ourselves to /bin/sh - i=0 - for arg in "$@" ; do - CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` - CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option - - if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition - eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` - else - eval `echo args$i`="\"$arg\"" + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) fi - i=$((i+1)) + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg done - case $i in - (0) set -- ;; - (1) set -- "$args0" ;; - (2) set -- "$args0" "$args1" ;; - (3) set -- "$args0" "$args1" "$args2" ;; - (4) set -- "$args0" "$args1" "$args2" "$args3" ;; - (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; - (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; - (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; - (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; - (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; - esac fi -# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules -function splitJvmOpts() { - JVM_OPTS=("$@") -} -eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS -JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" -exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat index 8a0b282aa..9b42019c7 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -1,90 +1,94 @@ -@if "%DEBUG%" == "" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS= - -set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto init - -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto init - -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:init -@rem Get command-line arguments, handling Windowz variants - -if not "%OS%" == "Windows_NT" goto win9xME_args -if "%@eval[2+2]" == "4" goto 4NT_args - -:win9xME_args -@rem Slurp the command line arguments. -set CMD_LINE_ARGS= -set _SKIP=2 - -:win9xME_args_slurp -if "x%~1" == "x" goto execute - -set CMD_LINE_ARGS=%* -goto execute - -:4NT_args -@rem Get arguments from the 4NT Shell from JP Software -set CMD_LINE_ARGS=%$ - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% - -:end -@rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/hamcrest-core/hamcrest-core.gradle b/hamcrest-core/hamcrest-core.gradle new file mode 100644 index 000000000..d2a91f8ed --- /dev/null +++ b/hamcrest-core/hamcrest-core.gradle @@ -0,0 +1,18 @@ +dependencies { + api project(':hamcrest') +} + +jar { + manifest { + attributes 'Implementation-Title': project.name, + 'Implementation-Vendor': 'hamcrest.org', + 'Implementation-Version': version, + 'Automatic-Module-Name': 'org.hamcrest.core.deprecated' + } +} + +javadoc { + title = "Hamcrest Core $version API" + options.showFromPackage() + options.showFromPrivate() +} diff --git a/hamcrest-core/hamcrest-core.iml b/hamcrest-core/hamcrest-core.iml deleted file mode 100644 index 9991f4e43..000000000 --- a/hamcrest-core/hamcrest-core.iml +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - - - - - - - - diff --git a/hamcrest-core/src/main/java/org/hamcrest/Condition.java b/hamcrest-core/src/main/java/org/hamcrest/Condition.java deleted file mode 100644 index 02ce09e68..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/Condition.java +++ /dev/null @@ -1,69 +0,0 @@ -package org.hamcrest; - -/** - * A Condition implements part of a multi-step match. We sometimes need to write matchers - * that have a sequence of steps, where each step depends on the result of the previous - * step and we can stop processing as soon as a step fails. These classes provide - * infrastructure for writing such a sequence. - * - * Based on https://github.com/npryce/maybe-java - * @author Steve Freeman 2012 http://www.hamcrest.com - */ - -public abstract class Condition { - public static final NotMatched NOT_MATCHED = new NotMatched(); - - public interface Step { - Condition apply(I value, Description mismatch); - } - - private Condition() { } - - public abstract boolean matching(Matcher match, String message); - public abstract Condition and(Step mapping); - - public final boolean matching(Matcher match) { return matching(match, ""); } - public final Condition then(Step mapping) { return and(mapping); } - - @SuppressWarnings("unchecked") - public static Condition notMatched() { - return (Condition) NOT_MATCHED; - } - - public static Condition matched(final T theValue, final Description mismatch) { - return new Matched(theValue, mismatch); - } - - private static final class Matched extends Condition { - private final T theValue; - private final Description mismatch; - - private Matched(T theValue, Description mismatch) { - this.theValue = theValue; - this.mismatch = mismatch; - } - - @Override - public boolean matching(Matcher matcher, String message) { - if (matcher.matches(theValue)) { - return true; - } - mismatch.appendText(message); - matcher.describeMismatch(theValue, mismatch); - return false; - } - - @Override - public Condition and(Step next) { - return next.apply(theValue, mismatch); - } - } - - private static final class NotMatched extends Condition { - @Override public boolean matching(Matcher match, String message) { return false; } - - @Override public Condition and(Step mapping) { - return notMatched(); - } - } -} diff --git a/hamcrest-core/src/main/java/org/hamcrest/Description.java b/hamcrest-core/src/main/java/org/hamcrest/Description.java deleted file mode 100644 index 73bfa3855..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/Description.java +++ /dev/null @@ -1,89 +0,0 @@ -package org.hamcrest; - -/** - * A description of a Matcher. A Matcher will describe itself to a description - * which can later be used for reporting. - * - * @see Matcher#describeTo(Description) - */ -public interface Description { - /** - * A description that consumes input but does nothing. - */ - static final Description NONE = new NullDescription(); - - /** - * Appends some plain text to the description. - */ - Description appendText(String text); - - /** - * Appends the description of a {@link SelfDescribing} value to this description. - */ - Description appendDescriptionOf(SelfDescribing value); - - /** - * Appends an arbitrary value to the description. - */ - Description appendValue(Object value); - - /** - * Appends a list of values to the description. - */ - Description appendValueList(String start, String separator, String end, - T... values); - - /** - * Appends a list of values to the description. - */ - Description appendValueList(String start, String separator, String end, - Iterable values); - - /** - * Appends a list of {@link org.hamcrest.SelfDescribing} objects - * to the description. - */ - Description appendList(String start, String separator, String end, - Iterable values); - - - public static final class NullDescription implements Description { - @Override - public Description appendDescriptionOf(SelfDescribing value) { - return this; - } - - @Override - public Description appendList(String start, String separator, - String end, Iterable values) { - return this; - } - - @Override - public Description appendText(String text) { - return this; - } - - @Override - public Description appendValue(Object value) { - return this; - } - - @Override - public Description appendValueList(String start, String separator, - String end, T... values) { - return this; - } - - @Override - public Description appendValueList(String start, String separator, - String end, Iterable values) { - return this; - } - - @Override - public String toString() { - return ""; - } - } -} diff --git a/hamcrest-core/src/main/java/org/hamcrest/DiagnosingMatcher.java b/hamcrest-core/src/main/java/org/hamcrest/DiagnosingMatcher.java deleted file mode 100644 index f87de2df1..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/DiagnosingMatcher.java +++ /dev/null @@ -1,21 +0,0 @@ -package org.hamcrest; - -/** - * TODO(ngd): Document. - * - * @param - */ -public abstract class DiagnosingMatcher extends BaseMatcher { - - @Override - public final boolean matches(Object item) { - return matches(item, Description.NONE); - } - - @Override - public final void describeMismatch(Object item, Description mismatchDescription) { - matches(item, mismatchDescription); - } - - protected abstract boolean matches(Object item, Description mismatchDescription); -} diff --git a/hamcrest-core/src/main/java/org/hamcrest/MatcherAssert.java b/hamcrest-core/src/main/java/org/hamcrest/MatcherAssert.java deleted file mode 100644 index 049e1df3c..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/MatcherAssert.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.hamcrest; - - -public class MatcherAssert { - public static void assertThat(T actual, Matcher matcher) { - assertThat("", actual, matcher); - } - - public static void assertThat(String reason, T actual, Matcher matcher) { - if (!matcher.matches(actual)) { - Description description = new StringDescription(); - description.appendText(reason) - .appendText("\nExpected: ") - .appendDescriptionOf(matcher) - .appendText("\n but: "); - matcher.describeMismatch(actual, description); - - throw new AssertionError(description.toString()); - } - } - - public static void assertThat(String reason, boolean assertion) { - if (!assertion) { - throw new AssertionError(reason); - } - } -} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/CombinableMatcher.java b/hamcrest-core/src/main/java/org/hamcrest/core/CombinableMatcher.java deleted file mode 100644 index 2414bbb2b..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/core/CombinableMatcher.java +++ /dev/null @@ -1,82 +0,0 @@ -package org.hamcrest.core; - -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeDiagnosingMatcher; - -import java.util.ArrayList; - -public class CombinableMatcher extends TypeSafeDiagnosingMatcher { - private final Matcher matcher; - - public CombinableMatcher(Matcher matcher) { - this.matcher = matcher; - } - - @Override - protected boolean matchesSafely(T item, Description mismatch) { - if (!matcher.matches(item)) { - matcher.describeMismatch(item, mismatch); - return false; - } - return true; - } - - @Override - public void describeTo(Description description) { - description.appendDescriptionOf(matcher); - } - - public CombinableMatcher and(Matcher other) { - return new CombinableMatcher(new AllOf(templatedListWith(other))); - } - - public CombinableMatcher or(Matcher other) { - return new CombinableMatcher(new AnyOf(templatedListWith(other))); - } - - private ArrayList> templatedListWith(Matcher other) { - ArrayList> matchers = new ArrayList>(); - matchers.add(matcher); - matchers.add(other); - return matchers; - } - - /** - * Creates a matcher that matches when both of the specified matchers match the examined object. - * For example: - *
    assertThat("fab", both(containsString("a")).and(containsString("b")))
    - */ - public static CombinableBothMatcher both(Matcher matcher) { - return new CombinableBothMatcher(matcher); - } - - public static final class CombinableBothMatcher { - private final Matcher first; - public CombinableBothMatcher(Matcher matcher) { - this.first = matcher; - } - public CombinableMatcher and(Matcher other) { - return new CombinableMatcher(first).and(other); - } - } - - /** - * Creates a matcher that matches when either of the specified matchers match the examined object. - * For example: - *
    assertThat("fan", either(containsString("a")).or(containsString("b")))
    - */ - public static CombinableEitherMatcher either(Matcher matcher) { - return new CombinableEitherMatcher(matcher); - } - - public static final class CombinableEitherMatcher { - private final Matcher first; - public CombinableEitherMatcher(Matcher matcher) { - this.first = matcher; - } - public CombinableMatcher or(Matcher other) { - return new CombinableMatcher(first).or(other); - } - } -} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/HamcrestCoreIsDeprecated.java b/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/HamcrestCoreIsDeprecated.java new file mode 100644 index 000000000..afac0ea83 --- /dev/null +++ b/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/HamcrestCoreIsDeprecated.java @@ -0,0 +1,14 @@ +package org.hamcrest.core.deprecated; + +/** + * All the classes in hamcrest-core.jar have moved to + * hamcrest.jar. Please use that dependency instead. + */ +@Deprecated +class HamcrestCoreIsDeprecated { + /** + * Unused + */ + private HamcrestCoreIsDeprecated() { + } +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/package-info.java b/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/package-info.java new file mode 100644 index 000000000..394ab8218 --- /dev/null +++ b/hamcrest-core/src/main/java/org/hamcrest/core/deprecated/package-info.java @@ -0,0 +1,5 @@ +/** + * All classes in hamcrest-core.jar have been migrated to + * hamcrest.jar. Please use that dependency instead. + */ +package org.hamcrest.core.deprecated; \ No newline at end of file diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/package.html b/hamcrest-core/src/main/java/org/hamcrest/core/package.html deleted file mode 100644 index 7bb0ffe10..000000000 --- a/hamcrest-core/src/main/java/org/hamcrest/core/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Fundamental matchers of objects and values, and composite matchers.

    - - diff --git a/hamcrest-core/src/main/resources/hamcrest-core-is-deprecated.txt b/hamcrest-core/src/main/resources/hamcrest-core-is-deprecated.txt new file mode 100644 index 000000000..4c860f0c1 --- /dev/null +++ b/hamcrest-core/src/main/resources/hamcrest-core-is-deprecated.txt @@ -0,0 +1,5 @@ +Hamcrest Core +============= + +All the classes in hamcrest-core.jar and hamcrest-library.jar has moved +into hamcrest.jar. Please update your dependencies. \ No newline at end of file diff --git a/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java b/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java deleted file mode 100644 index 22f823b39..000000000 --- a/hamcrest-core/src/test/java/org/hamcrest/AbstractMatcherTest.java +++ /dev/null @@ -1,77 +0,0 @@ -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 void assertMatches(Matcher matcher, T arg) { - assertMatches("Expected match, but mismatched", matcher, arg); - } - - public static void assertMatches(String message, Matcher matcher, T arg) { - if (!matcher.matches(arg)) { - Assert.fail(message + " because: '" + mismatchDescription(matcher, arg) + "'"); - } - } - - public static void assertDoesNotMatch(Matcher c, T arg) { - assertDoesNotMatch("Unexpected match", c, arg); - } - - public static void assertDoesNotMatch(String message, Matcher 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 void assertMismatchDescription(String expected, Matcher 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 String mismatchDescription(Matcher 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/core/IsCollectionContainingTest.java b/hamcrest-core/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java deleted file mode 100644 index a9007cd51..000000000 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java +++ /dev/null @@ -1,107 +0,0 @@ -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> itemMatcher = hasItem(equalTo("a")); - - assertMatches("list containing 'a'", itemMatcher, asList("a", "b", "c")); - } - - @Test public void - doesNotMatchCollectionWithoutAnElementForGivenMatcher() { - final Matcher> matcher = hasItem(mismatchable("a")); - - assertMismatchDescription("mismatches were: [mismatched: b, mismatched: c]", matcher, asList("b", "c")); - assertMismatchDescription("was empty", matcher, new ArrayList()); - } - - @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 s = new HashSet(); - s.add(2); - - assertMatches(new IsCollectionContaining(new IsEqual(2)), s); - assertMatches(IsCollectionContaining.hasItem(2), s); - } - - @SuppressWarnings("unchecked") - @Test public void - matchesMultipleItemsInCollection() { - final Matcher> matcher1 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); - assertMatches("list containing all items", matcher1, asList("a", "b", "c")); - - final Matcher> matcher2 = hasItems("a", "b", "c"); - assertMatches("list containing all items (without matchers)", matcher2, asList("a", "b", "c")); - - final Matcher> matcher3 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); - assertMatches("list containing all items in any order", matcher3, asList("c", "b", "a")); - - final Matcher> matcher4 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); - assertMatches("list containing all items plus others", matcher4, asList("e", "c", "b", "a", "d")); - - final Matcher> 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> 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 mismatchable(final String string) { - return new TypeSafeDiagnosingMatcher() { - @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-integration/hamcrest-integration.gradle b/hamcrest-integration/hamcrest-integration.gradle new file mode 100644 index 000000000..816b7a320 --- /dev/null +++ b/hamcrest-integration/hamcrest-integration.gradle @@ -0,0 +1,15 @@ +version = '1.3.1-SNAPSHOT' + +dependencies { + api 'org.hamcrest:hamcrest-library:1.3' + api 'org.easymock:easymock:2.2' + api('jmock:jmock:1.1.0') { + transitive = false + } + + testImplementation(group: 'junit', name: 'junit', version: '4.13.2') { + transitive = false + } +} + +javadoc.title = "Hamcrest Integration $version API" diff --git a/hamcrest-integration/src/main/java/org/hamcrest/EasyMock2Matchers.java b/hamcrest-integration/src/main/java/org/hamcrest/EasyMock2Matchers.java new file mode 100644 index 000000000..936aa7d56 --- /dev/null +++ b/hamcrest-integration/src/main/java/org/hamcrest/EasyMock2Matchers.java @@ -0,0 +1,17 @@ +package org.hamcrest; + +import org.hamcrest.integration.EasyMock2Adapter; +import org.hamcrest.core.IsEqual; + +/** + * + * @author Joe Walnes + */ +public class EasyMock2Matchers { + + public static String equalTo(String string) { + EasyMock2Adapter.adapt(IsEqual.equalTo(string)); + return null; + } + +} diff --git a/hamcrest-integration/src/main/java/org/hamcrest/JMock1Matchers.java b/hamcrest-integration/src/main/java/org/hamcrest/JMock1Matchers.java new file mode 100644 index 000000000..949b1fe79 --- /dev/null +++ b/hamcrest-integration/src/main/java/org/hamcrest/JMock1Matchers.java @@ -0,0 +1,13 @@ +package org.hamcrest; + +import org.hamcrest.integration.JMock1Adapter; +import org.hamcrest.core.IsEqual; +import org.jmock.core.Constraint; + +public class JMock1Matchers { + + public static Constraint equalTo(String string) { + return JMock1Adapter.adapt(IsEqual.equalTo(string)); + } + +} diff --git a/hamcrest-integration/src/main/java/org/hamcrest/JavaLangMatcherAssert.java b/hamcrest-integration/src/main/java/org/hamcrest/JavaLangMatcherAssert.java new file mode 100644 index 000000000..bb0d5160a --- /dev/null +++ b/hamcrest-integration/src/main/java/org/hamcrest/JavaLangMatcherAssert.java @@ -0,0 +1,20 @@ +package org.hamcrest; + +/** + * Integration method for use with Java's assert keyword. + * Example: + *
    + * assert that("Foo", startsWith("f"));
    + * 
    + * + * @author Neil Dunn + */ +public class JavaLangMatcherAssert { + + private JavaLangMatcherAssert() {}; + + public static boolean that(T argument, Matcher matcher) { + return matcher.matches(argument); + } + +} diff --git a/hamcrest-integration/src/main/java/org/hamcrest/integration/EasyMock2Adapter.java b/hamcrest-integration/src/main/java/org/hamcrest/integration/EasyMock2Adapter.java new file mode 100644 index 000000000..4773dc65e --- /dev/null +++ b/hamcrest-integration/src/main/java/org/hamcrest/integration/EasyMock2Adapter.java @@ -0,0 +1,48 @@ +package org.hamcrest.integration; + +import org.easymock.IArgumentMatcher; +import org.easymock.EasyMock; +import org.hamcrest.Matcher; +import org.hamcrest.StringDescription; + +/** + * An adapter allowing a Hamcrest {@link org.hamcrest.Matcher} + * to act as an EasyMock {@link org.easymock.IArgumentMatcher}. + * + * @author Joe Walnes + */ +public class EasyMock2Adapter implements IArgumentMatcher { + + /** + * Convenience factory method that will adapt a + * Hamcrest {@link org.hamcrest.Matcher} to act as an + * EasyMock {@link org.easymock.IArgumentMatcher} and + * report it to EasyMock so it can be kept track of. + * + * @param matcher + * the matcher to adapt to EasyMock constraint. + * @return The EasyMock matcher. + */ + public static IArgumentMatcher adapt(Matcher matcher) { + EasyMock2Adapter easyMock2Matcher = new EasyMock2Adapter(matcher); + EasyMock.reportMatcher(easyMock2Matcher); + return easyMock2Matcher; + } + + private final Matcher hamcrestMatcher; + + public EasyMock2Adapter(Matcher matcher) { + this.hamcrestMatcher = matcher; + } + + @Override + public boolean matches(Object argument) { + return hamcrestMatcher.matches(argument); + } + + @Override + public void appendTo(StringBuffer buffer) { + hamcrestMatcher.describeTo(new StringDescription(buffer)); + } + +} diff --git a/hamcrest-integration/src/main/java/org/hamcrest/integration/JMock1Adapter.java b/hamcrest-integration/src/main/java/org/hamcrest/integration/JMock1Adapter.java new file mode 100644 index 000000000..cf821f9fd --- /dev/null +++ b/hamcrest-integration/src/main/java/org/hamcrest/integration/JMock1Adapter.java @@ -0,0 +1,47 @@ +package org.hamcrest.integration; + +import org.jmock.core.Constraint; +import org.hamcrest.Matcher; +import org.hamcrest.StringDescription; + +/** + * An adapter allowing a Hamcrest {@link org.hamcrest.Matcher} + * to act as an jMock1 {@link org.jmock.core.Constraint}. + * Note, this is not necessary for jMock2 as it supports Hamcrest + * out of the box. + * + * @author Joe Walnes + */ +public class JMock1Adapter implements Constraint { + + /** + * Convenience factory method that will adapt a + * Hamcrest {@link org.hamcrest.Matcher} to act as an + * jMock {@link org.jmock.core.Constraint}. + * + * @param matcher + * the matcher to adapt to jMock constraint. + * @return The jMock constraint. + */ + public static Constraint adapt(Matcher matcher) { + return new JMock1Adapter(matcher); + } + + private final Matcher hamcrestMatcher; + + public JMock1Adapter(Matcher matcher) { + this.hamcrestMatcher = matcher; + } + + @Override + public boolean eval(Object o) { + return hamcrestMatcher.matches(o); + } + + @Override + public StringBuffer describeTo(StringBuffer buffer) { + hamcrestMatcher.describeTo(new StringDescription(buffer)); + return buffer; + } + +} diff --git a/hamcrest-library/hamcrest-library.gradle b/hamcrest-library/hamcrest-library.gradle new file mode 100644 index 000000000..fd8d19d16 --- /dev/null +++ b/hamcrest-library/hamcrest-library.gradle @@ -0,0 +1,17 @@ +dependencies { + api project(':hamcrest-core') +} + +jar { + manifest { + attributes 'Implementation-Title': project.name, + 'Implementation-Vendor': 'hamcrest.org', + 'Implementation-Version': version, + 'Automatic-Module-Name': 'org.hamcrest.library.deprecated' + } +} + +javadoc { + title = "Hamcrest Library $version API" + options.showFromPackage() +} diff --git a/hamcrest-library/hamcrest-library.iml b/hamcrest-library/hamcrest-library.iml deleted file mode 100644 index 6a890abdf..000000000 --- a/hamcrest-library/hamcrest-library.iml +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - - - - - - - - - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java b/hamcrest-library/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java deleted file mode 100644 index 326f9dcf3..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java +++ /dev/null @@ -1,148 +0,0 @@ -package org.hamcrest.beans; - -import org.hamcrest.Condition; -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeDiagnosingMatcher; - -import java.beans.PropertyDescriptor; -import java.lang.reflect.Method; - -import static org.hamcrest.Condition.matched; -import static org.hamcrest.Condition.notMatched; -import static org.hamcrest.beans.PropertyUtil.NO_ARGUMENTS; - -/** - *

    Matcher that asserts that a JavaBean property on an argument passed to the - * mock object meets the provided matcher. This is useful for when objects - * are created within code under test and passed to a mock object, and you wish - * to assert that the created object has certain properties. - *

    - * - *

    Example Usage

    - * Consider the situation where we have a class representing a person, which - * follows the basic JavaBean convention of having get() and possibly set() - * methods for it's properties: - *
    - * public class Person {
    - *   private String name;
    - *   public Person(String person) {
    - *     this.person = person;
    - *   }
    - *   public String getName() {
    - *     return name;
    - *   }
    - * }
    - * - * And that these person objects are generated within a piece of code under test - * (a class named PersonGenerator). This object is sent to one of our mock objects - * which overrides the PersonGenerationListener interface: - *
    - * public interface PersonGenerationListener {
    - *   public void personGenerated(Person person);
    - * }
    - * - * In order to check that the code under test generates a person with name - * "Iain" we would do the following: - *
    - * Mock personGenListenerMock = mock(PersonGenerationListener.class);
    - * personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
    - * PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy();
    - * - *

    If an exception is thrown by the getter method for a property, the property - * does not exist, is not readable, or a reflection related exception is thrown - * when trying to invoke it then this is treated as an evaluation failure and - * the matches method will return false. - *

    - *

    This matcher class will also work with JavaBean objects that have explicit - * bean descriptions via an associated BeanInfo description class. See the - * JavaBeans specification for more information: - * http://java.sun.com/products/javabeans/docs/index.html - *

    - * - * @author Iain McGinniss - * @author Nat Pryce - * @author Steve Freeman - */ -public class HasPropertyWithValue extends TypeSafeDiagnosingMatcher { - private static final Condition.Step WITH_READ_METHOD = withReadMethod(); - private final String propertyName; - private final Matcher valueMatcher; - - public HasPropertyWithValue(String propertyName, Matcher valueMatcher) { - this.propertyName = propertyName; - this.valueMatcher = nastyGenericsWorkaround(valueMatcher); - } - - @Override - public boolean matchesSafely(T bean, Description mismatch) { - return propertyOn(bean, mismatch) - .and(WITH_READ_METHOD) - .and(withPropertyValue(bean)) - .matching(valueMatcher, "property '" + propertyName + "' "); - } - - @Override - public void describeTo(Description description) { - description.appendText("hasProperty(").appendValue(propertyName).appendText(", ") - .appendDescriptionOf(valueMatcher).appendText(")"); - } - - private Condition propertyOn(T bean, Description mismatch) { - PropertyDescriptor property = PropertyUtil.getPropertyDescriptor(propertyName, bean); - if (property == null) { - mismatch.appendText("No property \"" + propertyName + "\""); - return notMatched(); - } - - return matched(property, mismatch); - } - - private Condition.Step withPropertyValue(final T bean) { - return new Condition.Step() { - @Override - public Condition apply(Method readMethod, Description mismatch) { - try { - return matched(readMethod.invoke(bean, NO_ARGUMENTS), mismatch); - } catch (Exception e) { - mismatch.appendText(e.getMessage()); - return notMatched(); - } - } - }; - } - - @SuppressWarnings("unchecked") - private static Matcher nastyGenericsWorkaround(Matcher valueMatcher) { - return (Matcher) valueMatcher; - } - - private static Condition.Step withReadMethod() { - return new Condition.Step() { - @Override - public Condition apply(PropertyDescriptor property, Description mismatch) { - final Method readMethod = property.getReadMethod(); - if (null == readMethod) { - mismatch.appendText("property \"" + property.getName() + "\" is not readable"); - return notMatched(); - } - return matched(readMethod, mismatch); - } - }; - } - - /** - * Creates a matcher that matches when the examined object has a JavaBean property - * with the specified name whose value satisfies the specified matcher. - * For example: - *
    assertThat(myBean, hasProperty("foo", equalTo("bar"))
    - * - * @param propertyName - * the name of the JavaBean property that examined beans should possess - * @param valueMatcher - * a matcher for the value of the specified property of the examined bean - */ - public static Matcher hasProperty(String propertyName, Matcher valueMatcher) { - return new HasPropertyWithValue(propertyName, valueMatcher); - } -} diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/PropertyUtil.java b/hamcrest-library/src/main/java/org/hamcrest/beans/PropertyUtil.java deleted file mode 100644 index 946c4f847..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/beans/PropertyUtil.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.hamcrest.beans; - -import java.beans.IntrospectionException; -import java.beans.Introspector; -import java.beans.PropertyDescriptor; - -/** - * Utility class for accessing properties on JavaBean objects. - * See http://java.sun.com/products/javabeans/docs/index.html for - * more information on JavaBeans. - * - * @author Iain McGinniss - * @author Steve Freeman - * @since 1.1.0 - */ -public class PropertyUtil { - /** - * Returns the description of the property with the provided - * name on the provided object's interface. - * - * @return the descriptor of the property, or null if the property does not exist. - * @throws IllegalArgumentException if there's a introspection failure - */ - public static PropertyDescriptor getPropertyDescriptor(String propertyName, Object fromObj) throws IllegalArgumentException { - for (PropertyDescriptor property : propertyDescriptorsFor(fromObj, null)) { - if (property.getName().equals(propertyName)) { - return property; - } - } - - return null; - } - - /** - * Returns all the property descriptors for the class associated with the given object - * - * @param fromObj Use the class of this object - * @param stopClass Don't include any properties from this ancestor class upwards. - * @return Property descriptors - * @throws IllegalArgumentException if there's a introspection failure - */ - public static PropertyDescriptor[] propertyDescriptorsFor(Object fromObj, Class stopClass) throws IllegalArgumentException { - try { - return Introspector.getBeanInfo(fromObj.getClass(), stopClass).getPropertyDescriptors(); - } catch (IntrospectionException e) { - throw new IllegalArgumentException("Could not get property descriptors for " + fromObj.getClass(), e); - } - } - - public static final Object[] NO_ARGUMENTS = new Object[0]; -} diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java b/hamcrest-library/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java deleted file mode 100644 index df7eab71f..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java +++ /dev/null @@ -1,140 +0,0 @@ -package org.hamcrest.beans; - -import org.hamcrest.Description; -import org.hamcrest.DiagnosingMatcher; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeDiagnosingMatcher; - -import java.beans.PropertyDescriptor; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import static org.hamcrest.beans.PropertyUtil.NO_ARGUMENTS; -import static org.hamcrest.beans.PropertyUtil.propertyDescriptorsFor; -import static org.hamcrest.core.IsEqual.equalTo; - -public class SamePropertyValuesAs extends TypeSafeDiagnosingMatcher { - private final T expectedBean; - private final Set propertyNames; - private final List propertyMatchers; - - - public SamePropertyValuesAs(T expectedBean) { - PropertyDescriptor[] descriptors = propertyDescriptorsFor(expectedBean, Object.class); - this.expectedBean = expectedBean; - this.propertyNames = propertyNamesFrom(descriptors); - this.propertyMatchers = propertyMatchersFor(expectedBean, descriptors); - } - - @Override - public boolean matchesSafely(T bean, Description mismatch) { - return isCompatibleType(bean, mismatch) - && hasNoExtraProperties(bean, mismatch) - && hasMatchingValues(bean, mismatch); - } - - @Override - public void describeTo(Description description) { - description.appendText("same property values as " + expectedBean.getClass().getSimpleName()) - .appendList(" [", ", ", "]", propertyMatchers); - } - - - private boolean isCompatibleType(T item, Description mismatchDescription) { - if (!expectedBean.getClass().isAssignableFrom(item.getClass())) { - mismatchDescription.appendText("is incompatible type: " + item.getClass().getSimpleName()); - return false; - } - return true; - } - - private boolean hasNoExtraProperties(T item, Description mismatchDescription) { - Set actualPropertyNames = propertyNamesFrom(propertyDescriptorsFor(item, Object.class)); - actualPropertyNames.removeAll(propertyNames); - if (!actualPropertyNames.isEmpty()) { - mismatchDescription.appendText("has extra properties called " + actualPropertyNames); - return false; - } - return true; - } - - private boolean hasMatchingValues(T item, Description mismatchDescription) { - for (PropertyMatcher propertyMatcher : propertyMatchers) { - if (!propertyMatcher.matches(item)) { - propertyMatcher.describeMismatch(item, mismatchDescription); - return false; - } - } - return true; - } - - private static List propertyMatchersFor(T bean, PropertyDescriptor[] descriptors) { - List result = new ArrayList(descriptors.length); - for (PropertyDescriptor propertyDescriptor : descriptors) { - result.add(new PropertyMatcher(propertyDescriptor, bean)); - } - return result; - } - - private static Set propertyNamesFrom(PropertyDescriptor[] descriptors) { - HashSet result = new HashSet(); - for (PropertyDescriptor propertyDescriptor : descriptors) { - result.add(propertyDescriptor.getDisplayName()); - } - return result; - } - - public static class PropertyMatcher extends DiagnosingMatcher { - private final Method readMethod; - private final Matcher matcher; - private final String propertyName; - - public PropertyMatcher(PropertyDescriptor descriptor, Object expectedObject) { - this.propertyName = descriptor.getDisplayName(); - this.readMethod = descriptor.getReadMethod(); - this.matcher = equalTo(readProperty(readMethod, expectedObject)); - } - - @Override - public boolean matches(Object actual, Description mismatch) { - final Object actualValue = readProperty(readMethod, actual); - if (!matcher.matches(actualValue)) { - mismatch.appendText(propertyName + " "); - matcher.describeMismatch(actualValue, mismatch); - return false; - } - return true; - } - - @Override - public void describeTo(Description description) { - description.appendText(propertyName + ": ").appendDescriptionOf(matcher); - } - } - - private static Object readProperty(Method method, Object target) { - try { - return method.invoke(target, NO_ARGUMENTS); - } catch (Exception e) { - throw new IllegalArgumentException("Could not invoke " + method + " on " + target, e); - } - } - - /** - * 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. - * For example: - *
    assertThat(myBean, samePropertyValuesAs(myExpectedBean))
    - * - * @param expectedBean - * the bean against which examined beans are compared - */ - public static Matcher samePropertyValuesAs(T expectedBean) { - return new SamePropertyValuesAs(expectedBean); - } - -} diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/package.html b/hamcrest-library/src/main/java/org/hamcrest/beans/package.html deleted file mode 100644 index 0dcc555d3..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/beans/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers of Java Bean properties and their values.

    - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java deleted file mode 100644 index 749c7c615..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java +++ /dev/null @@ -1,71 +0,0 @@ -package org.hamcrest.collection; - -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -import java.util.Arrays; - -import static org.hamcrest.core.IsEqual.equalTo; - -/** - * Matches if an array contains an item satisfying a nested matcher. - */ -public class IsArrayContaining extends TypeSafeMatcher { - private final Matcher elementMatcher; - - public IsArrayContaining(Matcher elementMatcher) { - this.elementMatcher = elementMatcher; - } - - @Override - public boolean matchesSafely(T[] array) { - for (T item : array) { - if (elementMatcher.matches(item)) { - return true; - } - } - return false; - } - - @Override - public void describeMismatchSafely(T[] item, Description mismatchDescription) { - super.describeMismatch(Arrays.asList(item), mismatchDescription); - } - - @Override - public void describeTo(Description description) { - description - .appendText("an array containing ") - .appendDescriptionOf(elementMatcher); - } - - /** - * Creates a matcher for arrays that matches when the examined array contains at least one item - * that is matched by the specified elementMatcher. Whilst matching, the traversal - * of the examined array will stop as soon as a matching element is found. - * For example: - *
    assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
    - * - * @param elementMatcher - * the matcher to apply to elements in examined arrays - */ - public static Matcher hasItemInArray(Matcher elementMatcher) { - return new IsArrayContaining(elementMatcher); - } - - /** - * A shortcut to the frequently used hasItemInArray(equalTo(x)). - * For example: - *
    assertThat(hasItemInArray(x))
    - * instead of: - *
    assertThat(hasItemInArray(equalTo(x)))
    - * - * @param element - * the element that should be present in examined arrays - */ - public static Matcher hasItemInArray(T element) { - Matcher matcher = equalTo(element); - return IsArrayContaining.hasItemInArray(matcher); - } -} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/package.html b/hamcrest-library/src/main/java/org/hamcrest/collection/package.html deleted file mode 100644 index 6248d8da3..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers of arrays and collections.

    - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/HamcrestLibraryIsDeprecated.java b/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/HamcrestLibraryIsDeprecated.java new file mode 100644 index 000000000..29d06fd98 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/HamcrestLibraryIsDeprecated.java @@ -0,0 +1,14 @@ +package org.hamcrest.library.deprecated; + +/** + * All the classes in hamcrest-library.jar have moved to + * hamcrest.jar. Please use that dependency instead. + */ +@Deprecated +class HamcrestLibraryIsDeprecated { + /** + * Unused + */ + private HamcrestLibraryIsDeprecated() { + } +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/package-info.java b/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/package-info.java new file mode 100644 index 000000000..c98f5aff1 --- /dev/null +++ b/hamcrest-library/src/main/java/org/hamcrest/library/deprecated/package-info.java @@ -0,0 +1,5 @@ +/** + * All classes in hamcrest-library.jar have been migrated to + * hamcrest.jar. Please use that dependency instead. + */ +package org.hamcrest.library.deprecated; \ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/package.html b/hamcrest-library/src/main/java/org/hamcrest/number/package.html deleted file mode 100644 index 2fbb07fd0..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/number/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers that perform numeric comparisons.

    - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/package.html b/hamcrest-library/src/main/java/org/hamcrest/object/package.html deleted file mode 100644 index 2fde62cea..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/object/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers that inspect objects and classes.

    - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java b/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java deleted file mode 100644 index f2b706c65..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringWhiteSpace.java +++ /dev/null @@ -1,79 +0,0 @@ -package org.hamcrest.text; - -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -import static java.lang.Character.isWhitespace; - -/** - * Tests if a string is equal to another string, ignoring any changes in whitespace. - */ -public class IsEqualIgnoringWhiteSpace extends TypeSafeMatcher { - - // TODO: Replace String with CharSequence to allow for easy interoperability 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; - } - - @Override - public boolean matchesSafely(String item) { - return stripSpace(string).equalsIgnoreCase(stripSpace(item)); - } - - @Override - public void describeMismatchSafely(String item, Description mismatchDescription) { - mismatchDescription.appendText("was ").appendText(stripSpace(item)); - } - - @Override - public void describeTo(Description description) { - description.appendText("equalToIgnoringWhiteSpace(") - .appendValue(string) - .appendText(")"); - } - - public String stripSpace(String toBeStripped) { - final StringBuilder result = new StringBuilder(); - boolean lastWasSpace = true; - for (int i = 0; i < toBeStripped.length(); i++) { - char c = toBeStripped.charAt(i); - if (isWhitespace(c)) { - if (!lastWasSpace) { - result.append(' '); - } - lastWasSpace = true; - } else { - result.append(c); - lastWasSpace = false; - } - } - return result.toString().trim(); - } - - /** - * Creates a matcher of {@link String} that matches when the examined string is equal to - * the specified expectedString, when whitespace differences are (mostly) ignored. To be - * exact, the following whitespace rules are applied: - *
      - *
    • all leading and trailing whitespace of both the expectedString and the examined string are ignored
    • - *
    • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
    • - *
    - * For example: - *
    assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
    - * - * @param expectedString - * the expected value of matched strings - */ - public static Matcher equalToIgnoringWhiteSpace(String expectedString) { - return new IsEqualIgnoringWhiteSpace(expectedString); - } - -} diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/package.html b/hamcrest-library/src/main/java/org/hamcrest/text/package.html deleted file mode 100644 index 8cf576f73..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/text/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers that perform text comparisons.

    - - diff --git a/hamcrest-library/src/main/java/org/hamcrest/xml/package.html b/hamcrest-library/src/main/java/org/hamcrest/xml/package.html deleted file mode 100644 index d9c5f97b9..000000000 --- a/hamcrest-library/src/main/java/org/hamcrest/xml/package.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - -

    Matchers of XML documents.

    - - diff --git a/hamcrest-library/src/main/resources/hamcrest-library-is-deprecated.txt b/hamcrest-library/src/main/resources/hamcrest-library-is-deprecated.txt new file mode 100644 index 000000000..038467d25 --- /dev/null +++ b/hamcrest-library/src/main/resources/hamcrest-library-is-deprecated.txt @@ -0,0 +1,5 @@ +Hamcrest Library +================ + +All the classes in hamcrest-core.jar and hamcrest-library.jar has moved +into hamcrest.jar. Please update your dependencies. \ No newline at end of file diff --git a/hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java b/hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java deleted file mode 100644 index eeaa11381..000000000 --- a/hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java +++ /dev/null @@ -1,139 +0,0 @@ -package org.hamcrest.beans; - -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.StringDescription; -import org.hamcrest.core.IsEqual; - -import java.beans.IntrospectionException; -import java.beans.PropertyDescriptor; -import java.beans.SimpleBeanInfo; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.beans.HasPropertyWithValue.hasProperty; -import static org.hamcrest.core.IsAnything.anything; -import static org.hamcrest.core.IsEqual.equalTo; - -/** - * @author Iain McGinniss - * @author Nat Pryce - * @author Steve Freeman - * @since 1.1.0 - */ -@SuppressWarnings("UnusedDeclaration") -public class HasPropertyWithValueTest extends AbstractMatcherTest { - private final BeanWithoutInfo shouldMatch = new BeanWithoutInfo("is expected"); - private final BeanWithoutInfo shouldNotMatch = new BeanWithoutInfo("not expected"); - - private final BeanWithInfo beanWithInfo = new BeanWithInfo("with info"); - - @Override - protected Matcher createMatcher() { - return hasProperty("irrelevant", anything()); - } - - public void testMatchesInfolessBeanWithMatchedNamedProperty() { - assertMatches("with property", hasProperty("property", equalTo("is expected")), shouldMatch); - assertMismatchDescription("property 'property' was \"not expected\"", - hasProperty("property", equalTo("is expected")), shouldNotMatch); - } - - public void testMatchesBeanWithInfoWithMatchedNamedProperty() { - assertMatches("with bean info", hasProperty("property", equalTo("with info")), beanWithInfo); - assertMismatchDescription("property 'property' was \"with info\"", - hasProperty("property", equalTo("without info")), beanWithInfo); - } - - public void testDoesNotMatchInfolessBeanWithoutMatchedNamedProperty() { - assertMismatchDescription("No property \"nonExistentProperty\"", - hasProperty("nonExistentProperty", anything()), shouldNotMatch); - } - - public void testDoesNotMatchWriteOnlyProperty() { - assertMismatchDescription("property \"writeOnlyProperty\" is not readable", - hasProperty("writeOnlyProperty", anything()), shouldNotMatch); - } - - public void testDescribeTo() { - assertDescription("hasProperty(\"property\", )", hasProperty("property", equalTo(true))); - } - - public void testMatchesPropertyAndValue() { - assertMatches("property with value", hasProperty( "property", anything()), beanWithInfo); - } - - public void testDoesNotWriteMismatchIfPropertyMatches() { - Description description = new StringDescription(); - hasProperty( "property", anything()).describeMismatch(beanWithInfo, description); - assertEquals("Expected mismatch description", "", description.toString()); - } - - public void testDescribesMissingPropertyMismatch() { - assertMismatchDescription("No property \"honk\"", hasProperty( "honk", anything()), shouldNotMatch); - } - - public void testCanAccessAnAnonymousInnerClass() { - class X implements IX { - @Override - public int getTest() { - return 1; - } - } - - assertThat(new X(), HasPropertyWithValue.hasProperty("test", IsEqual.equalTo(1))); - } - - interface IX { - int getTest(); - } - - public static class BeanWithoutInfo { - private String property; - - public BeanWithoutInfo(String property) { - this.property = property; - } - - public String getProperty() { - return property; - } - - public void setProperty(String property) { - this.property = property; - } - - public void setWriteOnlyProperty(@SuppressWarnings("unused") float property) { - } - - @Override - public String toString() { - return "[Person: " + property + "]"; - } - } - - public static class BeanWithInfo { - private final String propertyValue; - - public BeanWithInfo(String propertyValue) { - this.propertyValue = propertyValue; - } - - public String property() { - return propertyValue; - } - } - - public static class BeanWithInfoBeanInfo extends SimpleBeanInfo { - @Override - public PropertyDescriptor[] getPropertyDescriptors() { - try { - return new PropertyDescriptor[] { - new PropertyDescriptor("property", BeanWithInfo.class, "property", null) - }; - } catch (IntrospectionException e) { - throw new RuntimeException("Introspection exception: " + e.getMessage()); - } - } - } -} diff --git a/hamcrest-library/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java b/hamcrest-library/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java deleted file mode 100644 index 173457fe7..000000000 --- a/hamcrest-library/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java +++ /dev/null @@ -1,98 +0,0 @@ -package org.hamcrest.beans; - -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - -import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs; - -@SuppressWarnings("UnusedDeclaration") -public class SamePropertyValuesAsTest extends AbstractMatcherTest { - private static final Value aValue = new Value("expected"); - private static final ExampleBean expectedBean = new ExampleBean("same", 1, aValue); - private static final ExampleBean actualBean = new ExampleBean("same", 1, aValue); - - - @Override - protected Matcher createMatcher() { - return samePropertyValuesAs(expectedBean); - } - - public void testReportsMatchWhenAllPropertiesMatch() { - assertMatches("matched properties", samePropertyValuesAs(expectedBean), actualBean); - } - - public void testReportsMismatchWhenActualTypeIsNotAssignableToExpectedType() { - assertMismatchDescription("is incompatible type: ExampleBean", - samePropertyValuesAs((Object)aValue), actualBean); - } - - public void testReportsMismatchOnFirstPropertyDifference() { - assertMismatchDescription("string was \"different\"", - samePropertyValuesAs(expectedBean), new ExampleBean("different", 1, aValue)); - assertMismatchDescription("int was <2>", - samePropertyValuesAs(expectedBean), new ExampleBean("same", 2, aValue)); - assertMismatchDescription("value was ", - samePropertyValuesAs(expectedBean), new ExampleBean("same", 1, new Value("other"))); - } - - public void testMatchesBeansWithInheritanceButNoExtraProperties() { - assertMatches("sub type with same properties", - samePropertyValuesAs(expectedBean), new SubBeanWithNoExtraProperties("same", 1, aValue)); - } - - public void testRejectsSubTypeThatHasExtraProperties() { - assertMismatchDescription("has extra properties called [extra]", - samePropertyValuesAs(expectedBean), new SubBeanWithExtraProperty("same", 1, aValue)); - } - - public void testDescribesItself() { - assertDescription("same property values as ExampleBean [int: <1>, string: \"same\", value: ]", samePropertyValuesAs(expectedBean)); - } - - public static class Value { - public Value(Object value) { - this.value = value; - } - - public final Object value; - @Override - public String toString() { - return "Value " + value; - } - } - - public static class ExampleBean { - private String stringProperty; - private int intProperty; - private Value valueProperty; - - public ExampleBean(String stringProperty, int intProperty, Value valueProperty) { - this.stringProperty = stringProperty; - this.intProperty = intProperty; - this.valueProperty = valueProperty; - } - - public String getString() { - return stringProperty; - } - public int getInt() { - return intProperty; - } - public Value getValue() { - return valueProperty; - } - } - - public static class SubBeanWithNoExtraProperties extends ExampleBean { - public SubBeanWithNoExtraProperties(String stringProperty, int intProperty, Value valueProperty) { - super(stringProperty, intProperty, valueProperty); - } - } - - public static class SubBeanWithExtraProperty extends ExampleBean { - public SubBeanWithExtraProperty(String stringProperty, int intProperty, Value valueProperty) { - super(stringProperty, intProperty, valueProperty); - } - public String getExtra() { return "extra"; } - } -} diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingTest.java b/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingTest.java deleted file mode 100644 index 275984ce7..000000000 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package org.hamcrest.collection; - -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - -import static org.hamcrest.collection.IsArrayContaining.hasItemInArray; - -public class IsArrayContainingTest extends AbstractMatcherTest { - - @Override - protected Matcher createMatcher() { - return hasItemInArray("irrelevant"); - } - - public void testMatchesAnArrayThatContainsAnElementMatchingTheGivenMatcher() { - assertMatches("should matches array that contains 'a'", - hasItemInArray("a"), new String[]{"a", "b", "c"}); - } - - public void testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher() { - assertDoesNotMatch("should not matches array that doesn't contain 'a'", - hasItemInArray("a"), new String[]{"b", "c"}); - assertDoesNotMatch("should not matches empty array", - hasItemInArray("a"), new String[0]); - } - - public void testDoesNotMatchNull() { - assertDoesNotMatch("should not matches null", - hasItemInArray("a"), null); - } - - public void testHasAReadableDescription() { - assertDescription("an array containing \"a\"", hasItemInArray("a")); - } - - // Remaining code no longer compiles, thanks to generics. I think that's a good thing, but - // I still need to investigate how this behaves with code that doesn't use generics. - // I expect ClassCastExceptions will be thrown. - // -Joe. - -// public void testDoesNotMatchObjectThatIsNotAnArray() { -// assertDoesNotMatch("should not matches empty list", -// arrayContaining("a"), "not a collection"); -// } - -// public void testMatchesPrimitiveArrayElements() { -// assertMatches("boolean", arrayContaining(true), new boolean[]{true, false}); -// assertDoesNotMatch("boolean", arrayContaining(false), new boolean[]{false}); -// -// assertMatches("byte", arrayContaining((byte) 1), new byte[]{1, 2, 3}); -// assertDoesNotMatch("byte", arrayContaining((byte) 0), new byte[]{1, 2, 3}); -// -// assertMatches("char", arrayContaining('a'), new char[]{'a', 'b', 'c'}); -// assertDoesNotMatch("char", arrayContaining('z'), new char[]{'a', 'b', 'c'}); -// -// assertMatches("short", arrayContaining((short) 1), new short[]{1, 2, 3}); -// assertDoesNotMatch("short", arrayContaining((short) 0), new short[]{1, 2, 3}); -// -// assertMatches("int", arrayContaining(1), new int[]{1, 2, 3}); -// assertDoesNotMatch("int", arrayContaining(0), new int[]{1, 2, 3}); -// -// assertMatches("long", arrayContaining(1L), new long[]{1, 2, 3}); -// assertDoesNotMatch("long", arrayContaining(0L), new long[]{1, 2, 3}); -// -// assertMatches("float", arrayContaining(1f), new float[]{1f, 2f, 3f}); -// assertDoesNotMatch("float", arrayContaining(0f), new float[]{1f, 2f, 3f}); -// -// assertMatches("double", arrayContaining(1.0), new double[]{1.0, 2.0, 3.0}); -// assertDoesNotMatch("double", arrayContaining(0.0), new double[]{1.0, 2.0, 3.0}); -// } - -} diff --git a/hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringWhiteSpaceTest.java b/hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringWhiteSpaceTest.java deleted file mode 100644 index d5c7576b7..000000000 --- a/hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringWhiteSpaceTest.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.hamcrest.text; - -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.IsNot.not; -import static org.hamcrest.text.IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace; - -public class IsEqualIgnoringWhiteSpaceTest extends AbstractMatcherTest { - - private final Matcher matcher = equalToIgnoringWhiteSpace("Hello World how\n are we? "); - - @Override - protected Matcher createMatcher() { - return matcher; - } - - public void testPassesIfWordsAreSameButWhitespaceDiffers() { - assertThat("Hello World how are we?", matcher); - assertThat(" Hello World how are \n\n\twe?", matcher); - } - - public void testFailsIfTextOtherThanWhitespaceDiffers() { - assertThat("Hello PLANET how are we?", not(matcher)); - assertThat("Hello World how are we", not(matcher)); - } - - public void testFailsIfWhitespaceIsAddedOrRemovedInMidWord() { - assertThat("HelloWorld how are we?", not(matcher)); - assertThat("Hello Wo rld how are we?", not(matcher)); - } - - public void testFailsIfMatchingAgainstNull() { - assertThat(null, not(matcher)); - } - - public void testRequiresNonNullStringToBeConstructed() { - try { - new IsEqualIgnoringWhiteSpace(null); - fail("Expected exception"); - } catch (IllegalArgumentException goodException) { - // expected! - } - } - - public void testHasAReadableDescription() { - assertDescription("equalToIgnoringWhiteSpace(\"Hello World how\\n are we? \")", - matcher); - } -} diff --git a/hamcrest-library/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java b/hamcrest-library/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java deleted file mode 100644 index 8ffbc6767..000000000 --- a/hamcrest-library/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java +++ /dev/null @@ -1,30 +0,0 @@ -package org.hamcrest.text; - -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - -import static java.util.Arrays.asList; - - -public class StringContainsInOrderTest extends AbstractMatcherTest { - StringContainsInOrder m = new StringContainsInOrder(asList("a", "b", "c")); - - @Override - protected Matcher createMatcher() { - return m; - } - - public void testMatchesOnlyIfStringContainsGivenSubstringsInTheSameOrder() { - assertMatches("substrings in order", m, "abc"); - assertMatches("substrings separated", m, "1a2b3c4"); - - assertDoesNotMatch("substrings out of order", m, "cab"); - assertDoesNotMatch("no substrings in string", m, "xyz"); - assertDoesNotMatch("substring missing", m, "ac"); - assertDoesNotMatch("empty string", m, ""); - } - - public void testHasAReadableDescription() { - assertDescription("a string containing \"a\", \"b\", \"c\" in order", m); - } -} diff --git a/hamcrest/hamcrest.gradle b/hamcrest/hamcrest.gradle new file mode 100644 index 000000000..5259c441f --- /dev/null +++ b/hamcrest/hamcrest.gradle @@ -0,0 +1,39 @@ +plugins { + id 'biz.aQute.bnd.builder' version '6.4.0' +} + +version = rootProject.version + +dependencies { + testImplementation libs.junit.jupiter + testRuntimeOnly 'org.junit.platform:junit-platform-launcher' +} + +tasks.named("test") { + useJUnitPlatform() +} + +jar { + manifest { + attributes 'Implementation-Title': project.name, + 'Implementation-Vendor': 'hamcrest.org', + 'Implementation-Version': version, + 'Automatic-Module-Name': 'org.hamcrest' + } + bundle { + bnd 'Bundle-Name': 'org.hamcrest', + 'Bundle-SymbolicName': 'org.hamcrest', + 'Bundle-License': 'BSD-3-Clause', + 'Import-Package': 'javax.xml.namespace; resolution:=optional,' + + 'javax.xml.xpath;resolution:=optional,' + + 'org.w3c.dom;resolution:=optional,' + + '*', + '-exportcontents': 'org.hamcrest.*' + } +} + +javadoc { + title = "Hamcrest ${version} API" + exclude "org/hamcrest/internal/*" + options.overview = file("javadoc-overview.html") +} diff --git a/hamcrest/javadoc-overview.html b/hamcrest/javadoc-overview.html new file mode 100644 index 000000000..a9c2a6e81 --- /dev/null +++ b/hamcrest/javadoc-overview.html @@ -0,0 +1,31 @@ + + + + Hamcrest Overview + + +

    Matchers that can be combined to create flexible expressions of intent.

    +

    For example:

    +
    import org.junit.jupiter.api.Test;
    +import static org.hamcrest.MatcherAssert.assertThat;
    +import static org.hamcrest.Matchers.*;
    +
    +public class BiscuitTest {
    +  @Test
    +  public void testEquals() {
    +    Biscuit theBiscuit = new Biscuit("Ginger");
    +    Biscuit myBiscuit = new Biscuit("Ginger");
    +    assertThat(theBiscuit, equalTo(myBiscuit));
    +  }
    +}
    +
    + +

    For more information and documentation, see:

    + + + + + diff --git a/hamcrest-core/src/main/java/org/hamcrest/BaseDescription.java b/hamcrest/src/main/java/org/hamcrest/BaseDescription.java similarity index 84% rename from hamcrest-core/src/main/java/org/hamcrest/BaseDescription.java rename to hamcrest/src/main/java/org/hamcrest/BaseDescription.java index 6e62e696f..373992459 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/BaseDescription.java +++ b/hamcrest/src/main/java/org/hamcrest/BaseDescription.java @@ -13,18 +13,24 @@ */ public abstract class BaseDescription implements Description { + /** + * Default constructor + */ + public BaseDescription() { + } + @Override public Description appendText(String text) { append(text); return this; } - + @Override public Description appendDescriptionOf(SelfDescribing value) { value.describeTo(this); return this; } - + @Override public Description appendValue(Object value) { if (value == null) { @@ -35,6 +41,10 @@ public Description appendValue(Object value) { append('"'); toJavaSyntax((Character) value); append('"'); + } else if (value instanceof Byte) { + append('<'); + append(descriptionOf(value)); + append("b>"); } else if (value instanceof Short) { append('<'); append(descriptionOf(value)); @@ -66,20 +76,21 @@ private String descriptionOf(Object value) { } } + @SafeVarargs @Override - public Description appendValueList(String start, String separator, String end, T... values) { + public final Description appendValueList(String start, String separator, String end, T... values) { return appendValueList(start, separator, end, Arrays.asList(values)); } - + @Override public Description appendValueList(String start, String separator, String end, Iterable values) { return appendValueList(start, separator, end, values.iterator()); } - + private Description appendValueList(String start, String separator, String end, Iterator values) { - return appendList(start, separator, end, new SelfDescribingValueIterator(values)); + return appendList(start, separator, end, new SelfDescribingValueIterator<>(values)); } - + @Override public Description appendList(String start, String separator, String end, Iterable values) { return appendList(start, separator, end, values.iterator()); @@ -87,7 +98,7 @@ public Description appendList(String start, String separator, String end, Iterab private Description appendList(String start, String separator, String end, Iterator i) { boolean separate = false; - + append(start); while (i.hasNext()) { if (separate) append(separator); @@ -95,23 +106,29 @@ private Description appendList(String start, String separator, String end, Itera separate = true; } append(end); - + return this; } /** - * Append the String str to the description. - * The default implementation passes every character to {@link #append(char)}. + * Append the String str to the description. + * The default implementation passes every character to {@link #append(char)}. * Override in subclasses to provide an efficient implementation. + * + * @param str + * the string to append. */ protected void append(String str) { for (int i = 0; i < str.length(); i++) { append(str.charAt(i)); } } - + /** - * Append the char c to the description. + * Append the char c to the description. + * + * @param c + * the char to append. */ protected abstract void append(char c); @@ -137,8 +154,12 @@ private void toJavaSyntax(char ch) { case '\t': append("\\t"); break; + case '\\': + append("\\\\"); + break; default: append(ch); } } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/BaseMatcher.java b/hamcrest/src/main/java/org/hamcrest/BaseMatcher.java similarity index 53% rename from hamcrest-core/src/main/java/org/hamcrest/BaseMatcher.java rename to hamcrest/src/main/java/org/hamcrest/BaseMatcher.java index 484c101b3..9ae9ea5f4 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/BaseMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/BaseMatcher.java @@ -4,8 +4,14 @@ * BaseClass for all Matcher implementations. * * @see Matcher + * @param The Matcher type. */ public abstract class BaseMatcher implements Matcher { + /** + * Default constructor. + */ + public BaseMatcher() { + } /** * @see Matcher#_dont_implement_Matcher___instead_extend_BaseMatcher_() @@ -25,4 +31,19 @@ public void describeMismatch(Object item, Description description) { public String toString() { return StringDescription.toString(this); } + + /** + * Useful null-check method. Writes a mismatch description if the actual object is null + * @param actual the object to check + * @param mismatch where to write the mismatch description, if any + * @return false iff the actual object is null + */ + protected static boolean isNotNull(Object actual, Description mismatch) { + if (actual == null) { + mismatch.appendText("was null"); + return false; + } + return true; + } + } diff --git a/hamcrest/src/main/java/org/hamcrest/Condition.java b/hamcrest/src/main/java/org/hamcrest/Condition.java new file mode 100644 index 000000000..8518ec6ca --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/Condition.java @@ -0,0 +1,123 @@ +package org.hamcrest; + +/** + * A Condition implements part of a multi-step match. We sometimes need to write matchers + * that have a sequence of steps, where each step depends on the result of the previous + * step, and we can stop processing as soon as a step fails. These classes provide + * infrastructure for writing such a sequence. + * + *

    Based on Nat Pryce's maybe-java. + *

    + * + * @param the matched value type + * @author Steve Freeman 2012 http://www.hamcrest.com + */ +public abstract class Condition { + + /** + * Represents a single step in a multi-step sequence + * @param the initial value type + * @param the next step value type + */ + @FunctionalInterface + public interface Step { + /** + * Apply this condition to a value + * @param value the value to match + * @param mismatch the description for mismatches + * @return the next condition + */ + Condition apply(I value, Description mismatch); + } + + private Condition() { } + + /** + * Applies the matcher as the final step in the sequence + * @param match the value matcher + * @param message a description of the value + * @return true if the matcher matches the value, otherwise false + */ + public abstract boolean matching(Matcher match, String message); + + /** + * Applies the matcher as the final step in the sequence + * @param match the value matcher + * @return true if the matcher matches the value, otherwise false + */ + public final boolean matching(Matcher match) { return matching(match, ""); } + + /** + * Applies the mapping to the current value in the sequence + * @param mapping the current step in the sequence + * @return the condition for the next step in the sequence + * @param the type of the next value + */ + public abstract Condition and(Step mapping); + + /** + * An alias for {@link #and(Step)}, which applies the mapping to the current value in the + * sequence. + * @param mapping the current step in the sequence + * @return the condition for the next step in the sequence + * @param the type of the next value + */ + public final Condition then(Step mapping) { return and(mapping); } + + /** + * Called by steps when a mismatch occurs. + * @return a condition in the not matched state + * @param the type of the unmatched value + */ + @SuppressWarnings("unchecked") + public static Condition notMatched() { + return (Condition) NotMatched.NOT_MATCHED; + } + + /** + * Called by steps when a match occurs + * @param theValue the value that was matched + * @param mismatch a description for potential future mismatches + * @return the condition in a matched state + * @param the type of the matched value + */ + public static Condition matched(final T theValue, final Description mismatch) { + return new Matched<>(theValue, mismatch); + } + + private static final class Matched extends Condition { + private final T theValue; + private final Description mismatch; + + private Matched(T theValue, Description mismatch) { + this.theValue = theValue; + this.mismatch = mismatch; + } + + @Override + public boolean matching(Matcher matcher, String message) { + if (matcher.matches(theValue)) { + return true; + } + mismatch.appendText(message); + matcher.describeMismatch(theValue, mismatch); + return false; + } + + @Override + public Condition and(Step next) { + return next.apply(theValue, mismatch); + } + } + + private static final class NotMatched extends Condition { + public static final NotMatched NOT_MATCHED = new NotMatched<>(); + + @Override public boolean matching(Matcher match, String message) { return false; } + + @Override public Condition and(Step mapping) { + return notMatched(); + } + } + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/CoreMatchers.java b/hamcrest/src/main/java/org/hamcrest/CoreMatchers.java similarity index 77% rename from hamcrest-core/src/main/java/org/hamcrest/CoreMatchers.java rename to hamcrest/src/main/java/org/hamcrest/CoreMatchers.java index d690f7bfd..f00a6e549 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/CoreMatchers.java +++ b/hamcrest/src/main/java/org/hamcrest/CoreMatchers.java @@ -1,12 +1,34 @@ package org.hamcrest; +import org.hamcrest.core.IsIterableContaining; + +/** + * Builder methods for various matchers. + *

    + * CodeMatchers provides syntactic sugar for building matchers, or + * chains of matchers. By using static imports on these methods, concise and + * readable code calling the matchers can be maintained. + *

    + */ @SuppressWarnings("UnusedDeclaration") public class CoreMatchers { + /** + * Unused + */ + public CoreMatchers() { + } + /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(java.lang.Iterable> matchers) { return org.hamcrest.core.AllOf.allOf(matchers); @@ -16,17 +38,28 @@ public static org.hamcrest.Matcher allOf(java.lang.IterableALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. */ @SafeVarargs public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher... matchers) { return org.hamcrest.core.AllOf.allOf(matchers); } - /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. */ public static org.hamcrest.core.AnyOf anyOf(java.lang.Iterable> matchers) { return org.hamcrest.core.AnyOf.anyOf(matchers); @@ -36,6 +69,12 @@ public static org.hamcrest.core.AnyOf anyOf(java.lang.IterableANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. */ @SafeVarargs public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher... matchers) { @@ -46,6 +85,12 @@ public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.MatcherassertThat("fab", both(containsString("a")).and(containsString("b"))) + * + * @param + * the matcher type. + * @param matcher + * the matcher to combine, and both must pass. + * @return The matcher. */ public static org.hamcrest.core.CombinableMatcher.CombinableBothMatcher both(org.hamcrest.Matcher matcher) { return org.hamcrest.core.CombinableMatcher.both(matcher); @@ -55,6 +100,12 @@ public static org.hamcrest.core.CombinableMatcher.CombinableBothMatcherassertThat("fan", either(containsString("a")).or(containsString("b"))) + * + * @param + * the matcher type. + * @param matcher + * the matcher to combine, and either must pass. + * @return The matcher. */ public static org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher either(org.hamcrest.Matcher matcher) { return org.hamcrest.core.CombinableMatcher.either(matcher); @@ -65,13 +116,16 @@ public static org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher< * delegated to the decorated matcher, including its mismatch description. * For example: *
    describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
    - * + * + * @param + * the matcher type. * @param description * the new description for the wrapped matcher * @param matcher * the matcher to wrap * @param values - * optional values to insert into the tokenised description + * optional values to insert into the tokenized description + * @return The matcher. */ public static org.hamcrest.Matcher describedAs(java.lang.String description, org.hamcrest.Matcher matcher, java.lang.Object... values) { return org.hamcrest.core.DescribedAs.describedAs(description, matcher, values); @@ -83,9 +137,12 @@ public static org.hamcrest.Matcher describedAs(java.lang.String descripti * itemMatcher. * For example: *
    assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> everyItem(org.hamcrest.Matcher itemMatcher) { return org.hamcrest.core.Every.everyItem(itemMatcher); @@ -98,6 +155,12 @@ public static org.hamcrest.Matcher> everyIte *
    assertThat(cheese, is(equalTo(smelly)))
    * instead of: *
    assertThat(cheese, equalTo(smelly))
    + * + * @param + * the matcher type. + * @param matcher + * the matcher to wrap. + * @return The matcher. */ public static org.hamcrest.Matcher is(org.hamcrest.Matcher matcher) { return org.hamcrest.core.Is.is(matcher); @@ -109,6 +172,12 @@ public static org.hamcrest.Matcher is(org.hamcrest.Matcher matcher) { *
    assertThat(cheese, is(smelly))
    * instead of: *
    assertThat(cheese, is(equalTo(smelly)))
    + * + * @param + * the matcher type. + * @param value + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher is(T value) { return org.hamcrest.core.Is.is(value); @@ -120,6 +189,12 @@ public static org.hamcrest.Matcher is(T value) { *
    assertThat(cheese, isA(Cheddar.class))
    * instead of: *
    assertThat(cheese, is(instanceOf(Cheddar.class)))
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ public static org.hamcrest.Matcher isA(java.lang.Class type) { return org.hamcrest.core.Is.isA(type); @@ -127,6 +202,7 @@ public static org.hamcrest.Matcher isA(java.lang.Class type) { /** * Creates a matcher that always matches, regardless of the examined object. + * @return The matcher. */ public static org.hamcrest.Matcher anything() { return org.hamcrest.core.IsAnything.anything(); @@ -135,9 +211,10 @@ public static org.hamcrest.Matcher anything() { /** * Creates a matcher that always matches, regardless of the examined object, but describes * itself with the specified {@link String}. - * + * * @param description * a meaningful {@link String} used when describing itself + * @return The matcher. */ public static org.hamcrest.Matcher anything(java.lang.String description) { return org.hamcrest.core.IsAnything.anything(description); @@ -150,12 +227,15 @@ public static org.hamcrest.Matcher anything(java.lang.String d * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItem(org.hamcrest.Matcher itemMatcher) { - return org.hamcrest.core.IsCollectionContaining.hasItem(itemMatcher); + public static org.hamcrest.Matcher> hasItem(org.hamcrest.Matcher itemMatcher) { + return IsIterableContaining.hasItem(itemMatcher); } /** @@ -165,12 +245,15 @@ public static org.hamcrest.Matcher> hasItem(or * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
    - * + * + * @param + * the matcher type. * @param item * the item to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItem(T item) { - return org.hamcrest.core.IsCollectionContaining.hasItem(item); + public static org.hamcrest.Matcher> hasItem(T item) { + return IsIterableContaining.hasItem(item); } /** @@ -180,13 +263,16 @@ public static org.hamcrest.Matcher> hasItem(T * the examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ @SafeVarargs - public static org.hamcrest.Matcher> hasItems(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.core.IsCollectionContaining.hasItems(itemMatchers); + public static org.hamcrest.Matcher> hasItems(org.hamcrest.Matcher... itemMatchers) { + return IsIterableContaining.hasItems(itemMatchers); } /** @@ -196,35 +282,44 @@ public static org.hamcrest.Matcher> hasItems(org.hamcr * examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
    - * + * + * @param + * the matcher type. * @param items * the items to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ @SafeVarargs - public static org.hamcrest.Matcher> hasItems(T... items) { - return org.hamcrest.core.IsCollectionContaining.hasItems(items); + public static org.hamcrest.Matcher> hasItems(T... items) { + return IsIterableContaining.hasItems(items); } /** * Creates a matcher that matches when the examined object is logically equal to the specified * operand, as determined by calling the {@link java.lang.Object#equals} method on * the examined object. - * + * *

    If the specified operand is null then the created matcher will only match if * the examined object's equals method returns true when passed a * null (which would be a violation of the equals contract), unless the * examined object itself is null, in which case the matcher will return a positive * match.

    - * + * *

    The created matcher provides a special behaviour when examining Arrays, whereby * it will match if both the operand and the examined object are arrays of the same length and * contain items that are equal to each other (according to the above rules) in the same - * indexes.

    + * indexes.

    * For example: *
        * assertThat("foo", equalTo("foo"));
        * assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        * 
    + * + * @param + * the matcher type. + * @param operand + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher equalTo(T operand) { return org.hamcrest.core.IsEqual.equalTo(operand); @@ -233,6 +328,10 @@ public static org.hamcrest.Matcher equalTo(T operand) { /** * Creates an {@link org.hamcrest.core.IsEqual} matcher that does not enforce the values being * compared to be of the same static type. + * + * @param operand + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher equalToObject(java.lang.Object operand) { return org.hamcrest.core.IsEqual.equalToObject(operand); @@ -241,13 +340,19 @@ public static org.hamcrest.Matcher equalToObject(java.lang.Obj /** * Creates a matcher that matches when the examined object is an instance of the specified type, * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the - * the examined object. - * + * examined object. + * *

    The created matcher forces a relationship between specified type and the examined object, and should be * used when it is necessary to make generics conform, for example in the JMock clause * with(any(Thing.class))

    * For example: - *
    assertThat(new Canoe(), instanceOf(Canoe.class));
    + *
    assertThat(new Canoe(), any(Canoe.class));
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ public static org.hamcrest.Matcher any(java.lang.Class type) { return org.hamcrest.core.IsInstanceOf.any(type); @@ -257,10 +362,16 @@ public static org.hamcrest.Matcher any(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 {@link java.lang.Class#isInstance(Object)} method on that type, passing the * the examined object. - * + * *

    The created matcher assumes no relationship between specified type and the examined object.

    * For example: *
    assertThat(new Canoe(), instanceOf(Paddlable.class));
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ public static org.hamcrest.Matcher instanceOf(java.lang.Class type) { return org.hamcrest.core.IsInstanceOf.instanceOf(type); @@ -271,9 +382,12 @@ public static org.hamcrest.Matcher instanceOf(java.lang.Class type) { * it will match. * For example: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param matcher * the matcher whose sense should be inverted + * @return The matcher. */ public static org.hamcrest.Matcher not(org.hamcrest.Matcher matcher) { return org.hamcrest.core.IsNot.not(matcher); @@ -285,9 +399,12 @@ public static org.hamcrest.Matcher not(org.hamcrest.Matcher matcher) { *
    assertThat(cheese, is(not(smelly)))
    * instead of: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param value * the value that any examined object should not equal + * @return The matcher. */ public static org.hamcrest.Matcher not(T value) { return org.hamcrest.core.IsNot.not(value); @@ -299,6 +416,8 @@ public static org.hamcrest.Matcher not(T value) { *
    assertThat(cheese, is(notNullValue()))
    * instead of: *
    assertThat(cheese, is(not(nullValue())))
    + * + * @return The matcher. */ public static org.hamcrest.Matcher notNullValue() { return org.hamcrest.core.IsNull.notNullValue(); @@ -311,9 +430,12 @@ public static org.hamcrest.Matcher notNullValue() { *
    assertThat(cheese, is(notNullValue(X.class)))
    * instead of: *
    assertThat(cheese, is(not(nullValue(X.class))))
    - * + * + * @param + * the matcher type. * @param type * dummy parameter used to infer the generic type of the returned matcher + * @return The matcher. */ public static org.hamcrest.Matcher notNullValue(java.lang.Class type) { return org.hamcrest.core.IsNull.notNullValue(type); @@ -323,6 +445,8 @@ public static org.hamcrest.Matcher notNullValue(java.lang.Class type) * Creates a matcher that matches if examined object is null. * For example: *
    assertThat(cheese, is(nullValue())
    + * + * @return The matcher. */ public static org.hamcrest.Matcher nullValue() { return org.hamcrest.core.IsNull.nullValue(); @@ -333,9 +457,12 @@ public static org.hamcrest.Matcher nullValue() { * single dummy argument to facilitate type inference. * For example: *
    assertThat(cheese, is(nullValue(Cheese.class))
    - * + * + * @param + * the matcher type. * @param type * dummy parameter used to infer the generic type of the returned matcher + * @return The matcher. */ public static org.hamcrest.Matcher nullValue(java.lang.Class type) { return org.hamcrest.core.IsNull.nullValue(type); @@ -344,9 +471,12 @@ public static org.hamcrest.Matcher nullValue(java.lang.Class type) { /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. - * + * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static org.hamcrest.Matcher sameInstance(T target) { return org.hamcrest.core.IsSame.sameInstance(target); @@ -355,9 +485,12 @@ public static org.hamcrest.Matcher sameInstance(T target) { /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. - * + * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static org.hamcrest.Matcher theInstance(T target) { return org.hamcrest.core.IsSame.theInstance(target); @@ -368,11 +501,12 @@ public static org.hamcrest.Matcher theInstance(T target) { * {@link String} anywhere. * For example: *
    assertThat("myStringOfNote", containsString("ring"))
    - * + * * @param substring * the substring that the returned matcher will expect to find within any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher containsString(java.lang.String substring) { + public static Matcher containsString(java.lang.String substring) { return org.hamcrest.core.StringContains.containsString(substring); } @@ -380,12 +514,13 @@ public static org.hamcrest.Matcher containsString(java.lang.St * Creates a matcher that matches if the examined {@link String} contains the specified * {@link String} anywhere, ignoring case. * For example: - *
    assertThat("myStringOfNote", containsString("ring"))
    - * + *
    assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
    + * * @param substring * the substring that the returned matcher will expect to find within any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher containsStringIgnoringCase(java.lang.String substring) { + public static Matcher containsStringIgnoringCase(java.lang.String substring) { return org.hamcrest.core.StringContains.containsStringIgnoringCase(substring); } @@ -396,11 +531,12 @@ public static org.hamcrest.Matcher containsStringIgnoringCase( *

    * For example: *
    assertThat("myStringOfNote", startsWith("my"))
    - * + * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher startsWith(java.lang.String prefix) { + public static Matcher startsWith(java.lang.String prefix) { return org.hamcrest.core.StringStartsWith.startsWith(prefix); } @@ -410,12 +546,13 @@ public static org.hamcrest.Matcher startsWith(java.lang.String * {@link String}, ignoring case *

    * For example: - *
    assertThat("myStringOfNote", startsWith("my"))
    - * + *
    assertThat("myStringOfNote", startsWithIgnoringCase("My"))
    + * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher startsWithIgnoringCase(java.lang.String prefix) { + public static Matcher startsWithIgnoringCase(java.lang.String prefix) { return org.hamcrest.core.StringStartsWith.startsWithIgnoringCase(prefix); } @@ -424,11 +561,12 @@ public static org.hamcrest.Matcher startsWithIgnoringCase(java * {@link String}. * For example: *
    assertThat("myStringOfNote", endsWith("Note"))
    - * + * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher endsWith(java.lang.String suffix) { + public static Matcher endsWith(java.lang.String suffix) { return org.hamcrest.core.StringEndsWith.endsWith(suffix); } @@ -436,12 +574,13 @@ public static org.hamcrest.Matcher endsWith(java.lang.String s * Creates a matcher that matches if the examined {@link String} ends with the specified * {@link String}, ignoring case. * For example: - *
    assertThat("myStringOfNote", endsWith("Note"))
    - * + *
    assertThat("myStringOfNote", endsWithIgnoringCase("note"))
    + * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher endsWithIgnoringCase(java.lang.String suffix) { + public static Matcher endsWithIgnoringCase(java.lang.String suffix) { return org.hamcrest.core.StringEndsWith.endsWithIgnoringCase(suffix); } diff --git a/hamcrest-core/src/main/java/org/hamcrest/CustomMatcher.java b/hamcrest/src/main/java/org/hamcrest/CustomMatcher.java similarity index 81% rename from hamcrest-core/src/main/java/org/hamcrest/CustomMatcher.java rename to hamcrest/src/main/java/org/hamcrest/CustomMatcher.java index 036a76402..0a63c8b27 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/CustomMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/CustomMatcher.java @@ -13,16 +13,21 @@ *

    * This class is designed for scenarios where an anonymous inner class * matcher makes sense. It should not be used by API designers implementing - * matchers. + * matchers. See {@link CustomTypeSafeMatcher} for a type safe variant of + * this class that you probably want to use. * * @author Neil Dunn - * @see CustomTypeSafeMatcher for a type safe variant of this class that you probably - * want to use. * @param The type of object being matched. + * @see CustomTypeSafeMatcher */ public abstract class CustomMatcher extends BaseMatcher { + private final String fixedDescription; + /** + * Constructor + * @param description the description of this matcher + */ public CustomMatcher(String description) { if (description == null) { throw new IllegalArgumentException("Description should be non null!"); @@ -34,4 +39,5 @@ public CustomMatcher(String description) { public final void describeTo(Description description) { description.appendText(fixedDescription); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java b/hamcrest/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java similarity index 81% rename from hamcrest-core/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java rename to hamcrest/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java index 7c5c46ce6..3aff0d2e0 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/CustomTypeSafeMatcher.java @@ -1,8 +1,7 @@ package org.hamcrest; - /** - * Utility class for writing one off matchers. + * Utility class for writing one off matchers (with type safety and null checks). * For example: *

      * Matcher<String> aNonEmptyString = new CustomTypeSafeMatcher<String>("a non empty string") {
    @@ -16,15 +15,19 @@
      * 
    * This is a variant of {@link CustomMatcher} that first type checks * the argument being matched. By the time {@link TypeSafeMatcher#matchesSafely} is - * is called the argument is guaranteed to be non-null and of the correct - * type. + * called the argument is guaranteed to be non-null and of the correct type. * * @author Neil Dunn * @param The type of object being matched */ public abstract class CustomTypeSafeMatcher extends TypeSafeMatcher { + private final String fixedDescription; + /** + * Constructor + * @param description the description of this matcher + */ public CustomTypeSafeMatcher(String description) { if (description == null) { throw new IllegalArgumentException("Description must be non null!"); @@ -36,4 +39,5 @@ public CustomTypeSafeMatcher(String description) { public final void describeTo(Description description) { description.appendText(fixedDescription); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/Description.java b/hamcrest/src/main/java/org/hamcrest/Description.java new file mode 100644 index 000000000..31031742d --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/Description.java @@ -0,0 +1,129 @@ +package org.hamcrest; + +/** + * A description of a Matcher. A Matcher will describe itself to a description + * which can later be used for reporting. + * + * @see Matcher#describeTo(Description) + */ +public interface Description { + + /** + * A description that consumes input but does nothing, implemented by + * {@link NullDescription}. + */ + Description NONE = new NullDescription(); + + /** + * Appends some plain text to the description. + * + * @param text the text to append. + * @return the update description when displaying the matcher error. + */ + Description appendText(String text); + + /** + * Appends the description of a {@link SelfDescribing} value to this description. + * + * @param value the value to append. + * @return the update description when displaying the matcher error. + */ + Description appendDescriptionOf(SelfDescribing value); + + /** + * Appends an arbitrary value to the description. + * + * @param value the object to append. + * @return the update description when displaying the matcher error. + */ + Description appendValue(Object value); + + /** + * Appends a list of values to the description. + * + * @param the description type. + * @param start the prefix. + * @param separator the separator. + * @param end the suffix. + * @param values the values to append. + * @return the update description when displaying the matcher error. + */ + Description appendValueList(String start, String separator, String end, + T... values); + + /** + * Appends a list of values to the description. + * + * @param the description type. + * @param start the prefix. + * @param separator the separator. + * @param end the suffix. + * @param values the values to append. + * @return the update description when displaying the matcher error. + */ + Description appendValueList(String start, String separator, String end, + Iterable values); + + /** + * Appends a list of {@link org.hamcrest.SelfDescribing} objects + * to the description. + * + * @param start the prefix. + * @param separator the separator. + * @param end the suffix. + * @param values the values to append. + * @return the update description when displaying the matcher error. + */ + Description appendList(String start, String separator, String end, + Iterable values); + + /** + * A description that consumes input but does nothing. + */ + final class NullDescription implements Description { + /** + * Constructor. + */ + public NullDescription() { + } + + @Override + public Description appendDescriptionOf(SelfDescribing value) { + return this; + } + + @Override + public Description appendList(String start, String separator, + String end, Iterable values) { + return this; + } + + @Override + public Description appendText(String text) { + return this; + } + + @Override + public Description appendValue(Object value) { + return this; + } + + @Override + public Description appendValueList(String start, String separator, + String end, T... values) { + return this; + } + + @Override + public Description appendValueList(String start, String separator, + String end, Iterable values) { + return this; + } + + @Override + public String toString() { + return ""; + } + } + +} diff --git a/hamcrest/src/main/java/org/hamcrest/DiagnosingMatcher.java b/hamcrest/src/main/java/org/hamcrest/DiagnosingMatcher.java new file mode 100644 index 000000000..44a36c486 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/DiagnosingMatcher.java @@ -0,0 +1,41 @@ +package org.hamcrest; + +/** + * Convenient base class for Matchers of a specific type and that will report why the + * received value has been rejected. + * + * Unlike the {@link TypeSafeDiagnosingMatcher}, this does not implement the null check + * or validate the type, so subclasses need to be prepared to handle these conditions. + * + * To use, implement {@link #matches(Object, Description)} + * + * @param the type of matcher being diagnosed. + * @see TypeSafeDiagnosingMatcher + */ +public abstract class DiagnosingMatcher extends BaseMatcher { + + /** + * Constructor + */ + public DiagnosingMatcher() { + } + + @Override + public final boolean matches(Object item) { + return matches(item, Description.NONE); + } + + @Override + public final void describeMismatch(Object item, Description mismatchDescription) { + matches(item, mismatchDescription); + } + + /** + * Evaluates the matcher for argument item. + * @param item the value to check + * @param mismatchDescription the description for the matcher + * @return true if item matches, otherwise false. + */ + protected abstract boolean matches(Object item, Description mismatchDescription); + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/FeatureMatcher.java b/hamcrest/src/main/java/org/hamcrest/FeatureMatcher.java similarity index 93% rename from hamcrest-core/src/main/java/org/hamcrest/FeatureMatcher.java rename to hamcrest/src/main/java/org/hamcrest/FeatureMatcher.java index 385cf9995..5c7511cea 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/FeatureMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/FeatureMatcher.java @@ -4,17 +4,18 @@ /** * Supporting class for matching a feature of an object. Implement featureValueOf() - * in a subclass to pull out the feature to be matched against. + * in a subclass to pull out the feature to be matched against. * * @param The type of the object to be matched * @param The type of the feature to be matched */ public abstract class FeatureMatcher extends TypeSafeDiagnosingMatcher { - private static final ReflectiveTypeFinder TYPE_FINDER = new ReflectiveTypeFinder("featureValueOf", 1, 0); + + private static final ReflectiveTypeFinder TYPE_FINDER = new ReflectiveTypeFinder("featureValueOf", 1, 0); private final Matcher subMatcher; private final String featureDescription; private final String featureName; - + /** * Constructor * @param subMatcher The matcher to apply to the feature @@ -27,7 +28,7 @@ public FeatureMatcher(Matcher subMatcher, String featureDescription, this.featureDescription = featureDescription; this.featureName = featureName; } - + /** * Implement this to extract the interesting feature. * @param actual the target object @@ -45,10 +46,11 @@ protected boolean matchesSafely(T actual, Description mismatch) { } return true; } - + @Override public final void describeTo(Description description) { description.appendText(featureDescription).appendText(" ") .appendDescriptionOf(subMatcher); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/Matcher.java b/hamcrest/src/main/java/org/hamcrest/Matcher.java similarity index 72% rename from hamcrest-core/src/main/java/org/hamcrest/Matcher.java rename to hamcrest/src/main/java/org/hamcrest/Matcher.java index 3ac1a53ca..697009369 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/Matcher.java +++ b/hamcrest/src/main/java/org/hamcrest/Matcher.java @@ -12,9 +12,16 @@ * new features and remain compatible with all Matcher implementations. *

    *

    + * When using Hamcrest, there is no guarantee as to how often matches() or + * describeMismatch() will be called, so the objects passed as + * actual arguments should not change when referenced. If you're testing a + * stream, a good practice is to collect the contents of the stream before matching. + *

    + *

    * N.B. Well designed matchers should be immutable. *

    * + * @param the matched value type * @see BaseMatcher */ public interface Matcher extends SelfDescribing { @@ -27,25 +34,25 @@ public interface Matcher extends SelfDescribing { * (because of type erasure with Java generics). It is down to the implementations * to check the correct type. * - * @param item the object against which the matcher is evaluated. + * @param actual the object against which the matcher is evaluated. * @return true if item matches, otherwise false. * * @see BaseMatcher */ - boolean matches(Object item); - + boolean matches(Object actual); + /** * Generate a description of why the matcher has not accepted the item. * The description will be part of a larger description of why a matching - * failed, so it should be concise. - * This method assumes that matches(item) is false, but + * failed, so it should be concise. + * This method assumes that matches(item) is false, but * will not check this. * - * @param item The item that the Matcher has rejected. + * @param actual The item that the Matcher has rejected. * @param mismatchDescription * The description to be built or appended to. */ - void describeMismatch(Object item, Description mismatchDescription); + void describeMismatch(Object actual, Description mismatchDescription); /** * This method simply acts a friendly reminder not to implement Matcher directly and @@ -58,4 +65,5 @@ public interface Matcher extends SelfDescribing { */ @Deprecated void _dont_implement_Matcher___instead_extend_BaseMatcher_(); + } diff --git a/hamcrest/src/main/java/org/hamcrest/MatcherAssert.java b/hamcrest/src/main/java/org/hamcrest/MatcherAssert.java new file mode 100644 index 000000000..29d3364e2 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/MatcherAssert.java @@ -0,0 +1,58 @@ +package org.hamcrest; + +/** + * The Hamcrest entrypoint, static methods to check if matchers match a + * given value. + */ +public class MatcherAssert { + + /** + * Unused. + */ + public MatcherAssert() { + } + + /** + * Checks that a value matches a matcher + * @param actual the value to check + * @param matcher the matcher + * @param the type of the value + */ + public static void assertThat(T actual, Matcher matcher) { + assertThat("", actual, matcher); + } + + /** + * Checks that a value matches a matcher + * @param reason a description of what is being matched + * @param actual the value to check + * @param matcher the matcher + * @param the type of the value + */ + public static void assertThat(String reason, T actual, Matcher matcher) { + if (!matcher.matches(actual)) { + Description description = new StringDescription(); + description.appendText(reason) + .appendText(System.lineSeparator()) + .appendText("Expected: ") + .appendDescriptionOf(matcher) + .appendText(System.lineSeparator()) + .appendText(" but: "); + matcher.describeMismatch(actual, description); + + throw new AssertionError(description.toString()); + } + } + + /** + * Checks that an assertion is true + * @param reason a description of what is being checked + * @param assertion the result of the check + */ + public static void assertThat(String reason, boolean assertion) { + if (!assertion) { + throw new AssertionError(reason); + } + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/Matchers.java b/hamcrest/src/main/java/org/hamcrest/Matchers.java similarity index 67% rename from hamcrest-library/src/main/java/org/hamcrest/Matchers.java rename to hamcrest/src/main/java/org/hamcrest/Matchers.java index 691d15fce..60d8256a4 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/Matchers.java +++ b/hamcrest/src/main/java/org/hamcrest/Matchers.java @@ -1,149 +1,333 @@ package org.hamcrest; +import org.hamcrest.collection.ArrayMatching; +import org.hamcrest.core.IsIterableContaining; +import org.hamcrest.core.StringRegularExpression; +import org.hamcrest.exception.ThrowsException; +import org.hamcrest.optional.OptionalEmpty; +import org.hamcrest.optional.OptionalWithValue; +import org.hamcrest.text.IsEqualCompressingWhiteSpace; + +import java.util.Optional; +import java.util.regex.Pattern; + +/** + * Builder methods for various matchers. + *

    + * Matchers provides syntactic sugar for building matchers, or + * chains of matchers. By using static imports on these methods, concise and + * readable code calling the matchers can be maintained. + *

    + */ +@SuppressWarnings({"unused", "WeakerAccess"}) public class Matchers { + /** + * Unused + */ + public Matchers() { + } + /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(java.lang.Iterable> matchers) { - return org.hamcrest.core.AllOf.allOf(matchers); + return org.hamcrest.core.AllOf.allOf(matchers); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    - */ + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. + */ + @SafeVarargs public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher... matchers) { - return org.hamcrest.core.AllOf.allOf(matchers); + return org.hamcrest.core.AllOf.allOf(matchers); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher that must pass. + * @param second + * second matcher that must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second) { - return org.hamcrest.core.AllOf.allOf(first, second); + return org.hamcrest.core.AllOf.allOf(first, second); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher that must pass. + * @param second + * second matcher that must pass. + * @param third + * third matcher that must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third) { - return org.hamcrest.core.AllOf.allOf(first, second, third); + return org.hamcrest.core.AllOf.allOf(first, second, third); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher that must pass. + * @param second + * second matcher that must pass. + * @param third + * third matcher that must pass. + * @param fourth + * fourth matcher that must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth) { - return org.hamcrest.core.AllOf.allOf(first, second, third, fourth); + return org.hamcrest.core.AllOf.allOf(first, second, third, fourth); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher that must pass. + * @param second + * second matcher that must pass. + * @param third + * third matcher that must pass. + * @param fourth + * fourth matcher that must pass. + * @param fifth + * fifth matcher that must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth) { - return org.hamcrest.core.AllOf.allOf(first, second, third, fourth, fifth); + return org.hamcrest.core.AllOf.allOf(first, second, third, fourth, fifth); } /** * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher that must pass. + * @param second + * second matcher that must pass. + * @param third + * third matcher that must pass. + * @param fourth + * fourth matcher that must pass. + * @param fifth + * fifth matcher that must pass. + * @param sixth + * sixth matcher that must pass. + * @return The matcher. */ public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth, org.hamcrest.Matcher sixth) { - return org.hamcrest.core.AllOf.allOf(first, second, third, fourth, fifth, sixth); + return org.hamcrest.core.AllOf.allOf(first, second, third, fourth, fifth, sixth); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. */ public static org.hamcrest.core.AnyOf anyOf(java.lang.Iterable> matchers) { - return org.hamcrest.core.AnyOf.anyOf(matchers); + return org.hamcrest.core.AnyOf.anyOf(matchers); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    - */ + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. + */ + @SafeVarargs public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher... matchers) { - return org.hamcrest.core.AnyOf.anyOf(matchers); + return org.hamcrest.core.AnyOf.anyOf(matchers); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher to check. + * @param second + * second matcher to check. + * @return The matcher. */ - public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second) { - return org.hamcrest.core.AnyOf.anyOf(first, second); + public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second) { + return org.hamcrest.core.AnyOf.anyOf(first, second); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher to check. + * @param second + * second matcher to check. + * @param third + * third matcher to check. + * @return The matcher. */ - public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third) { - return org.hamcrest.core.AnyOf.anyOf(first, second, third); + public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third) { + return org.hamcrest.core.AnyOf.anyOf(first, second, third); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param first + * first matcher to check. + * @param second + * second matcher to check. + * @param third + * third matcher to check. + * @param fourth + * fourth matcher to check. + * @return The matcher. */ - public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth) { - return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth); + public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth) { + return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    - */ - public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth) { - return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth, fifth); + * + * @param + * the matcher type. + * @param first + * first matcher to check. + * @param second + * second matcher to check. + * @param third + * third matcher to check. + * @param fourth + * fourth matcher to check. + * @param fifth + * fifth matcher to check. + * @return The matcher. + */ + public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth) { + return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth, fifth); } /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    - */ - public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth, org.hamcrest.Matcher sixth) { - return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth, fifth, sixth); + * + * @param + * the matcher type. + * @param first + * first matcher to check. + * @param second + * second matcher to check. + * @param third + * third matcher to check. + * @param fourth + * fourth matcher to check. + * @param fifth + * fifth matcher to check. + * @param sixth + * sixth matcher to check. + * @return The matcher. + */ + public static org.hamcrest.core.AnyOf anyOf(org.hamcrest.Matcher first, org.hamcrest.Matcher second, org.hamcrest.Matcher third, org.hamcrest.Matcher fourth, org.hamcrest.Matcher fifth, org.hamcrest.Matcher sixth) { + return org.hamcrest.core.AnyOf.anyOf(first, second, third, fourth, fifth, sixth); } /** * Creates a matcher that matches when both of the specified matchers match the examined object. * For example: *
    assertThat("fab", both(containsString("a")).and(containsString("b")))
    + * + * @param + * the matcher type. + * @param matcher + * the matcher to combine, and both must pass. + * @return The matcher. */ public static org.hamcrest.core.CombinableMatcher.CombinableBothMatcher both(org.hamcrest.Matcher matcher) { - return org.hamcrest.core.CombinableMatcher.both(matcher); + return org.hamcrest.core.CombinableMatcher.both(matcher); } /** * Creates a matcher that matches when either of the specified matchers match the examined object. * For example: *
    assertThat("fan", either(containsString("a")).or(containsString("b")))
    + * + * @param + * the matcher type. + * @param matcher + * the matcher to combine, and either must pass. + * @return The matcher. */ public static org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher either(org.hamcrest.Matcher matcher) { - return org.hamcrest.core.CombinableMatcher.either(matcher); + return org.hamcrest.core.CombinableMatcher.either(matcher); } /** @@ -151,16 +335,19 @@ public static org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher< * delegated to the decorated matcher, including its mismatch description. * For example: *
    describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
    - * + * + * @param + * the matcher type. * @param description * the new description for the wrapped matcher * @param matcher * the matcher to wrap * @param values - * optional values to insert into the tokenised description + * optional values to insert into the tokenized description + * @return The matcher. */ public static org.hamcrest.Matcher describedAs(java.lang.String description, org.hamcrest.Matcher matcher, java.lang.Object... values) { - return org.hamcrest.core.DescribedAs.describedAs(description, matcher, values); + return org.hamcrest.core.DescribedAs.describedAs(description, matcher, values); } /** @@ -169,12 +356,15 @@ public static org.hamcrest.Matcher describedAs(java.lang.String descripti * itemMatcher. * For example: *
    assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> everyItem(org.hamcrest.Matcher itemMatcher) { - return org.hamcrest.core.Every.everyItem(itemMatcher); + return org.hamcrest.core.Every.everyItem(itemMatcher); } /** @@ -184,9 +374,15 @@ public static org.hamcrest.Matcher> everyIte *
    assertThat(cheese, is(equalTo(smelly)))
    * instead of: *
    assertThat(cheese, equalTo(smelly))
    + * + * @param + * the matcher type. + * @param matcher + * the matcher to wrap. + * @return The matcher. */ public static org.hamcrest.Matcher is(org.hamcrest.Matcher matcher) { - return org.hamcrest.core.Is.is(matcher); + return org.hamcrest.core.Is.is(matcher); } /** @@ -195,9 +391,15 @@ public static org.hamcrest.Matcher is(org.hamcrest.Matcher matcher) { *
    assertThat(cheese, is(smelly))
    * instead of: *
    assertThat(cheese, is(equalTo(smelly)))
    + * + * @param + * the matcher type. + * @param value + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher is(T value) { - return org.hamcrest.core.Is.is(value); + return org.hamcrest.core.Is.is(value); } /** @@ -206,13 +408,20 @@ public static org.hamcrest.Matcher is(T value) { *
    assertThat(cheese, isA(Cheddar.class))
    * instead of: *
    assertThat(cheese, is(instanceOf(Cheddar.class)))
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ - public static org.hamcrest.Matcher isA(java.lang.Class type) { - return org.hamcrest.core.Is.isA(type); + public static org.hamcrest.Matcher isA(java.lang.Class type) { + return org.hamcrest.core.Is.isA(type); } /** * Creates a matcher that always matches, regardless of the examined object. + * @return The matcher. */ public static org.hamcrest.Matcher anything() { return org.hamcrest.core.IsAnything.anything(); @@ -221,9 +430,10 @@ public static org.hamcrest.Matcher anything() { /** * Creates a matcher that always matches, regardless of the examined object, but describes * itself with the specified {@link String}. - * + * * @param description * a meaningful {@link String} used when describing itself + * @return The matcher. */ public static org.hamcrest.Matcher anything(java.lang.String description) { return org.hamcrest.core.IsAnything.anything(description); @@ -236,12 +446,15 @@ public static org.hamcrest.Matcher anything(java.lang.String d * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItem(org.hamcrest.Matcher itemMatcher) { - return org.hamcrest.core.IsCollectionContaining.hasItem(itemMatcher); + public static org.hamcrest.Matcher> hasItem(org.hamcrest.Matcher itemMatcher) { + return IsIterableContaining.hasItem(itemMatcher); } /** @@ -251,12 +464,15 @@ public static org.hamcrest.Matcher> hasItem(or * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
    - * + * + * @param + * the matcher type. * @param item * the item to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItem(T item) { - return org.hamcrest.core.IsCollectionContaining.hasItem(item); + public static org.hamcrest.Matcher> hasItem(T item) { + return IsIterableContaining.hasItem(item); } /** @@ -266,12 +482,16 @@ public static org.hamcrest.Matcher> hasItem(T * the examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItems(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.core.IsCollectionContaining.hasItems(itemMatchers); + @SafeVarargs + public static org.hamcrest.Matcher> hasItems(org.hamcrest.Matcher... itemMatchers) { + return IsIterableContaining.hasItems(itemMatchers); } /** @@ -281,42 +501,56 @@ public static org.hamcrest.Matcher> hasItems(org.hamcr * examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
    - * + * + * @param + * the matcher type. * @param items * the items to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ - public static org.hamcrest.Matcher> hasItems(T... items) { - return org.hamcrest.core.IsCollectionContaining.hasItems(items); + @SafeVarargs + public static org.hamcrest.Matcher> hasItems(T... items) { + return IsIterableContaining.hasItems(items); } /** * Creates a matcher that matches when the examined object is logically equal to the specified * operand, as determined by calling the {@link java.lang.Object#equals} method on * the examined object. - * + * *

    If the specified operand is null then the created matcher will only match if * the examined object's equals method returns true when passed a * null (which would be a violation of the equals contract), unless the * examined object itself is null, in which case the matcher will return a positive * match.

    - * + * *

    The created matcher provides a special behaviour when examining Arrays, whereby * it will match if both the operand and the examined object are arrays of the same length and * contain items that are equal to each other (according to the above rules) in the same - * indexes.

    + * indexes.

    * For example: *
        * assertThat("foo", equalTo("foo"));
        * assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
        * 
    + * + * @param + * the matcher type. + * @param operand + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher equalTo(T operand) { - return org.hamcrest.core.IsEqual.equalTo(operand); + return org.hamcrest.core.IsEqual.equalTo(operand); } /** * Creates an {@link org.hamcrest.core.IsEqual} matcher that does not enforce the values being * compared to be of the same static type. + * + * @param operand + * the value to check. + * @return The matcher. */ public static org.hamcrest.Matcher equalToObject(java.lang.Object operand) { return org.hamcrest.core.IsEqual.equalToObject(operand); @@ -325,29 +559,41 @@ public static org.hamcrest.Matcher equalToObject(java.lang.Obj /** * Creates a matcher that matches when the examined object is an instance of the specified type, * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the - * the examined object. - * + * examined object. + * *

    The created matcher forces a relationship between specified type and the examined object, and should be * used when it is necessary to make generics conform, for example in the JMock clause * with(any(Thing.class))

    * For example: *
    assertThat(new Canoe(), instanceOf(Canoe.class));
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ public static org.hamcrest.Matcher any(java.lang.Class type) { - return org.hamcrest.core.IsInstanceOf.any(type); + return org.hamcrest.core.IsInstanceOf.any(type); } /** * Creates a matcher that matches when the examined object is an instance of the specified type, * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the * the examined object. - * + * *

    The created matcher assumes no relationship between specified type and the examined object.

    * For example: *
    assertThat(new Canoe(), instanceOf(Paddlable.class));
    + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ public static org.hamcrest.Matcher instanceOf(java.lang.Class type) { - return org.hamcrest.core.IsInstanceOf.instanceOf(type); + return org.hamcrest.core.IsInstanceOf.instanceOf(type); } /** @@ -355,12 +601,15 @@ public static org.hamcrest.Matcher instanceOf(java.lang.Class type) { * it will match. * For example: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param matcher * the matcher whose sense should be inverted + * @return The matcher. */ public static org.hamcrest.Matcher not(org.hamcrest.Matcher matcher) { - return org.hamcrest.core.IsNot.not(matcher); + return org.hamcrest.core.IsNot.not(matcher); } /** @@ -369,12 +618,15 @@ public static org.hamcrest.Matcher not(org.hamcrest.Matcher matcher) { *
    assertThat(cheese, is(not(smelly)))
    * instead of: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param value * the value that any examined object should not equal + * @return The matcher. */ public static org.hamcrest.Matcher not(T value) { - return org.hamcrest.core.IsNot.not(value); + return org.hamcrest.core.IsNot.not(value); } /** @@ -383,6 +635,8 @@ public static org.hamcrest.Matcher not(T value) { *
    assertThat(cheese, is(notNullValue()))
    * instead of: *
    assertThat(cheese, is(not(nullValue())))
    + * + * @return The matcher. */ public static org.hamcrest.Matcher notNullValue() { return org.hamcrest.core.IsNull.notNullValue(); @@ -395,18 +649,23 @@ public static org.hamcrest.Matcher notNullValue() { *
    assertThat(cheese, is(notNullValue(X.class)))
    * instead of: *
    assertThat(cheese, is(not(nullValue(X.class))))
    - * + * + * @param + * the matcher type. * @param type * dummy parameter used to infer the generic type of the returned matcher + * @return The matcher. */ public static org.hamcrest.Matcher notNullValue(java.lang.Class type) { - return org.hamcrest.core.IsNull.notNullValue(type); + return org.hamcrest.core.IsNull.notNullValue(type); } /** * Creates a matcher that matches if examined object is null. * For example: *
    assertThat(cheese, is(nullValue())
    + * + * @return The matcher. */ public static org.hamcrest.Matcher nullValue() { return org.hamcrest.core.IsNull.nullValue(); @@ -417,34 +676,43 @@ public static org.hamcrest.Matcher nullValue() { * single dummy argument to facilitate type inference. * For example: *
    assertThat(cheese, is(nullValue(Cheese.class))
    - * + * + * @param + * the matcher type. * @param type * dummy parameter used to infer the generic type of the returned matcher + * @return The matcher. */ public static org.hamcrest.Matcher nullValue(java.lang.Class type) { - return org.hamcrest.core.IsNull.nullValue(type); + return org.hamcrest.core.IsNull.nullValue(type); } /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. - * + * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static org.hamcrest.Matcher sameInstance(T target) { - return org.hamcrest.core.IsSame.sameInstance(target); + return org.hamcrest.core.IsSame.sameInstance(target); } /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. - * + * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static org.hamcrest.Matcher theInstance(T target) { - return org.hamcrest.core.IsSame.theInstance(target); + return org.hamcrest.core.IsSame.theInstance(target); } /** @@ -452,11 +720,12 @@ public static org.hamcrest.Matcher theInstance(T target) { * {@link String} anywhere. * For example: *
    assertThat("myStringOfNote", containsString("ring"))
    - * + * * @param substring * the substring that the returned matcher will expect to find within any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher containsString(java.lang.String substring) { + public static Matcher containsString(java.lang.String substring) { return org.hamcrest.core.StringContains.containsString(substring); } @@ -464,12 +733,13 @@ public static org.hamcrest.Matcher containsString(java.lang.St * Creates a matcher that matches if the examined {@link String} contains the specified * {@link String} anywhere, ignoring case. * For example: - *
    assertThat("myStringOfNote", containsString("ring"))
    - * + *
    assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
    + * * @param substring * the substring that the returned matcher will expect to find within any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher containsStringIgnoringCase(java.lang.String substring) { + public static Matcher containsStringIgnoringCase(java.lang.String substring) { return org.hamcrest.core.StringContains.containsStringIgnoringCase(substring); } @@ -480,11 +750,12 @@ public static org.hamcrest.Matcher containsStringIgnoringCase( *

    * For example: *
    assertThat("myStringOfNote", startsWith("my"))
    - * + * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher startsWith(java.lang.String prefix) { + public static Matcher startsWith(java.lang.String prefix) { return org.hamcrest.core.StringStartsWith.startsWith(prefix); } @@ -494,12 +765,13 @@ public static org.hamcrest.Matcher startsWith(java.lang.String * {@link String}, ignoring case *

    * For example: - *
    assertThat("myStringOfNote", startsWith("my"))
    - * + *
    assertThat("myStringOfNote", startsWithIgnoringCase("My"))
    + * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher startsWithIgnoringCase(java.lang.String prefix) { + public static Matcher startsWithIgnoringCase(java.lang.String prefix) { return org.hamcrest.core.StringStartsWith.startsWithIgnoringCase(prefix); } @@ -508,11 +780,12 @@ public static org.hamcrest.Matcher startsWithIgnoringCase(java * {@link String}. * For example: *
    assertThat("myStringOfNote", endsWith("Note"))
    - * + * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher endsWith(java.lang.String suffix) { + public static Matcher endsWith(java.lang.String suffix) { return org.hamcrest.core.StringEndsWith.endsWith(suffix); } @@ -520,27 +793,62 @@ public static org.hamcrest.Matcher endsWith(java.lang.String s * Creates a matcher that matches if the examined {@link String} ends with the specified * {@link String}, ignoring case. * For example: - *
    assertThat("myStringOfNote", endsWith("Note"))
    - * + *
    assertThat("myStringOfNote", endsWithIgnoringCase("note"))
    + * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ - public static org.hamcrest.Matcher endsWithIgnoringCase(java.lang.String suffix) { + public static Matcher endsWithIgnoringCase(java.lang.String suffix) { return org.hamcrest.core.StringEndsWith.endsWithIgnoringCase(suffix); } + /** + * Validate a string with a {@link java.util.regex.Pattern}. + * + *
    +   * assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
    +   * 
    + * + * @param pattern + * the pattern to be used. + * @return The matcher. + */ + public static Matcher matchesRegex(Pattern pattern) { + return StringRegularExpression.matchesRegex(pattern); + } + + /** + * Validate a string with a regex. + * + *
    +   * assertThat("abc", matchesRegex("ˆ[a-z]+$"));
    +   * 
    + * + * @param regex + * The regex to be used for the validation. + * @return The matcher. + */ + public static Matcher matchesRegex(String regex) { + return StringRegularExpression.matchesRegex(Pattern.compile(regex)); + } + /** * Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches * positively only if the number of matchers specified is equal to the length of the examined array and * each matcher[i] is satisfied by array[i]. * For example: *
    assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
    - * + * + * @param + * the matcher type. * @param elementMatchers * the matchers that the elements of examined arrays should satisfy + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.collection.IsArray array(org.hamcrest.Matcher... elementMatchers) { - return org.hamcrest.collection.IsArray.array(elementMatchers); + return org.hamcrest.collection.IsArray.array(elementMatchers); } /** @@ -549,12 +857,15 @@ public static org.hamcrest.collection.IsArray array(org.hamcrest.Matcher< * of the examined array will stop as soon as a matching element is found. * For example: *
    assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param elementMatcher * the matcher to apply to elements in examined arrays + * @return The matcher. */ public static org.hamcrest.Matcher hasItemInArray(org.hamcrest.Matcher elementMatcher) { - return org.hamcrest.collection.IsArrayContaining.hasItemInArray(elementMatcher); + return ArrayMatching.hasItemInArray(elementMatcher); } /** @@ -563,12 +874,15 @@ public static org.hamcrest.Matcher hasItemInArray(org.hamcrest.Matcher< *
    assertThat(hasItemInArray(x))
    * instead of: *
    assertThat(hasItemInArray(equalTo(x)))
    - * + * + * @param + * the matcher type. * @param element * the element that should be present in examined arrays + * @return The matcher. */ public static org.hamcrest.Matcher hasItemInArray(T element) { - return org.hamcrest.collection.IsArrayContaining.hasItemInArray(element); + return ArrayMatching.hasItemInArray(element); } /** @@ -576,13 +890,17 @@ public static org.hamcrest.Matcher hasItemInArray(T element) { * logically equal to the corresponding item in the specified items. For a positive match, * the examined array must be of the same length as the number of specified items. * For example: - *
    assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
    - * + *
    assertThat(new String[]{"foo", "bar"}, arrayContaining("foo", "bar"))
    + * + * @param + * the matcher type. * @param items * the items that must equal the items within an examined array + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher arrayContaining(E... items) { - return org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining(items); + return ArrayMatching.arrayContaining(items); } /** @@ -590,13 +908,17 @@ public static org.hamcrest.Matcher arrayContaining(E... items) { * corresponding matcher in the specified matchers. For a positive match, the examined array * must be of the same length as the number of specified matchers. * For example: - *
    assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
    - * + *
    assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
    + * + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items in the examined array + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher arrayContaining(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining(itemMatchers); + return ArrayMatching.arrayContaining(itemMatchers); } /** @@ -604,13 +926,16 @@ public static org.hamcrest.Matcher arrayContaining(org.hamcrest.Matcher * corresponding matcher in the specified list of matchers. For a positive match, the examined array * must be of the same length as the specified list of matchers. * For example: - *
    assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    - * + *
    assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the corresponding item in an examined array + * @return The matcher. */ public static org.hamcrest.Matcher arrayContaining(java.util.List> itemMatchers) { - return org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining(itemMatchers); + return ArrayMatching.arrayContaining(itemMatchers); } /** @@ -629,12 +954,16 @@ public static org.hamcrest.Matcher arrayContaining(java.util.List *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an entry in an examined array + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher arrayContainingInAnyOrder(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(itemMatchers); + return ArrayMatching.arrayContainingInAnyOrder(itemMatchers); } /** @@ -653,12 +982,15 @@ public static org.hamcrest.Matcher arrayContainingInAnyOrder(org.hamcre * For example: *

    *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined array + * @return The matcher. */ public static org.hamcrest.Matcher arrayContainingInAnyOrder(java.util.Collection> itemMatchers) { - return org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(itemMatchers); + return ArrayMatching.arrayContainingInAnyOrder(itemMatchers); } /** @@ -674,13 +1006,17 @@ public static org.hamcrest.Matcher arrayContainingInAnyOrder(java.util. *

    * For example: *

    - *
    assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
    - * + *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder("bar", "foo"))
    + * + * @param + * the matcher type. * @param items * the items that must equal the entries of an examined array, in any order + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher arrayContainingInAnyOrder(E... items) { - return org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder(items); + return ArrayMatching.arrayContainingInAnyOrder(items); } /** @@ -688,12 +1024,15 @@ public static org.hamcrest.Matcher arrayContainingInAnyOrder(E... items * satisfies the specified matcher. * For example: *
    assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
    - * + * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the length of an examined array + * @return The matcher. */ public static org.hamcrest.Matcher arrayWithSize(org.hamcrest.Matcher sizeMatcher) { - return org.hamcrest.collection.IsArrayWithSize.arrayWithSize(sizeMatcher); + return org.hamcrest.collection.IsArrayWithSize.arrayWithSize(sizeMatcher); } /** @@ -701,12 +1040,15 @@ public static org.hamcrest.Matcher arrayWithSize(org.hamcrest.Matchersize. * For example: *
    assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
    - * + * + * @param + * the matcher type. * @param size * the length that an examined array must have for a positive match + * @return The matcher. */ public static org.hamcrest.Matcher arrayWithSize(int size) { - return org.hamcrest.collection.IsArrayWithSize.arrayWithSize(size); + return org.hamcrest.collection.IsArrayWithSize.arrayWithSize(size); } /** @@ -714,9 +1056,13 @@ public static org.hamcrest.Matcher arrayWithSize(int size) { * is zero. * For example: *
    assertThat(new String[0], emptyArray())
    + * + * @param + * the matcher type. + * @return The matcher. */ public static org.hamcrest.Matcher emptyArray() { - return org.hamcrest.collection.IsArrayWithSize.emptyArray(); + return org.hamcrest.collection.IsArrayWithSize.emptyArray(); } /** @@ -724,12 +1070,17 @@ public static org.hamcrest.Matcher emptyArray() { * a value that satisfies the specified matcher. * For example: *
    assertThat(myMap, is(aMapWithSize(equalTo(2))))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param sizeMatcher * a matcher for the size of an examined {@link java.util.Map} + * @return The matcher. */ public static org.hamcrest.Matcher> aMapWithSize(org.hamcrest.Matcher sizeMatcher) { - return org.hamcrest.collection.IsMapWithSize.aMapWithSize(sizeMatcher); + return org.hamcrest.collection.IsMapWithSize.aMapWithSize(sizeMatcher); } /** @@ -737,12 +1088,17 @@ public static org.hamcrest.Matcher * a value equal to the specified size. * For example: *
    assertThat(myMap, is(aMapWithSize(2)))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param size * the expected size of an examined {@link java.util.Map} + * @return The matcher. */ public static org.hamcrest.Matcher> aMapWithSize(int size) { - return org.hamcrest.collection.IsMapWithSize.aMapWithSize(size); + return org.hamcrest.collection.IsMapWithSize.aMapWithSize(size); } /** @@ -750,9 +1106,15 @@ public static org.hamcrest.Matcher * zero. * For example: *
    assertThat(myMap, is(anEmptyMap()))
    + * + * @param + * the map key type. + * @param + * the map value type. + * @return The matcher. */ public static org.hamcrest.Matcher> anEmptyMap() { - return org.hamcrest.collection.IsMapWithSize.anEmptyMap(); + return org.hamcrest.collection.IsMapWithSize.anEmptyMap(); } /** @@ -760,12 +1122,15 @@ public static org.hamcrest.Matcher * a value that satisfies the specified matcher. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
    - * + * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the size of an examined {@link java.util.Collection} + * @return The matcher. */ public static org.hamcrest.Matcher> hasSize(org.hamcrest.Matcher sizeMatcher) { - return org.hamcrest.collection.IsCollectionWithSize.hasSize(sizeMatcher); + return org.hamcrest.collection.IsCollectionWithSize.hasSize(sizeMatcher); } /** @@ -773,12 +1138,15 @@ public static org.hamcrest.Matcher> hasSiz * a value equal to the specified size. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasSize(2))
    - * + * + * @param + * the matcher type. * @param size * the expected size of an examined {@link java.util.Collection} + * @return The matcher. */ public static org.hamcrest.Matcher> hasSize(int size) { - return org.hamcrest.collection.IsCollectionWithSize.hasSize(size); + return org.hamcrest.collection.IsCollectionWithSize.hasSize(size); } /** @@ -786,9 +1154,13 @@ public static org.hamcrest.Matcher> hasSiz * method returns true. * For example: *
    assertThat(new ArrayList<String>(), is(empty()))
    + * + * @param + * the matcher type. + * @return The matcher. */ public static org.hamcrest.Matcher> empty() { - return org.hamcrest.collection.IsEmptyCollection.empty(); + return org.hamcrest.collection.IsEmptyCollection.empty(); } /** @@ -796,33 +1168,43 @@ public static org.hamcrest.Matcher> empty( * method returns true. * For example: *
    assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
    - * + * + * @param + * the matcher type. * @param unusedToForceReturnType * the type of the collection's content + * @return The matcher. */ public static org.hamcrest.Matcher> emptyCollectionOf(java.lang.Class unusedToForceReturnType) { - return org.hamcrest.collection.IsEmptyCollection.emptyCollectionOf(unusedToForceReturnType); + return org.hamcrest.collection.IsEmptyCollection.emptyCollectionOf(unusedToForceReturnType); } /** * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. * For example: *
    assertThat(new ArrayList<String>(), is(emptyIterable()))
    + * + * @param + * the matcher type. + * @return The matcher. */ public static org.hamcrest.Matcher> emptyIterable() { - return org.hamcrest.collection.IsEmptyIterable.emptyIterable(); + return org.hamcrest.collection.IsEmptyIterable.emptyIterable(); } /** * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. * For example: *
    assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
    - * + * + * @param + * the matcher type. * @param unusedToForceReturnType * the type of the iterable's content + * @return The matcher. */ public static org.hamcrest.Matcher> emptyIterableOf(java.lang.Class unusedToForceReturnType) { - return org.hamcrest.collection.IsEmptyIterable.emptyIterableOf(unusedToForceReturnType); + return org.hamcrest.collection.IsEmptyIterable.emptyIterableOf(unusedToForceReturnType); } /** @@ -832,12 +1214,16 @@ public static org.hamcrest.Matcher> emptyIterableOf(ja * must be of the same length as the number of specified items. * For example: *
    assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
    - * + * + * @param + * the matcher type. * @param items * the items that must equal the items provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> contains(E... items) { - return org.hamcrest.collection.IsIterableContainingInOrder.contains(items); + return org.hamcrest.collection.IsIterableContainingInOrder.contains(items); } /** @@ -846,13 +1232,16 @@ public static org.hamcrest.Matcher> contains * For a positive match, the examined iterable must only yield one item. * For example: *
    assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher that must be satisfied by the single item provided by an * examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> contains(org.hamcrest.Matcher itemMatcher) { - return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatcher); + return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatcher); } /** @@ -862,12 +1251,16 @@ public static org.hamcrest.Matcher> contains * must be of the same length as the number of specified matchers. * For example: *
    assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> contains(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatchers); } /** @@ -877,13 +1270,16 @@ public static org.hamcrest.Matcher> contains * must be of the same length as the specified list of matchers. * For example: *
    assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the corresponding item provided by * an examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> contains(java.util.List> itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInOrder.contains(itemMatchers); } /** @@ -902,12 +1298,16 @@ public static org.hamcrest.Matcher> contains * For example: *

    *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> containsInAnyOrder(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(itemMatchers); } /** @@ -926,12 +1326,16 @@ public static org.hamcrest.Matcher> contains * For example: *

    *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
    - * + * + * @param + * the matcher type. * @param items * the items that must equal the items provided by an examined {@link Iterable} in any order + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> containsInAnyOrder(T... items) { - return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(items); + return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(items); } /** @@ -948,12 +1352,15 @@ public static org.hamcrest.Matcher> contains *

    *

    For example:

    *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> containsInAnyOrder(java.util.Collection> itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder(itemMatchers); } /** @@ -962,12 +1369,16 @@ public static org.hamcrest.Matcher> contains * corresponding item in the specified items, in the same relative order * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
    - * + * + * @param + * the matcher type. * @param items * the items that must be contained within items provided by an examined {@link Iterable} in the same relative order + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> containsInRelativeOrder(E... items) { - return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(items); + return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(items); } /** @@ -976,12 +1387,16 @@ public static org.hamcrest.Matcher> contains * matcher in the specified matchers, in the same relative order. * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items provided by an examined {@link Iterable} in the same relative order + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher> containsInRelativeOrder(org.hamcrest.Matcher... itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers); } /** @@ -990,13 +1405,16 @@ public static org.hamcrest.Matcher> contains * matcher in the specified list of matchers, in the same relative order. * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the items provided by * an examined {@link Iterable} in the same relative order + * @return The matcher. */ public static org.hamcrest.Matcher> containsInRelativeOrder(java.util.List> itemMatchers) { - return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers); + return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers); } /** @@ -1005,12 +1423,15 @@ public static org.hamcrest.Matcher> contains * matcher. * For example: *
    assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
    - * + * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the number of items that should be yielded by an examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> iterableWithSize(org.hamcrest.Matcher sizeMatcher) { - return org.hamcrest.collection.IsIterableWithSize.iterableWithSize(sizeMatcher); + return org.hamcrest.collection.IsIterableWithSize.iterableWithSize(sizeMatcher); } /** @@ -1019,12 +1440,15 @@ public static org.hamcrest.Matcher> iterableWithSize(o * size argument. * For example: *
    assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
    - * + * + * @param + * the matcher type. * @param size * the number of items that should be yielded by an examined {@link Iterable} + * @return The matcher. */ public static org.hamcrest.Matcher> iterableWithSize(int size) { - return org.hamcrest.collection.IsIterableWithSize.iterableWithSize(size); + return org.hamcrest.collection.IsIterableWithSize.iterableWithSize(size); } /** @@ -1033,14 +1457,19 @@ public static org.hamcrest.Matcher> iterableWithSize(i * value satisfies the specified valueMatcher. * For example: *
    assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param keyMatcher * the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry * @param valueMatcher * the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry + * @return The matcher. */ public static org.hamcrest.Matcher> hasEntry(org.hamcrest.Matcher keyMatcher, org.hamcrest.Matcher valueMatcher) { - return org.hamcrest.collection.IsMapContaining.hasEntry(keyMatcher, valueMatcher); + return org.hamcrest.collection.IsMapContaining.hasEntry(keyMatcher, valueMatcher); } /** @@ -1049,14 +1478,19 @@ public static org.hamcrest.Matcher * specified value. * For example: *
    assertThat(myMap, hasEntry("bar", "foo"))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param key * the key that, in combination with the value, must be describe at least one entry * @param value * the value that, in combination with the key, must be describe at least one entry + * @return The matcher. */ public static org.hamcrest.Matcher> hasEntry(K key, V value) { - return org.hamcrest.collection.IsMapContaining.hasEntry(key, value); + return org.hamcrest.collection.IsMapContaining.hasEntry(key, value); } /** @@ -1064,12 +1498,15 @@ public static org.hamcrest.Matcher * at least one key that satisfies the specified matcher. * For example: *
    assertThat(myMap, hasKey(equalTo("bar")))
    - * + * + * @param + * the map key type. * @param keyMatcher * the matcher that must be satisfied by at least one key + * @return The matcher. */ public static org.hamcrest.Matcher> hasKey(org.hamcrest.Matcher keyMatcher) { - return org.hamcrest.collection.IsMapContaining.hasKey(keyMatcher); + return org.hamcrest.collection.IsMapContaining.hasKey(keyMatcher); } /** @@ -1077,12 +1514,15 @@ public static org.hamcrest.Matcher> hasKey(org. * at least one key that is equal to the specified key. * For example: *
    assertThat(myMap, hasKey("bar"))
    - * + * + * @param + * the map key type. * @param key * the key that satisfying maps must contain + * @return The matcher. */ public static org.hamcrest.Matcher> hasKey(K key) { - return org.hamcrest.collection.IsMapContaining.hasKey(key); + return org.hamcrest.collection.IsMapContaining.hasKey(key); } /** @@ -1090,12 +1530,15 @@ public static org.hamcrest.Matcher> hasKey(K ke * at least one value that satisfies the specified valueMatcher. * For example: *
    assertThat(myMap, hasValue(equalTo("foo")))
    - * + * + * @param + * the value type. * @param valueMatcher * the matcher that must be satisfied by at least one value + * @return The matcher. */ public static org.hamcrest.Matcher> hasValue(org.hamcrest.Matcher valueMatcher) { - return org.hamcrest.collection.IsMapContaining.hasValue(valueMatcher); + return org.hamcrest.collection.IsMapContaining.hasValue(valueMatcher); } /** @@ -1103,12 +1546,15 @@ public static org.hamcrest.Matcher> hasValue(or * at least one value that is equal to the specified value. * For example: *
    assertThat(myMap, hasValue("foo"))
    - * + * + * @param + * the value type. * @param value * the value that satisfying maps must contain + * @return The matcher. */ public static org.hamcrest.Matcher> hasValue(V value) { - return org.hamcrest.collection.IsMapContaining.hasValue(value); + return org.hamcrest.collection.IsMapContaining.hasValue(value); } /** @@ -1116,12 +1562,15 @@ public static org.hamcrest.Matcher> hasValue(V * specified collection. * For example: *
    assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
    - * + * + * @param + * the matcher type. * @param collection * the collection in which matching items must be found + * @return The matcher. */ public static org.hamcrest.Matcher in(java.util.Collection collection) { - return org.hamcrest.collection.IsIn.in(collection); + return org.hamcrest.collection.IsIn.in(collection); } /** @@ -1129,12 +1578,15 @@ public static org.hamcrest.Matcher in(java.util.Collection collection) * specified array. * For example: *
    assertThat("foo", is(in(new String[]{"bar", "foo"})))
    - * + * + * @param + * the matcher type. * @param elements * the array in which matching items must be found + * @return The matcher. */ public static org.hamcrest.Matcher in(T[] elements) { - return org.hamcrest.collection.IsIn.in(elements); + return org.hamcrest.collection.IsIn.in(elements); } /** @@ -1142,13 +1594,17 @@ public static org.hamcrest.Matcher in(T[] elements) { * specified collection. * For example: *
    assertThat("foo", isIn(Arrays.asList("bar", "foo")))
    - * + * + * @param + * the matcher type. * @deprecated use is(in(...)) instead * @param collection * the collection in which matching items must be found + * @return The matcher. */ + @SuppressWarnings("deprecation") public static org.hamcrest.Matcher isIn(java.util.Collection collection) { - return org.hamcrest.collection.IsIn.isIn(collection); + return org.hamcrest.collection.IsIn.isIn(collection); } /** @@ -1156,13 +1612,17 @@ public static org.hamcrest.Matcher isIn(java.util.Collection collectio * specified array. * For example: *
    assertThat("foo", isIn(new String[]{"bar", "foo"}))
    - * + * * @deprecated use is(in(...)) instead + * @param + * the matcher type. * @param elements * the array in which matching items must be found + * @return The matcher. */ + @SuppressWarnings("deprecation") public static org.hamcrest.Matcher isIn(T[] elements) { - return org.hamcrest.collection.IsIn.isIn(elements); + return org.hamcrest.collection.IsIn.isIn(elements); } /** @@ -1170,13 +1630,18 @@ public static org.hamcrest.Matcher isIn(T[] elements) { * specified elements. * For example: *
    assertThat("foo", isOneOf("bar", "foo"))
    - * + * * @deprecated use is(oneOf(...)) instead + * @param + * the matcher type. * @param elements * the elements amongst which matching items will be found + * @return The matcher. */ + @SuppressWarnings("deprecation") + @SafeVarargs public static org.hamcrest.Matcher isOneOf(T... elements) { - return org.hamcrest.collection.IsIn.isOneOf(elements); + return org.hamcrest.collection.IsIn.isOneOf(elements); } /** @@ -1184,12 +1649,16 @@ public static org.hamcrest.Matcher isOneOf(T... elements) { * specified elements. * For example: *
    assertThat("foo", is(oneOf("bar", "foo")))
    - * + * + * @param + * the matcher type. * @param elements * the elements amongst which matching items will be found + * @return The matcher. */ + @SafeVarargs public static org.hamcrest.Matcher oneOf(T... elements) { - return org.hamcrest.collection.IsIn.oneOf(elements); + return org.hamcrest.collection.IsIn.oneOf(elements); } /** @@ -1197,11 +1666,12 @@ public static org.hamcrest.Matcher oneOf(T... elements) { * to the specified operand, within a range of +/- error. * For example: *
    assertThat(1.03, is(closeTo(1.0, 0.03)))
    - * + * * @param operand * the expected value of matching doubles * @param error * the delta (+/-) within which matches will be allowed + * @return The matcher. */ public static org.hamcrest.Matcher closeTo(double operand, double error) { return org.hamcrest.number.IsCloseTo.closeTo(operand, error); @@ -1211,6 +1681,8 @@ public static org.hamcrest.Matcher closeTo(double operand, dou * Creates a matcher of {@link Double}s that matches when an examined double is not a number. * For example: *
    assertThat(Double.NaN, is(notANumber()))
    + * + * @return The matcher. */ public static org.hamcrest.Matcher notANumber() { return org.hamcrest.number.IsNaN.notANumber(); @@ -1222,11 +1694,12 @@ public static org.hamcrest.Matcher notANumber() { * is done by BigDecimals {@link java.math.BigDecimal#compareTo(java.math.BigDecimal)} method. * For example: *
    assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
    - * + * * @param operand * the expected value of matching BigDecimals * @param error * the delta (+/-) within which matches will be allowed + * @return The matcher. */ public static org.hamcrest.Matcher closeTo(java.math.BigDecimal operand, java.math.BigDecimal error) { return org.hamcrest.number.BigDecimalCloseTo.closeTo(operand, error); @@ -1238,11 +1711,14 @@ public static org.hamcrest.Matcher closeTo(java.math.BigDe * examined object. * For example: *
    assertThat(1, comparesEqualTo(1))
    - * + * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return zero + * @return The matcher. */ public static > org.hamcrest.Matcher comparesEqualTo(T value) { - return org.hamcrest.number.OrderingComparison.comparesEqualTo(value); + return org.hamcrest.number.OrderingComparison.comparesEqualTo(value); } /** @@ -1251,12 +1727,15 @@ public static > org.hamcrest.Matcher compar * examined object. * For example: *
    assertThat(2, greaterThan(1))
    - * + * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return greater * than zero + * @return The matcher. */ public static > org.hamcrest.Matcher greaterThan(T value) { - return org.hamcrest.number.OrderingComparison.greaterThan(value); + return org.hamcrest.number.OrderingComparison.greaterThan(value); } /** @@ -1265,12 +1744,15 @@ public static > org.hamcrest.Matcher greate * of the examined object. * For example: *
    assertThat(1, greaterThanOrEqualTo(1))
    - * + * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return greater * than or equal to zero + * @return The matcher. */ public static > org.hamcrest.Matcher greaterThanOrEqualTo(T value) { - return org.hamcrest.number.OrderingComparison.greaterThanOrEqualTo(value); + return org.hamcrest.number.OrderingComparison.greaterThanOrEqualTo(value); } /** @@ -1279,12 +1761,15 @@ public static > org.hamcrest.Matcher greate * examined object. * For example: *
    assertThat(1, lessThan(2))
    - * + * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return less * than zero + * @return The matcher. */ public static > org.hamcrest.Matcher lessThan(T value) { - return org.hamcrest.number.OrderingComparison.lessThan(value); + return org.hamcrest.number.OrderingComparison.lessThan(value); } /** @@ -1293,12 +1778,15 @@ public static > org.hamcrest.Matcher lessTh * of the examined object. * For example: *
    assertThat(1, lessThanOrEqualTo(1))
    - * + * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return less * than or equal to zero + * @return The matcher. */ public static > org.hamcrest.Matcher lessThanOrEqualTo(T value) { - return org.hamcrest.number.OrderingComparison.lessThanOrEqualTo(value); + return org.hamcrest.number.OrderingComparison.lessThanOrEqualTo(value); } /** @@ -1306,14 +1794,25 @@ public static > org.hamcrest.Matcher lessTh * the specified expectedString, ignoring case. * For example: *
    assertThat("Foo", equalToIgnoringCase("FOO"))
    - * + * * @param expectedString * the expected value of matched strings + * @return The matcher. */ - public static org.hamcrest.Matcher equalToIgnoringCase(java.lang.String expectedString) { + public static Matcher equalToIgnoringCase(java.lang.String expectedString) { return org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase(expectedString); } + /** + * @deprecated {@link #equalToCompressingWhiteSpace(String)} + * @param expectedString + * the expected value of matched strings + * @return The matcher. + */ + public static Matcher equalToIgnoringWhiteSpace(java.lang.String expectedString) { + return equalToCompressingWhiteSpace(expectedString); + } + /** * Creates a matcher of {@link String} that matches when the examined string is equal to * the specified expectedString, when whitespace differences are (mostly) ignored. To be @@ -1324,12 +1823,13 @@ public static org.hamcrest.Matcher equalToIgnoringCase(java.la * * For example: *
    assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
    - * + * * @param expectedString * the expected value of matched strings + * @return The matcher. */ - public static org.hamcrest.Matcher equalToIgnoringWhiteSpace(java.lang.String expectedString) { - return org.hamcrest.text.IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace(expectedString); + public static Matcher equalToCompressingWhiteSpace(java.lang.String expectedString) { + return IsEqualCompressingWhiteSpace.equalToCompressingWhiteSpace(expectedString); } /** @@ -1337,8 +1837,10 @@ public static org.hamcrest.Matcher equalToIgnoringWhiteSpace(j * has zero length. * For example: *
    assertThat(((String)null), is(emptyOrNullString()))
    + * + * @return The matcher. */ - public static org.hamcrest.Matcher emptyOrNullString() { + public static Matcher emptyOrNullString() { return org.hamcrest.text.IsEmptyString.emptyOrNullString(); } @@ -1346,8 +1848,10 @@ public static org.hamcrest.Matcher emptyOrNullString() { * Creates a matcher of {@link String} that matches when the examined string has zero length. * For example: *
    assertThat("", is(emptyString()))
    + * + * @return The matcher. */ - public static org.hamcrest.Matcher emptyString() { + public static Matcher emptyString() { return org.hamcrest.text.IsEmptyString.emptyString(); } @@ -1356,10 +1860,12 @@ public static org.hamcrest.Matcher emptyString() { * has zero length. * For example: *
    assertThat(((String)null), isEmptyOrNullString())
    - * + * * @deprecated use is(emptyOrNullString()) instead + * @return The matcher. */ - public static org.hamcrest.Matcher isEmptyOrNullString() { + @SuppressWarnings("deprecation") + public static Matcher isEmptyOrNullString() { return org.hamcrest.text.IsEmptyString.isEmptyOrNullString(); } @@ -1367,10 +1873,12 @@ public static org.hamcrest.Matcher isEmptyOrNullString() { * Creates a matcher of {@link String} that matches when the examined string has zero length. * For example: *
    assertThat("", isEmptyString())
    - * + * * @deprecated use is(emptyString()) instead + * @return The matcher. */ - public static org.hamcrest.Matcher isEmptyString() { + @SuppressWarnings("deprecation") + public static Matcher isEmptyString() { return org.hamcrest.text.IsEmptyString.isEmptyString(); } @@ -1379,8 +1887,10 @@ public static org.hamcrest.Matcher isEmptyString() { * contains zero or more whitespace characters and nothing else. * For example: *
    assertThat(((String)null), is(blankOrNullString()))
    + * + * @return The matcher. */ - public static org.hamcrest.Matcher blankOrNullString() { + public static Matcher blankOrNullString() { return org.hamcrest.text.IsBlankString.blankOrNullString(); } @@ -1389,24 +1899,34 @@ public static org.hamcrest.Matcher blankOrNullString() { * zero or more whitespace characters and nothing else. * For example: *
    assertThat("  ", is(blankString()))
    + * + * @return The matcher. */ - public static org.hamcrest.Matcher blankString() { + public static Matcher blankString() { return org.hamcrest.text.IsBlankString.blankString(); } /** * Creates a matcher of {@link java.lang.String} that matches when the examined string * exactly matches the given {@link java.util.regex.Pattern}. + * + * @param pattern + * the text pattern to match. + * @return The matcher. */ - public static org.hamcrest.Matcher matchesPattern(java.util.regex.Pattern pattern) { + public static Matcher matchesPattern(java.util.regex.Pattern pattern) { return org.hamcrest.text.MatchesPattern.matchesPattern(pattern); } /** * Creates a matcher of {@link java.lang.String} that matches when the examined string * exactly matches the given regular expression, treated as a {@link java.util.regex.Pattern}. + * + * @param regex + * the regex to match. + * @return The matcher. */ - public static org.hamcrest.Matcher matchesPattern(java.lang.String regex) { + public static Matcher matchesPattern(java.lang.String regex) { return org.hamcrest.text.MatchesPattern.matchesPattern(regex); } @@ -1416,11 +1936,12 @@ public static org.hamcrest.Matcher matchesPattern(java.lang.St * For example: *
    assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
    * fails as "foo" occurs before "bar" in the string "myfoobarbaz" - * + * * @param substrings * the substrings that must be contained within matching strings + * @return The matcher. */ - public static org.hamcrest.Matcher stringContainsInOrder(java.lang.Iterable substrings) { + public static Matcher stringContainsInOrder(java.lang.Iterable substrings) { return org.hamcrest.text.StringContainsInOrder.stringContainsInOrder(substrings); } @@ -1430,25 +1951,61 @@ public static org.hamcrest.Matcher stringContainsInOrder(java. * For example: *
    assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
    * fails as "foo" occurs before "bar" in the string "myfoobarbaz" - * + * * @param substrings * the substrings that must be contained within matching strings + * @return The matcher. */ - public static org.hamcrest.Matcher stringContainsInOrder(java.lang.String... substrings) { + public static Matcher stringContainsInOrder(java.lang.String... substrings) { return org.hamcrest.text.StringContainsInOrder.stringContainsInOrder(substrings); } + /** + * Creates a matcher of {@link CharSequence} that matches when a char sequence has the length + * that satisfies the specified matcher. + * For example: + * + *
    +   * assertThat("text", hasLength(lessThan(4)))
    +   * 
    + * + * @param lengthMatcher a matcher for the expected length of the string + * @return The matcher. + */ + public static Matcher hasLength(org.hamcrest.Matcher lengthMatcher) { + return org.hamcrest.text.CharSequenceLength.hasLength(lengthMatcher); + } + + /** + * Creates a matcher of {@link CharSequence} that matches when a char sequence has the length + * of the specified argument. + * For example: + * + *
    +   * assertThat("text", length(4))
    +   * 
    + * + * @param length the expected length of the string + * @return The matcher. + */ + public static Matcher hasLength(int length) { + return org.hamcrest.text.CharSequenceLength.hasLength(length); + } + /** * Creates a matcher that matches any examined object whose toString method * returns a value that satisfies the specified matcher. * For example: *
    assertThat(true, hasToString(equalTo("TRUE")))
    - * + * + * @param + * the matcher type. * @param toStringMatcher * the matcher used to verify the toString result + * @return The matcher. */ public static org.hamcrest.Matcher hasToString(org.hamcrest.Matcher toStringMatcher) { - return org.hamcrest.object.HasToString.hasToString(toStringMatcher); + return org.hamcrest.object.HasToString.hasToString(toStringMatcher); } /** @@ -1456,12 +2013,15 @@ public static org.hamcrest.Matcher hasToString(org.hamcrest.MatcherassertThat(true, hasToString("TRUE")) - * + * + * @param + * the matcher type. * @param expectedToString * the expected toString result + * @return The matcher. */ public static org.hamcrest.Matcher hasToString(java.lang.String expectedToString) { - return org.hamcrest.object.HasToString.hasToString(expectedToString); + return org.hamcrest.object.HasToString.hasToString(expectedToString); } /** @@ -1469,12 +2029,15 @@ public static org.hamcrest.Matcher hasToString(java.lang.String expectedT * assignable from the examined class. * For example: *
    assertThat(Integer.class, typeCompatibleWith(Number.class))
    - * + * + * @param + * the matcher type. * @param baseType * the base class to examine classes against + * @return The matcher. */ public static org.hamcrest.Matcher> typeCompatibleWith(java.lang.Class baseType) { - return org.hamcrest.object.IsCompatibleType.typeCompatibleWith(baseType); + return org.hamcrest.object.IsCompatibleType.typeCompatibleWith(baseType); } /** @@ -1482,11 +2045,12 @@ public static org.hamcrest.Matcher> typeCompatibleWith(ja * derived from eventClass announced by source. * For example: *
    assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
    - * + * * @param eventClass * the class of the event to match on * @param source * the source of the event + * @return The matcher. */ public static org.hamcrest.Matcher eventFrom(java.lang.Class eventClass, java.lang.Object source) { return org.hamcrest.object.IsEventFrom.eventFrom(eventClass, source); @@ -1497,9 +2061,10 @@ public static org.hamcrest.Matcher eventFrom(java.lang.Cl * announced by source. * For example: *
    assertThat(myEvent, is(eventFrom(myBean)))
    - * + * * @param source * the source of the event + * @return The matcher. */ public static org.hamcrest.Matcher eventFrom(java.lang.Object source) { return org.hamcrest.object.IsEventFrom.eventFrom(source); @@ -1510,12 +2075,15 @@ public static org.hamcrest.Matcher eventFrom(java.lang.Ob * with the specified name. * For example: *
    assertThat(myBean, hasProperty("foo"))
    - * + * + * @param + * the matcher type. * @param propertyName * the name of the JavaBean property that examined beans should possess + * @return The matcher. */ public static org.hamcrest.Matcher hasProperty(java.lang.String propertyName) { - return org.hamcrest.beans.HasProperty.hasProperty(propertyName); + return org.hamcrest.beans.HasProperty.hasProperty(propertyName); } /** @@ -1523,28 +2091,39 @@ public static org.hamcrest.Matcher hasProperty(java.lang.String propertyN * with the specified name whose value satisfies the specified matcher. * For example: *
    assertThat(myBean, hasProperty("foo", equalTo("bar"))
    - * + * + * @param + * the matcher type. * @param propertyName * the name of the JavaBean property that examined beans should possess * @param valueMatcher * a matcher for the value of the specified property of the examined bean + * @return The matcher. */ public static org.hamcrest.Matcher hasProperty(java.lang.String propertyName, org.hamcrest.Matcher valueMatcher) { - return org.hamcrest.beans.HasPropertyWithValue.hasProperty(propertyName, valueMatcher); + return org.hamcrest.beans.HasPropertyWithValue.hasProperty(propertyName, valueMatcher); } /** * 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. + * specified bean. If any properties are marked as ignored, they will be dropped from + * both the expected and actual bean. Note that the ignored properties use JavaBean + * display names, for example
    age
    rather than method names such as
    getAge
    . * For example: *
    assertThat(myBean, samePropertyValuesAs(myExpectedBean))
    - * + *
    assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
    + * + * @param + * the matcher type. * @param expectedBean * the bean against which examined beans are compared + * @param ignoredProperties + * do not check any of these named properties. + * @return The matcher. */ - public static org.hamcrest.Matcher samePropertyValuesAs(T expectedBean) { - return org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs(expectedBean); + public static Matcher samePropertyValuesAs(B expectedBean, String... ignoredProperties) { + return org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs(expectedBean, ignoredProperties); } /** @@ -1552,13 +2131,14 @@ public static org.hamcrest.Matcher samePropertyValuesAs(T expectedBean) { * specified xPath that satisfies the specified valueMatcher. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
    - * + * * @param xPath * the target xpath * @param valueMatcher * matcher for the value at the specified xpath + * @return The matcher. */ - public static org.hamcrest.Matcher hasXPath(java.lang.String xPath, org.hamcrest.Matcher valueMatcher) { + public static org.hamcrest.Matcher hasXPath(java.lang.String xPath, Matcher valueMatcher) { return org.hamcrest.xml.HasXPath.hasXPath(xPath, valueMatcher); } @@ -1568,15 +2148,16 @@ public static org.hamcrest.Matcher hasXPath(java.lang.String x * the specified valueMatcher. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
    - * + * * @param xPath * the target xpath * @param namespaceContext * the namespace for matching nodes * @param valueMatcher * matcher for the value at the specified xpath + * @return The matcher. */ - public static org.hamcrest.Matcher hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, org.hamcrest.Matcher valueMatcher) { + public static org.hamcrest.Matcher hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, Matcher valueMatcher) { return org.hamcrest.xml.HasXPath.hasXPath(xPath, namespaceContext, valueMatcher); } @@ -1585,9 +2166,10 @@ public static org.hamcrest.Matcher hasXPath(java.lang.String x * at the specified xPath, with any content. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese"))
    - * + * * @param xPath * the target xpath + * @return The matcher. */ public static org.hamcrest.Matcher hasXPath(java.lang.String xPath) { return org.hamcrest.xml.HasXPath.hasXPath(xPath); @@ -1598,14 +2180,138 @@ public static org.hamcrest.Matcher hasXPath(java.lang.String x * at the specified xPath within the specified namespace context, with any content. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
    - * + * * @param xPath * the target xpath * @param namespaceContext * the namespace for matching nodes + * @return The matcher. */ public static org.hamcrest.Matcher hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext) { return org.hamcrest.xml.HasXPath.hasXPath(xPath, namespaceContext); } + /** + * Matcher that expects empty {@link Optional}. + * + * @param type of optional value + * @return The matcher. + */ + public static Matcher> emptyOptional() { + return OptionalEmpty.emptyOptional(); + } + + /** + * Matcher for {@link Optional} that expects that value is present. + * + * @param type of optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue() { + return OptionalWithValue.optionalWithValue(); + } + + /** + * Matcher for {@link Optional} that expects that value is present and is equal to value + * + * @param type of optional value + * @param value to validate present optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue(T value) { + return OptionalWithValue.optionalWithValue(value); + } + + /** + * Matcher for {@link Optional} that expects that value is present and matches matcher + * + * @param type of optional value + * @param matcher matcher to validate present optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue(Matcher matcher) { + return OptionalWithValue.optionalWithValue(matcher); + } + + /** + * Matcher for {@link Runnable} that expects an exception to be thrown + * + * @param type of the Runnable + * @return The matcher. + */ + public static Matcher throwsException() { + return ThrowsException.throwsException(); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception equal to the provided throwable + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwable the Throwable class against which examined exceptions are compared + * @return The matcher. + */ + public static Matcher throwsException(U throwable) { + return ThrowsException.throwsException(throwable); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided throwableClass class + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass) { + return ThrowsException.throwsException(throwableClass); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided throwableClass class and has a message equal to the provided message + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @param message the String against which examined exception messages are compared + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass, String message) { + return ThrowsException.throwsException(throwableClass, message); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided throwableClass class and has a message matching the provided messageMatcher + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @param messageMatcher matcher to validate exception's message + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass, Matcher messageMatcher) { + return ThrowsException.throwsException(throwableClass, messageMatcher); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception with a message equal to the provided message + * + * @param type of the Runnable + * @param message the String against which examined exception messages are compared + * @return The matcher. + */ + public static Matcher throwsExceptionWithMessage(String message) { + return ThrowsException.throwsExceptionWithMessage(message); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception with a message matching the provided messageMatcher + * + * @param type of the Runnable + * @param messageMatcher matcher to validate exception's message + * @return The matcher. + */ + public static Matcher throwsExceptionWithMessage(Matcher messageMatcher) { + return ThrowsException.throwsExceptionWithMessage(messageMatcher); + } } diff --git a/hamcrest-core/src/main/java/org/hamcrest/SelfDescribing.java b/hamcrest/src/main/java/org/hamcrest/SelfDescribing.java similarity index 80% rename from hamcrest-core/src/main/java/org/hamcrest/SelfDescribing.java rename to hamcrest/src/main/java/org/hamcrest/SelfDescribing.java index 06b361d28..a3ef73018 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/SelfDescribing.java +++ b/hamcrest/src/main/java/org/hamcrest/SelfDescribing.java @@ -4,13 +4,15 @@ * The ability of an object to describe itself. */ public interface SelfDescribing { + /** * Generates a description of the object. The description may be part of a - * a description of a larger object of which this is just a component, so it + * description of a larger object of which this is just a component, so it * should be worded appropriately. - * + * * @param description * The description to be built or appended to. */ void describeTo(Description description); -} \ No newline at end of file + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/StringDescription.java b/hamcrest/src/main/java/org/hamcrest/StringDescription.java similarity index 80% rename from hamcrest-core/src/main/java/org/hamcrest/StringDescription.java rename to hamcrest/src/main/java/org/hamcrest/StringDescription.java index 813c1782a..a8b3e8032 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/StringDescription.java +++ b/hamcrest/src/main/java/org/hamcrest/StringDescription.java @@ -6,21 +6,29 @@ * A {@link Description} that is stored as a string. */ public class StringDescription extends BaseDescription { + private final Appendable out; + /** + * Creates a new description. + */ public StringDescription() { this(new StringBuilder()); } + /** + * Creates a new description using the given appendable. + * @param out the place to append the description. + */ public StringDescription(Appendable out) { this.out = out; } - + /** * Return the description of a {@link SelfDescribing} object as a String. - * + * * @param selfDescribing - * The object to be described. + * The object to be described. * @return * The description of the object. */ @@ -30,6 +38,11 @@ public static String toString(SelfDescribing selfDescribing) { /** * Alias for {@link #toString(SelfDescribing)}. + * + * @param selfDescribing + * The object to be described. + * @return + * The description of the object. */ public static String asString(SelfDescribing selfDescribing) { return toString(selfDescribing); @@ -52,7 +65,7 @@ protected void append(char c) { throw new RuntimeException("Could not write description", e); } } - + /** * Returns the description as a string. */ @@ -60,4 +73,5 @@ protected void append(char c) { public String toString() { return out.toString(); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java b/hamcrest/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java similarity index 72% rename from hamcrest-core/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java rename to hamcrest/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java index c204120a6..4bcf871b2 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/TypeSafeDiagnosingMatcher.java @@ -2,31 +2,40 @@ import org.hamcrest.internal.ReflectiveTypeFinder; - /** * Convenient base class for Matchers that require a non-null value of a specific type * and that will report why the received value has been rejected. - * This implements the null check, checks the type and then casts. - * To use, implement
    matchesSafely()
    . + * This implements the null check, checks the type and then casts. + * To use, implement {@link #matchesSafely(Object, Description)}. + * + * @param the matcher type. + * @see DiagnosingMatcher * - * @param * @author Neil Dunn * @author Nat Pryce * @author Steve Freeman */ public abstract class TypeSafeDiagnosingMatcher extends BaseMatcher { - private static final ReflectiveTypeFinder TYPE_FINDER = new ReflectiveTypeFinder("matchesSafely", 2, 0); + + private static final ReflectiveTypeFinder TYPE_FINDER = new ReflectiveTypeFinder("matchesSafely", 2, 0); private final Class expectedType; /** * Subclasses should implement this. The item will already have been checked * for the specific type and will never be null. + * + * @param item + * the item. + * @param mismatchDescription + * the mismatch description. + * @return boolean true/false depending if item matches matcher. */ protected abstract boolean matchesSafely(T item, Description mismatchDescription); /** - * Use this constructor if the subclass that implements matchesSafely - * is not the class that binds <T> to a type. + * Use this constructor if the subclass that implements matchesSafely + * is not the class that binds <T> to a type. + * * @param expectedType The expectedType of the actual value. */ protected TypeSafeDiagnosingMatcher(Class expectedType) { @@ -34,19 +43,20 @@ protected TypeSafeDiagnosingMatcher(Class expectedType) { } /** - * Use this constructor if the subclass that implements matchesSafely - * is not the class that binds <T> to a type. + * Use this constructor if the subclass that implements matchesSafely + * is not the class that binds <T> to a type. + * * @param typeFinder A type finder to extract the type */ protected TypeSafeDiagnosingMatcher(ReflectiveTypeFinder typeFinder) { - this.expectedType = typeFinder.findExpectedType(getClass()); + this.expectedType = typeFinder.findExpectedType(getClass()); } /** * The default constructor for simple sub types */ protected TypeSafeDiagnosingMatcher() { - this(TYPE_FINDER); + this(TYPE_FINDER); } @Override @@ -60,10 +70,16 @@ public final boolean matches(Object item) { @SuppressWarnings("unchecked") @Override public final void describeMismatch(Object item, Description mismatchDescription) { - if (item == null || !expectedType.isInstance(item)) { - super.describeMismatch(item, mismatchDescription); - } else { + if (item == null) { + mismatchDescription.appendText("was null"); + } else if (!expectedType.isInstance(item)) { + mismatchDescription.appendText("was ") + .appendText(item.getClass().getSimpleName()) + .appendText(" ") + .appendValue(item); + } else { matchesSafely((T) item, mismatchDescription); } } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/TypeSafeMatcher.java b/hamcrest/src/main/java/org/hamcrest/TypeSafeMatcher.java similarity index 76% rename from hamcrest-core/src/main/java/org/hamcrest/TypeSafeMatcher.java rename to hamcrest/src/main/java/org/hamcrest/TypeSafeMatcher.java index 08dfce8ba..4bad8e8a4 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/TypeSafeMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/TypeSafeMatcher.java @@ -6,13 +6,16 @@ * Convenient base class for Matchers that require a non-null value of a specific type. * This simply implements the null check, checks the type and then casts. * + * @param + * the matcher type. * @author Joe Walnes * @author Steve Freeman * @author Nat Pryce */ public abstract class TypeSafeMatcher extends BaseMatcher { + private static final ReflectiveTypeFinder TYPE_FINDER = new ReflectiveTypeFinder("matchesSafely", 1, 0); - + final private Class expectedType; /** @@ -21,43 +24,55 @@ public abstract class TypeSafeMatcher extends BaseMatcher { protected TypeSafeMatcher() { this(TYPE_FINDER); } - + /** - * Use this constructor if the subclass that implements matchesSafely - * is not the class that binds <T> to a type. + * Use this constructor if the subclass that implements matchesSafely + * is not the class that binds <T> to a type. * @param expectedType The expectedType of the actual value. */ protected TypeSafeMatcher(Class expectedType) { this.expectedType = expectedType; } - + /** - * Use this constructor if the subclass that implements matchesSafely - * is not the class that binds <T> to a type. + * Use this constructor if the subclass that implements matchesSafely + * is not the class that binds <T> to a type. + * * @param typeFinder A type finder to extract the type */ protected TypeSafeMatcher(ReflectiveTypeFinder typeFinder) { - this.expectedType = typeFinder.findExpectedType(getClass()); + this.expectedType = typeFinder.findExpectedType(getClass()); } - + /** - * Subclasses should implement this. The item will already have been checked for - * the specific type and will never be null. + * Check if the item matches. The item will already have been checked for + * the specific type and will never be null. Subclasses should implement this. + * + * @param item the type safe item to match against. + * @return boolean true/false depending if item matches matcher. */ protected abstract boolean matchesSafely(T item); - + /** - * Subclasses should override this. The item will already have been checked for - * the specific type and will never be null. + * Describe the mismatch. The item will already have been checked for + * the specific type and will never be null. Subclasses should override this. + * + * @param item + * the type safe item to match against. + * @param mismatchDescription + * the mismatch description. */ protected void describeMismatchSafely(T item, Description mismatchDescription) { super.describeMismatch(item, mismatchDescription); } - + /** * Methods made final to prevent accidental override. * If you need to override this, there's no point on extending TypeSafeMatcher. * Instead, extend the {@link BaseMatcher}. + * + * @param item + * the type safe item to match against. */ @Override @SuppressWarnings({"unchecked"}) @@ -66,7 +81,7 @@ public final boolean matches(Object item) { && expectedType.isInstance(item) && matchesSafely((T) item); } - + @SuppressWarnings("unchecked") @Override final public void describeMismatch(Object item, Description description) { @@ -82,4 +97,5 @@ final public void describeMismatch(Object item, Description description) { describeMismatchSafely((T)item, description); } } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/HasProperty.java b/hamcrest/src/main/java/org/hamcrest/beans/HasProperty.java similarity index 69% rename from hamcrest-library/src/main/java/org/hamcrest/beans/HasProperty.java rename to hamcrest/src/main/java/org/hamcrest/beans/HasProperty.java index 320a49ef6..8494c9a39 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/beans/HasProperty.java +++ b/hamcrest/src/main/java/org/hamcrest/beans/HasProperty.java @@ -5,10 +5,11 @@ import org.hamcrest.TypeSafeMatcher; /** - * A Matcher that checks that an object has a JavaBean property - * with the specified name. If an error occurs during introspection - * of the object then this is treated as a mismatch. + * A matcher that checks if an object has a JavaBean property with the + * specified name. If an error occurs during introspection of the object + * then this is treated as a mismatch. * + * @param The Matcher type. * @author Iain McGinniss * @author Nat Pryce * @author Steve Freeman @@ -17,6 +18,11 @@ public class HasProperty extends TypeSafeMatcher { private final String propertyName; + /** + * Constructor, best called from {@link #hasProperty(String)}. + * @param propertyName the name of the property + * @see #hasProperty(String) + */ public HasProperty(String propertyName) { this.propertyName = propertyName; } @@ -24,7 +30,8 @@ public HasProperty(String propertyName) { @Override public boolean matchesSafely(T obj) { try { - return PropertyUtil.getPropertyDescriptor(propertyName, obj) != null; + return PropertyUtil.getPropertyDescriptor(propertyName, obj) != null || + PropertyUtil.getMethodDescriptor(propertyName, obj) != null; } catch (IllegalArgumentException e) { return false; } @@ -45,12 +52,15 @@ public void describeTo(Description description) { * with the specified name. * For example: *
    assertThat(myBean, hasProperty("foo"))
    - * + * + * @param + * the matcher type. * @param propertyName * the name of the JavaBean property that examined beans should possess + * @return The matcher. */ public static Matcher hasProperty(String propertyName) { - return new HasProperty(propertyName); + return new HasProperty<>(propertyName); } } diff --git a/hamcrest/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java b/hamcrest/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java new file mode 100644 index 000000000..f45c1264d --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/beans/HasPropertyWithValue.java @@ -0,0 +1,211 @@ +package org.hamcrest.beans; + +import org.hamcrest.Condition; +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +import java.beans.FeatureDescriptor; +import java.beans.MethodDescriptor; +import java.beans.PropertyDescriptor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.List; +import java.util.ListIterator; + +import static org.hamcrest.Condition.matched; +import static org.hamcrest.Condition.notMatched; +import static org.hamcrest.beans.PropertyUtil.NO_ARGUMENTS; + +/** + *

    A matcher that checks if an object has a JavaBean property with the + * specified name and an expected value. This is useful for when objects are + * created within code under test and passed to a mock object, and you wish + * to assert that the created object has certain properties. + *

    + * + *

    Example Usage

    + * Consider the situation where we have a class representing a person, which + * follows the basic JavaBean convention of having get() and possibly set() + * methods for its properties: + *
    {@code  public class Person {
    + *   private String name;
    + *   public Person(String person) {
    + *     this.person = person;
    + *   }
    + *   public String getName() {
    + *     return name;
    + *   }
    + * } }
    + * + * And that these person objects are generated within a piece of code under test + * (a class named PersonGenerator). This object is sent to one of our mock objects + * which overrides the PersonGenerationListener interface: + *
    {@code  public interface PersonGenerationListener {
    + *   public void personGenerated(Person person);
    + * } }
    + * + * In order to check that the code under test generates a person with name + * "Iain" we would do the following: + *
    {@code  Mock personGenListenerMock = mock(PersonGenerationListener.class);
    + * personGenListenerMock.expects(once()).method("personGenerated").with(and(isA(Person.class), hasProperty("Name", eq("Iain")));
    + * PersonGenerationListener listener = (PersonGenerationListener)personGenListenerMock.proxy(); }
    + * + *

    If an exception is thrown by the getter method for a property, the property + * does not exist, is not readable, or a reflection related exception is thrown + * when trying to invoke it then this is treated as an evaluation failure and + * the matches method will return false. + *

    + *

    This matcher class will also work with JavaBean objects that have explicit + * bean descriptions via an associated BeanInfo description class. + * See https://docs.oracle.com/javase/8/docs/technotes/guides/beans/index.html for + * more information on JavaBeans. + *

    + * + * @param the Matcher type + * @author Iain McGinniss + * @author Nat Pryce + * @author Steve Freeman + * @author cristcost at github + */ +public class HasPropertyWithValue extends TypeSafeDiagnosingMatcher { + + private static final Condition.Step WITH_READ_METHOD = withReadMethod(); + private final String propertyName; + private final Matcher valueMatcher; + private final String messageFormat; + + /** + * Constructor, best called from {@link #hasProperty(String, Matcher)} or + * {@link #hasPropertyAtPath(String, Matcher)}. + * @param propertyName the name of the property + * @param valueMatcher matcher for the expected value + */ + public HasPropertyWithValue(String propertyName, Matcher valueMatcher) { + this(propertyName, valueMatcher, " property '%s' "); + } + + /** + * Constructor, best called from {@link #hasProperty(String, Matcher)} or + * {@link #hasPropertyAtPath(String, Matcher)}. + * @param propertyName the name of the property + * @param valueMatcher matcher for the expected value + * @param messageFormat format string for the description + */ + public HasPropertyWithValue(String propertyName, Matcher valueMatcher, String messageFormat) { + this.propertyName = propertyName; + this.valueMatcher = nastyGenericsWorkaround(valueMatcher); + this.messageFormat = messageFormat; + } + + @Override + public boolean matchesSafely(T bean, Description mismatch) { + return propertyOn(bean, mismatch) + .and(WITH_READ_METHOD) + .and(withPropertyValue(bean)) + .matching(valueMatcher, String.format(messageFormat, propertyName)); + } + + @Override + public void describeTo(Description description) { + description.appendText("hasProperty(").appendValue(propertyName).appendText(", ") + .appendDescriptionOf(valueMatcher).appendText(")"); + } + + private Condition propertyOn(T bean, Description mismatch) { + FeatureDescriptor property = PropertyUtil.getPropertyDescriptor(propertyName, bean); + if (property == null) { + property = PropertyUtil.getMethodDescriptor(propertyName, bean); + } + if (property == null) { + mismatch.appendText("No property \"" + propertyName + "\""); + return notMatched(); + } + + return matched(property, mismatch); + } + + private Condition.Step withPropertyValue(final T bean) { + return (readMethod, mismatch) -> { + try { + return matched(readMethod.invoke(bean, NO_ARGUMENTS), mismatch); + } catch (InvocationTargetException e) { + mismatch + .appendText("Calling '") + .appendText(readMethod.toString()) + .appendText("': ") + .appendValue(e.getTargetException().getMessage()); + return notMatched(); + } catch (Exception e) { + throw new IllegalStateException( + "Calling: '" + readMethod + "' should not have thrown " + e); + } + }; + } + + @SuppressWarnings("unchecked") + private static Matcher nastyGenericsWorkaround(Matcher valueMatcher) { + return (Matcher) valueMatcher; + } + + private static Condition.Step withReadMethod() { + return (property, mismatch) -> { + final Method readMethod = property instanceof PropertyDescriptor ? + ((PropertyDescriptor) property).getReadMethod() : + (((MethodDescriptor) property).getMethod()); + if (null == readMethod || readMethod.getReturnType() == void.class) { + mismatch.appendText("property \"" + property.getName() + "\" is not readable"); + return notMatched(); + } + return matched(readMethod, mismatch); + }; + } + + /** + * Creates a matcher that matches when the examined object has a JavaBean property + * with the specified name whose value satisfies the specified matcher. + * For example: + *
    assertThat(myBean, hasProperty("foo", equalTo("bar"))
    + * + * @param + * the matcher type. + * @param propertyName + * the name of the JavaBean property that examined beans should possess + * @param valueMatcher + * a matcher for the value of the specified property of the examined bean + * @return The matcher. + */ + public static Matcher hasProperty(String propertyName, Matcher valueMatcher) { + return new HasPropertyWithValue<>(propertyName, valueMatcher); + } + + /** + * Creates a matcher that matches when the examined object is a graph of + * JavaBean objects that can be navigated along the declared dot-separated path + * and the final element of that path is a JavaBean property whose value satisfies the + * specified matcher. + * For example: + *
    assertThat(myBean, hasProperty("foo.bar.baz", equalTo("a property value"))
    + * + * @param + * the matcher type. + * @param path + * the dot-separated path from the examined object to the JavaBean property + * @param valueMatcher + * a matcher for the value of the specified property of the examined bean + * @return The matcher. + */ + public static Matcher hasPropertyAtPath(String path, Matcher valueMatcher) { + List properties = Arrays.asList(path.split("\\.")); + ListIterator iterator = + properties.listIterator(properties.size()); + + Matcher ret = valueMatcher; + while (iterator.hasPrevious()) { + ret = new HasPropertyWithValue<>(iterator.previous(), ret, "%s."); + } + return ret; + } + +} diff --git a/hamcrest/src/main/java/org/hamcrest/beans/PropertyUtil.java b/hamcrest/src/main/java/org/hamcrest/beans/PropertyUtil.java new file mode 100644 index 000000000..40d5a37db --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/beans/PropertyUtil.java @@ -0,0 +1,136 @@ +package org.hamcrest.beans; + +import java.beans.IntrospectionException; +import java.beans.Introspector; +import java.beans.MethodDescriptor; +import java.beans.PropertyDescriptor; +import java.lang.reflect.Field; +import java.util.Arrays; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Utility class with static methods for accessing properties on JavaBean objects. + * See https://docs.oracle.com/javase/8/docs/technotes/guides/beans/index.html for + * more information on JavaBeans. + * + * @author Iain McGinniss + * @author Steve Freeman + * @author Uno Kim + * @since 1.1.0 + */ +public class PropertyUtil { + + private PropertyUtil() { + } + + /** + * Returns the description of the property with the provided + * name on the provided object's interface. + * + * @param propertyName + * the bean property name. + * @param fromObj + * the object to check. + * @return the descriptor of the property, or null if the property does not exist. + * @throws IllegalArgumentException if there's an introspection failure + */ + public static PropertyDescriptor getPropertyDescriptor(String propertyName, Object fromObj) throws IllegalArgumentException { + for (PropertyDescriptor property : propertyDescriptorsFor(fromObj, null)) { + if (property.getName().equals(propertyName)) { + return property; + } + } + + return null; + } + + /** + * Returns all the property descriptors for the class associated with the given object + * + * @param fromObj Use the class of this object + * @param stopClass Don't include any properties from this ancestor class upwards. + * @return Property descriptors + * @throws IllegalArgumentException if there's an introspection failure + */ + public static PropertyDescriptor[] propertyDescriptorsFor(Object fromObj, Class stopClass) throws IllegalArgumentException { + try { + return Introspector.getBeanInfo(fromObj.getClass(), stopClass).getPropertyDescriptors(); + } catch (IntrospectionException e) { + throw new IllegalArgumentException("Could not get property descriptors for " + fromObj.getClass(), e); + } + } + + /** + * Returns the description of the read accessor method with the provided + * name on the provided object's interface. + * This is what you need when you try to find a property from a target object + * when it doesn't follow standard JavaBean specification, a Java Record for example. + * + * @param propertyName the object property name. + * @param fromObj the object to check. + * @return the descriptor of the method, or null if the method does not exist. + * @throws IllegalArgumentException if there's an introspection failure + * @see Java Records + * + */ + public static MethodDescriptor getMethodDescriptor(String propertyName, Object fromObj) throws IllegalArgumentException { + for (MethodDescriptor method : recordReadAccessorMethodDescriptorsFor(fromObj, null)) { + if (method.getName().equals(propertyName)) { + return method; + } + } + + return null; + } + + /** + * Returns read accessor method descriptors for the class associated with the given object. + * This is useful when you find getter methods for the fields from the object + * when it doesn't follow standard JavaBean specification, a Java Record for example. + * Be careful as this doesn't return standard JavaBean getter methods, like a method starting with {@code get-}. + * + * @param fromObj Use the class of this object + * @param stopClass Don't include any properties from this ancestor class upwards. + * @return Method descriptors for read accessor methods + * @throws IllegalArgumentException if there's an introspection failure + */ + public static MethodDescriptor[] recordReadAccessorMethodDescriptorsFor(Object fromObj, Class stopClass) throws IllegalArgumentException { + try { + Set recordComponentNames = getFieldNames(fromObj); + MethodDescriptor[] methodDescriptors = Introspector.getBeanInfo(fromObj.getClass(), stopClass).getMethodDescriptors(); + + return Arrays.stream(methodDescriptors) + .filter(x -> recordComponentNames.contains(x.getDisplayName())) + .filter(x -> x.getMethod().getReturnType() != void.class) + .filter(x -> x.getMethod().getParameterCount() == 0) + .toArray(MethodDescriptor[]::new); + } catch (IntrospectionException e) { + throw new IllegalArgumentException("Could not get method descriptors for " + fromObj.getClass(), e); + } + } + + /** + * Returns the field names of the given object. + * It can be the names of the record components of Java Records, for example. + * + * @param fromObj the object to check + * @return The field names + * @throws IllegalArgumentException if there's a security issue reading the fields + */ + public static Set getFieldNames(Object fromObj) throws IllegalArgumentException { + try { + return Arrays.stream(fromObj.getClass().getDeclaredFields()) + .map(Field::getName) + .collect(Collectors.toSet()); + } catch (SecurityException e) { + throw new IllegalArgumentException("Could not get record component names for " + fromObj.getClass(), e); + } + } + + /** + * Empty object array, used for documenting that we are deliberately passing no arguments to a method. + */ + public static final Object[] NO_ARGUMENTS = new Object[0]; + +} diff --git a/hamcrest/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java b/hamcrest/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java new file mode 100644 index 000000000..fbb0175fe --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java @@ -0,0 +1,183 @@ +package org.hamcrest.beans; + +import org.hamcrest.Description; +import org.hamcrest.DiagnosingMatcher; +import org.hamcrest.Matcher; + +import java.beans.FeatureDescriptor; +import java.beans.MethodDescriptor; +import java.beans.PropertyDescriptor; +import java.lang.reflect.Method; +import java.util.*; + +import static java.util.Arrays.asList; +import static org.hamcrest.beans.PropertyUtil.NO_ARGUMENTS; +import static org.hamcrest.beans.PropertyUtil.propertyDescriptorsFor; +import static org.hamcrest.beans.PropertyUtil.recordReadAccessorMethodDescriptorsFor; +import static org.hamcrest.core.IsEqual.equalTo; + +/** + * A matcher that checks if a given bean has the same property values + * as an example bean. + * @param the matcher value type. + * @see #samePropertyValuesAs(Object, String...) + */ +public class SamePropertyValuesAs extends DiagnosingMatcher { + + private final T expectedBean; + private final Set propertyNames; + private final List propertyMatchers; + private final List ignoredFields; + + /** + * Constructor, best called from {@link #samePropertyValuesAs(Object, String...)}. + * @param expectedBean the bean object with the expected values + * @param ignoredProperties list of property names that should be excluded from the match + */ + @SuppressWarnings("WeakerAccess") + public SamePropertyValuesAs(T expectedBean, List ignoredProperties) { + FeatureDescriptor[] descriptors = propertyDescriptorsFor(expectedBean, Object.class); + if (descriptors == null || descriptors.length == 0) { + descriptors = recordReadAccessorMethodDescriptorsFor(expectedBean, Object.class); + } + + this.expectedBean = expectedBean; + this.ignoredFields = ignoredProperties; + this.propertyNames = propertyNamesFrom(descriptors, ignoredProperties); + this.propertyMatchers = propertyMatchersFor(expectedBean, descriptors, ignoredProperties); + } + + @Override + protected boolean matches(Object actual, Description mismatch) { + return isNotNull(actual, mismatch) + && isCompatibleType(actual, mismatch) + && hasNoExtraProperties(actual, mismatch) + && hasMatchingValues(actual, mismatch); + } + + @Override + public void describeTo(Description description) { + description.appendText("same property values as " + expectedBean.getClass().getSimpleName()) + .appendList(" [", ", ", "]", propertyMatchers); + if (! ignoredFields.isEmpty()) { + description.appendText(" ignoring ") + .appendValueList("[", ", ", "]", ignoredFields); + } + } + + private boolean isCompatibleType(Object actual, Description mismatchDescription) { + if (expectedBean.getClass().isAssignableFrom(actual.getClass())) { + return true; + } + + mismatchDescription.appendText("is incompatible type: " + actual.getClass().getSimpleName()); + return false; + } + + private boolean hasNoExtraProperties(Object actual, Description mismatchDescription) { + Set actualPropertyNames = propertyNamesFrom(propertyDescriptorsFor(actual, Object.class), ignoredFields); + actualPropertyNames.removeAll(propertyNames); + if (!actualPropertyNames.isEmpty()) { + mismatchDescription.appendText("has extra properties called " + actualPropertyNames); + return false; + } + return true; + } + + private boolean hasMatchingValues(Object actual, Description mismatchDescription) { + for (PropertyMatcher propertyMatcher : propertyMatchers) { + if (!propertyMatcher.matches(actual)) { + propertyMatcher.describeMismatch(actual, mismatchDescription); + return false; + } + } + return true; + } + + private static List propertyMatchersFor(T bean, FeatureDescriptor[] descriptors, List ignoredFields) { + List result = new ArrayList<>(descriptors.length); + for (FeatureDescriptor descriptor : descriptors) { + if (isNotIgnored(ignoredFields, descriptor)) { + result.add(new PropertyMatcher(descriptor, bean)); + } + } + return result; + } + + private static Set propertyNamesFrom(FeatureDescriptor[] descriptors, List ignoredFields) { + HashSet result = new HashSet<>(); + for (FeatureDescriptor descriptor : descriptors) { + if (isNotIgnored(ignoredFields, descriptor)) { + result.add(descriptor.getDisplayName()); + } + } + return result; + } + + private static boolean isNotIgnored(List ignoredFields, FeatureDescriptor propertyDescriptor) { + return ! ignoredFields.contains(propertyDescriptor.getDisplayName()); + } + + @SuppressWarnings("WeakerAccess") + private static class PropertyMatcher extends DiagnosingMatcher { + private final Method readMethod; + private final Matcher matcher; + private final String propertyName; + + public PropertyMatcher(FeatureDescriptor descriptor, Object expectedObject) { + this.propertyName = descriptor.getDisplayName(); + this.readMethod = descriptor instanceof PropertyDescriptor ? + ((PropertyDescriptor) descriptor).getReadMethod() : + ((MethodDescriptor) descriptor).getMethod(); + this.matcher = equalTo(readProperty(readMethod, expectedObject)); + } + + @Override + public boolean matches(Object actual, Description mismatch) { + final Object actualValue = readProperty(readMethod, actual); + if (!matcher.matches(actualValue)) { + mismatch.appendText(propertyName + " "); + matcher.describeMismatch(actualValue, mismatch); + return false; + } + return true; + } + + @Override + public void describeTo(Description description) { + description.appendText(propertyName + ": ").appendDescriptionOf(matcher); + } + } + + private static Object readProperty(Method method, Object target) { + try { + return method.invoke(target, NO_ARGUMENTS); + } catch (Exception e) { + throw new IllegalArgumentException("Could not invoke " + method + " on " + target, e); + } + } + + /** + *

    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. If any properties are marked as ignored, they will be dropped from + * both the expected and actual bean. Note that the ignored properties use JavaBean + * display names, for example "age" rather than method names such as + * "getAge". + *

    + * For example: + *
    {@code
    +     * assertThat(myBean, samePropertyValuesAs(myExpectedBean))
    +     * assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
    +     * }
    + * + * @param the matcher value type. + * @param expectedBean the bean against which examined beans are compared + * @param ignoredProperties do not check any of these named properties. + * @return The matcher. + */ + public static Matcher samePropertyValuesAs(B expectedBean, String... ignoredProperties) { + return new SamePropertyValuesAs<>(expectedBean, asList(ignoredProperties)); + } + +} diff --git a/hamcrest/src/main/java/org/hamcrest/beans/package-info.java b/hamcrest/src/main/java/org/hamcrest/beans/package-info.java new file mode 100644 index 000000000..d122dc661 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/beans/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers of Java Bean properties and their values. + */ +package org.hamcrest.beans; \ No newline at end of file diff --git a/hamcrest/src/main/java/org/hamcrest/collection/ArrayAsIterableMatcher.java b/hamcrest/src/main/java/org/hamcrest/collection/ArrayAsIterableMatcher.java new file mode 100644 index 000000000..5ea3e2d3e --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/collection/ArrayAsIterableMatcher.java @@ -0,0 +1,67 @@ +package org.hamcrest.collection; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.hamcrest.TypeSafeMatcher; + +import java.util.Collection; + +import static java.util.Arrays.asList; + +/** + * A matcher for arrays that matches when each item in the examined array satisfies the + * corresponding matcher in the specified list of matchers. + * + * @param the collection element type + * @author Steve Freeman 2016 http://www.hamcrest.com + */ +public class ArrayAsIterableMatcher extends TypeSafeMatcher { + + /** + * The matchers to match iterable against + */ + protected final TypeSafeDiagnosingMatcher> iterableMatcher; + + private final String message; + + /** + * The matchers to match items against + */ + protected final Collection> matchers; + + + /** + * Constructor, best called from {@link ArrayMatching#arrayContainingInAnyOrder(Matcher[])}. + * @param iterableMatcher the iterable matchers + * @param matchers the matchers + * @param message the description of this matcher + * @see ArrayMatching#arrayContainingInAnyOrder(Matcher[]) + */ + public ArrayAsIterableMatcher( + TypeSafeDiagnosingMatcher> iterableMatcher, + Collection> matchers, + String message) + { + this.matchers = matchers; + this.iterableMatcher = iterableMatcher; + this.message = message; + } + + @Override + public boolean matchesSafely(E[] item) { + return iterableMatcher.matches(asList(item)); + } + + @Override + public void describeMismatchSafely(E[] item, Description mismatchDescription) { + iterableMatcher.describeMismatch(asList(item), mismatchDescription); + } + + @Override + public void describeTo(Description description) { + description.appendList("[", ", ", "]", matchers) + .appendText(" ").appendText(message); + } + +} diff --git a/hamcrest/src/main/java/org/hamcrest/collection/ArrayMatching.java b/hamcrest/src/main/java/org/hamcrest/collection/ArrayMatching.java new file mode 100644 index 000000000..f160ce7be --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/collection/ArrayMatching.java @@ -0,0 +1,207 @@ +package org.hamcrest.collection; + +import org.hamcrest.Matcher; +import org.hamcrest.internal.NullSafety; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import static java.util.Arrays.asList; +import static org.hamcrest.core.IsEqual.equalTo; + +/** + * Collected helper code for converting matchers between lists and iterables. + * + * @author Steve Freeman 2016 http://www.hamcrest.com + */ +public class ArrayMatching { + private ArrayMatching() { + } + + /** + * Creates a matcher for arrays that matches when the examined array contains at least one item + * that is matched by the specified elementMatcher. Whilst matching, the traversal + * of the examined array will stop as soon as a matching element is found. + * For example: + *
    assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))
    + * + * @param + * the matcher type. + * @param elementMatcher + * the matcher to apply to elements in examined arrays + * @return The matcher. + */ + public static Matcher hasItemInArray(Matcher elementMatcher) { + return new HasItemInArray<>(elementMatcher); + } + + /** + * A shortcut to the frequently used hasItemInArray(equalTo(x)). + * For example: + *
    assertThat(hasItemInArray(x))
    + * instead of: + *
    assertThat(hasItemInArray(equalTo(x)))
    + * + * @param + * the matcher type. + * @param element + * the element that should be present in examined arrays + * @return The matcher. + */ + public static Matcher hasItemInArray(T element) { + return hasItemInArray(equalTo(element)); + } + + /** + *

    + * Creates an order agnostic matcher for arrays that matches when each item in the + * examined array satisfies one matcher anywhere in the specified matchers. + * For a positive match, the examined array must be of the same length as the number of + * specified matchers. + *

    + *

    + * N.B. each of the specified matchers will only be used once during a given examination, so be + * careful when specifying matchers that may be satisfied by more than one entry in an examined + * array. + *

    + *

    + * For example: + *

    + *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
    + * + * @param + * the matcher type. + * @param itemMatchers + * a list of matchers, each of which must be satisfied by an entry in an examined array + * @return The matcher. + */ + @SafeVarargs + public static Matcher arrayContainingInAnyOrder(Matcher... itemMatchers) { + return arrayContainingInAnyOrder((Collection) asList(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. + * For a positive match, the examined array must be of the same length as the specified collection + * of matchers. + *

    + *

    + * N.B. each matcher in the specified collection will only be used once during a given + * examination, so be careful when specifying matchers that may be satisfied by more than + * one entry in an examined array. + *

    + *

    + * For example: + *

    + *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
    + * + * @param + * the matcher type. + * @param itemMatchers + * a list of matchers, each of which must be satisfied by an item provided by an examined array + * @return The matcher. + */ + public static Matcher arrayContainingInAnyOrder(Collection> itemMatchers) { + return new ArrayAsIterableMatcher<>(new IsIterableContainingInAnyOrder<>(itemMatchers), itemMatchers, "in any order"); + } + + /** + *

    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. + * For a positive match, the examined array must be of the same length as the number of + * specified items. + *

    + *

    N.B. each of the specified items will only be used once during a given examination, so be + * careful when specifying items that may be equal to more than one entry in an examined + * array. + *

    + *

    + * For example: + *

    + *
    assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
    + * + * @param + * the matcher type. + * @param items + * the items that must equal the entries of an examined array, in any order + * @return The matcher. + */ + @SafeVarargs + public static Matcher arrayContainingInAnyOrder(E... items) { + return arrayContainingInAnyOrder(asEqualMatchers(items)); + } + + /** + * Creates a matcher for arrays that matches when each item in the examined array is + * logically equal to the corresponding item in the specified items. For a positive match, + * the examined array must be of the same length as the number of specified items. + * For example: + *
    assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
    + * + * @param + * the matcher type. + * @param items + * the items that must equal the items within an examined array + * @return The matcher. + */ + @SafeVarargs + public static Matcher arrayContaining(E... items) { + return arrayContaining(asEqualMatchers(items)); + } + /** + * Creates a matcher for arrays that matches when each item in the examined array satisfies the + * corresponding matcher in the specified matchers. For a positive match, the examined array + * must be of the same length as the number of specified matchers. + * For example: + *
    assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))
    + * + * @param + * the matcher type. + * @param itemMatchers + * the matchers that must be satisfied by the items in the examined array + * @return The matcher. + */ + @SafeVarargs + public static Matcher arrayContaining(Matcher... itemMatchers) { + //required for JDK 1.6 + //noinspection RedundantTypeArguments + final List> nullSafeWithExplicitTypeMatchers = NullSafety.nullSafe(itemMatchers); + + return arrayContaining(nullSafeWithExplicitTypeMatchers); + } + + /** + * Creates a matcher for arrays that matches when each item in the examined array satisfies the + * corresponding matcher in the specified list of matchers. For a positive match, the examined array + * must be of the same length as the specified list of matchers. + * For example: + *
    assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    + * + * @param + * the matcher type. + * @param itemMatchers + * a list of matchers, each of which must be satisfied by the corresponding item in an examined array + * @return The matcher. + */ + public static Matcher arrayContaining(List> itemMatchers) { + return new ArrayAsIterableMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, ""); + } + + /** + * Converts item array to corresponding array of equalTo matchers + * @param items items to convert + * @return list of corresponding equaTo matchers + * @param type of array items + */ + public static List> asEqualMatchers(E[] items) { + final List> matchers = new ArrayList<>(); + for (E item : items) { + matchers.add(equalTo(item)); + } + return matchers; + } + +} diff --git a/hamcrest/src/main/java/org/hamcrest/collection/HasItemInArray.java b/hamcrest/src/main/java/org/hamcrest/collection/HasItemInArray.java new file mode 100644 index 000000000..6e96ae216 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/collection/HasItemInArray.java @@ -0,0 +1,48 @@ +package org.hamcrest.collection; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.hamcrest.TypeSafeMatcher; +import org.hamcrest.core.IsIterableContaining; + +import static java.util.Arrays.asList; + +/** + * Matches if an array contains an item satisfying a nested matcher. + * + * @param the array element type + */ +public class HasItemInArray extends TypeSafeMatcher { + + private final Matcher elementMatcher; + private final TypeSafeDiagnosingMatcher> collectionMatcher; + + /** + * Constructor, best called from {@link ArrayMatching}. + * @param elementMatcher matcher for the expected item + * @see ArrayMatching#hasItemInArray(Matcher) + */ + public HasItemInArray(Matcher elementMatcher) { + this.elementMatcher = elementMatcher; + this.collectionMatcher = new IsIterableContaining<>(elementMatcher); + } + + @Override + public boolean matchesSafely(T[] actual) { + return collectionMatcher.matches(asList(actual)); + } + + @Override + public void describeMismatchSafely(T[] actual, Description mismatchDescription) { + collectionMatcher.describeMismatch(asList(actual), mismatchDescription); + } + + @Override + public void describeTo(Description description) { + description + .appendText("an array containing ") + .appendDescriptionOf(elementMatcher); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java b/hamcrest/src/main/java/org/hamcrest/collection/IsArray.java similarity index 85% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsArray.java index 38f5d915d..fb123bd39 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArray.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsArray.java @@ -9,22 +9,29 @@ /** * Matcher for array whose elements satisfy a sequence of matchers. * The array size must equal the number of element matchers. + * + * @param the array element type */ public class IsArray extends TypeSafeMatcher { + private final Matcher[] elementMatchers; - + + /** + * Constructor, best called from {@link #array(Matcher[])}. + * @param elementMatchers matchers for expected values + */ public IsArray(Matcher[] elementMatchers) { this.elementMatchers = elementMatchers.clone(); } - + @Override 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; } @@ -46,15 +53,17 @@ public void describeMismatchSafely(T[] actual, Description mismatchDescription) @Override @SuppressWarnings("unchecked") public void describeTo(Description description) { - description.appendList(descriptionStart(), descriptionSeparator(), descriptionEnd(), + 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. + * + * @return The description prefix. */ protected String descriptionStart() { return "["; @@ -62,9 +71,11 @@ protected String descriptionStart() { /** * Returns the string that separates the elements in the description. - * + * * Can be overridden in subclasses to customise how the matcher is * described. + * + * @return The description separator. */ protected String descriptionSeparator() { return ", "; @@ -72,26 +83,31 @@ protected String descriptionSeparator() { /** * Returns the string that ends the description. - * + * * Can be overridden in subclasses to customise how the matcher is * described. + * + * @return The description suffix. */ protected String descriptionEnd() { return "]"; } - + /** * Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches * positively only if the number of matchers specified is equal to the length of the examined array and * each matcher[i] is satisfied by array[i]. * For example: *
    assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))
    - * + * + * @param + * the matcher type. * @param elementMatchers * the matchers that the elements of examined arrays should satisfy + * @return The matcher. */ public static IsArray array(Matcher... elementMatchers) { - return new IsArray(elementMatchers); + return new IsArray<>(elementMatchers); } } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java similarity index 72% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java index 5748820d4..82b4b59ce 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInAnyOrder.java @@ -11,12 +11,23 @@ import static org.hamcrest.core.IsEqual.equalTo; +/** + * @param the collection element type + * @deprecated As of release 2.1, replaced by {@link ArrayMatching}. + */ +@Deprecated public class IsArrayContainingInAnyOrder extends TypeSafeMatcher { + private final IsIterableContainingInAnyOrder iterableMatcher; private final Collection> matchers; + /** + * Constructor, best called from {@link #arrayContainingInAnyOrder(Object[])}, + * {@link #arrayContainingInAnyOrder(Matcher[])}, or {@link #arrayContainingInAnyOrder(Collection)}. + * @param matchers matchers for expected values + */ public IsArrayContainingInAnyOrder(Collection> matchers) { - this.iterableMatcher = new IsIterableContainingInAnyOrder(matchers); + this.iterableMatcher = new IsIterableContainingInAnyOrder<>(matchers); this.matchers = matchers; } @@ -24,11 +35,11 @@ public IsArrayContainingInAnyOrder(Collection> matchers) { public boolean matchesSafely(E[] item) { return iterableMatcher.matches(Arrays.asList(item)); } - + @Override public void describeMismatchSafely(E[] item, Description mismatchDescription) { iterableMatcher.describeMismatch(Arrays.asList(item), mismatchDescription); - } + }; @Override public void describeTo(Description description) { @@ -37,76 +48,79 @@ public void describeTo(Description description) { } /** - *

    * Creates an order agnostic matcher for arrays that matches when each item in the * examined array satisfies one matcher anywhere in the specified matchers. * For a positive match, the examined array must be of the same length as the number of * specified matchers. - *

    *

    * N.B. each of the specified matchers will only be used once during a given examination, so be * careful when specifying matchers that may be satisfied by more than one entry in an examined * array. - *

    *

    * For example: - *

    *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContainingInAnyOrder(Matcher[])}. + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an entry in an examined array + * @return The matcher. */ public static Matcher arrayContainingInAnyOrder(Matcher... itemMatchers) { - return arrayContainingInAnyOrder(Arrays.asList(itemMatchers)); + return arrayContainingInAnyOrder((Collection) Arrays.asList(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. * For a positive match, the examined array must be of the same length as the specified collection * of matchers. - *

    *

    * N.B. each matcher in the specified collection will only be used once during a given * examination, so be careful when specifying matchers that may be satisfied by more than * one entry in an examined array. - *

    *

    * For example: - *

    *
    assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContainingInAnyOrder(Collection)}. + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined array + * @return The matcher. */ public static Matcher arrayContainingInAnyOrder(Collection> itemMatchers) { - return new IsArrayContainingInAnyOrder(itemMatchers); + return new IsArrayContainingInAnyOrder<>(itemMatchers); } /** - *

    Creates an order agnostic matcher for arrays that matches when each item in the + * 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. * For a positive match, the examined array must be of the same length as the number of * specified items. - *

    - *

    N.B. each of the specified items will only be used once during a given examination, so be + *

    + * N.B. each of the specified items will only be used once during a given examination, so be * careful when specifying items that may be equal to more than one entry in an examined * array. - *

    *

    * For example: - *

    *
    assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContainingInAnyOrder(Object[])}. + * @param + * the matcher type. * @param items * the items that must equal the entries of an examined array, in any order + * @return The matcher. */ public static Matcher arrayContainingInAnyOrder(E... items) { - List> matchers = new ArrayList>(); + List> matchers = new ArrayList<>(); for (E item : items) { matchers.add(equalTo(item)); } - return new IsArrayContainingInAnyOrder(matchers); + return new IsArrayContainingInAnyOrder<>(matchers); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java similarity index 70% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java index 849920ac8..3c748cfbe 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayContainingInOrder.java @@ -3,7 +3,6 @@ import org.hamcrest.Description; import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher; -import org.hamcrest.internal.NullSafety; import java.util.ArrayList; import java.util.Collection; @@ -12,12 +11,23 @@ import static java.util.Arrays.asList; import static org.hamcrest.core.IsEqual.equalTo; +/** + * @param the array element type + * + * @deprecated As of release 2.1, replaced by {@link ArrayMatching}. + */ public class IsArrayContainingInOrder extends TypeSafeMatcher { + private final Collection> matchers; private final IsIterableContainingInOrder iterableMatcher; + /** + * Constructor, best called from {@link #arrayContaining(Object[])}, + * {@link #arrayContaining(Matcher[])}, or {@link #arrayContaining(List)}. + * @param matchers matchers for expected values + */ public IsArrayContainingInOrder(List> matchers) { - this.iterableMatcher = new IsIterableContainingInOrder(matchers); + this.iterableMatcher = new IsIterableContainingInOrder<>(matchers); this.matchers = matchers; } @@ -25,7 +35,7 @@ public IsArrayContainingInOrder(List> matchers) { public boolean matchesSafely(E[] item) { return iterableMatcher.matches(asList(item)); } - + @Override public void describeMismatchSafely(E[] item, Description mismatchDescription) { iterableMatcher.describeMismatch(asList(item), mismatchDescription); @@ -37,17 +47,22 @@ public void describeTo(Description description) { } /** - * Creates a matcher for arrays that matches when each item in the examined array is + * Creates a matcher for arrays that matcheswhen each item in the examined array is * logically equal to the corresponding item in the specified items. For a positive match, * the examined array must be of the same length as the number of specified items. + *

    * For example: *

    assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContaining(Object[])}. + * @param + * the matcher type. * @param items * the items that must equal the items within an examined array + * @return The matcher. */ public static Matcher arrayContaining(E... items) { - List> matchers = new ArrayList>(); + List> matchers = new ArrayList<>(); for (E item : items) { matchers.add(equalTo(item)); } @@ -58,32 +73,38 @@ public static Matcher arrayContaining(E... items) { * Creates a matcher for arrays that matches when each item in the examined array satisfies the * corresponding matcher in the specified matchers. For a positive match, the examined array * must be of the same length as the number of specified matchers. + *

    * For example: *

    assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContaining(Matcher[])}. + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items in the examined array + * @return The matcher. */ public static Matcher arrayContaining(Matcher... itemMatchers) { - //required for JDK 1.6 - //noinspection RedundantTypeArguments - final List> nullSafeWithExplicitTypeMatchers = NullSafety.nullSafe(itemMatchers); - - return arrayContaining(nullSafeWithExplicitTypeMatchers); + return arrayContaining((List) asList(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. For a positive match, the examined array * must be of the same length as the specified list of matchers. + *

    * For example: *

    assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    - * + * + * @deprecated As of version 2.1, use {@link ArrayMatching#arrayContaining(List)}. + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the corresponding item in an examined array + * @return The matcher. */ public static Matcher arrayContaining(List> itemMatchers) { - return new IsArrayContainingInOrder(itemMatchers); + return new IsArrayContainingInOrder<>(itemMatchers); } } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayWithSize.java b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayWithSize.java similarity index 71% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayWithSize.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsArrayWithSize.java index b3a0b1fdf..9c2dbb85c 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayWithSize.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsArrayWithSize.java @@ -7,9 +7,17 @@ import static org.hamcrest.core.IsEqual.equalTo; /** - * Matches if array size satisfies a nested matcher. + * Matches if array size satisfies a size matcher. + * + * @param the array element type */ public class IsArrayWithSize extends FeatureMatcher { + + /** + * Constructor, best called from {@link #emptyArray()}, + * {@link #arrayWithSize(int)} or {@link #arrayWithSize(Matcher)}. + * @param sizeMatcher the expected size + */ public IsArrayWithSize(Matcher sizeMatcher) { super(sizeMatcher, "an array with size","array size"); } @@ -24,12 +32,14 @@ protected Integer featureValueOf(E[] actual) { * satisfies the specified matcher. * For example: *
    assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
    - * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the length of an examined array + * @return The matcher. */ public static Matcher arrayWithSize(Matcher sizeMatcher) { - return new IsArrayWithSize(sizeMatcher); + return new IsArrayWithSize<>(sizeMatcher); } /** @@ -37,9 +47,12 @@ public static Matcher arrayWithSize(Matcher sizeMatche * equals the specified size. * For example: *
    assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
    - * + * + * @param + * the matcher type. * @param size * the length that an examined array must have for a positive match + * @return The matcher. */ public static Matcher arrayWithSize(int size) { return arrayWithSize(equalTo(size)); @@ -50,10 +63,13 @@ public static Matcher arrayWithSize(int size) { * is zero. * For example: *
    assertThat(new String[0], emptyArray())
    - * + * + * @param + * the matcher type. + * @return The matcher. */ public static Matcher emptyArray() { - Matcher isEmpty = arrayWithSize(0); - return describedAs("an empty array", isEmpty); + return describedAs("an empty array", IsArrayWithSize.arrayWithSize(0)); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java b/hamcrest/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java similarity index 76% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java index f12f57c49..ce403a7d7 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsCollectionWithSize.java @@ -9,8 +9,15 @@ /** * Matches if collection size satisfies a nested matcher. + * + * @param the collection element type */ public class IsCollectionWithSize extends FeatureMatcher, Integer> { + + /** + * Constructor, best called from {@link #hasSize(int)} or {@link #hasSize(Matcher)}. + * @param sizeMatcher the expected size + */ public IsCollectionWithSize(Matcher sizeMatcher) { super(sizeMatcher, "a collection with size", "collection size"); } @@ -25,12 +32,15 @@ protected Integer featureValueOf(Collection actual) { * a value that satisfies the specified matcher. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
    - * + * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the size of an examined {@link java.util.Collection} + * @return The matcher. */ public static Matcher> hasSize(Matcher sizeMatcher) { - return new IsCollectionWithSize(sizeMatcher); + return new IsCollectionWithSize<>(sizeMatcher); } /** @@ -38,13 +48,16 @@ public static Matcher> hasSize(Matchersize. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasSize(2))
    - * + * + * @param + * the matcher type. * @param size * the expected size of an examined {@link java.util.Collection} + * @return The matcher. */ @SuppressWarnings({ "rawtypes", "unchecked" }) public static Matcher> hasSize(int size) { - return (Matcher)IsCollectionWithSize.hasSize(equalTo(size)); + return (Matcher)IsCollectionWithSize.hasSize(equalTo(size)); } } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyCollection.java b/hamcrest/src/main/java/org/hamcrest/collection/IsEmptyCollection.java similarity index 78% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyCollection.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsEmptyCollection.java index 481b08c3b..9109d31cb 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyCollection.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsEmptyCollection.java @@ -7,10 +7,19 @@ import java.util.Collection; /** - * Tests if collection is empty. + * Tests if a collection is empty. + * + * @param the collection element type */ public class IsEmptyCollection extends TypeSafeMatcher> { + /** + * Constructor, best called from {@link #empty()} or + * {@link #emptyCollectionOf(Class)}. + */ + public IsEmptyCollection() { + } + @Override public boolean matchesSafely(Collection item) { return item.isEmpty(); @@ -31,10 +40,13 @@ public void describeTo(Description description) { * method returns true. * For example: *
    assertThat(new ArrayList<String>(), is(empty()))
    - * + * + * @param + * the matcher type. + * @return The matcher. */ public static Matcher> empty() { - return new IsEmptyCollection(); + return new IsEmptyCollection<>(); } /** @@ -42,12 +54,16 @@ public static Matcher> empty() { * method returns true. * For example: *
    assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
    - * + * + * @param + * the matcher type. * @param unusedToForceReturnType * the type of the collection's content + * @return The matcher. */ @SuppressWarnings({"unchecked", "UnusedParameters"}) public static Matcher> emptyCollectionOf(Class unusedToForceReturnType) { return (Matcher)empty(); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyIterable.java b/hamcrest/src/main/java/org/hamcrest/collection/IsEmptyIterable.java similarity index 76% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyIterable.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsEmptyIterable.java index 047e670ce..c5aab514c 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsEmptyIterable.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsEmptyIterable.java @@ -5,10 +5,19 @@ import org.hamcrest.TypeSafeMatcher; /** - * Tests if collection is empty. + * Tests if an iterable is empty. + * + * @param the iterable element type */ public class IsEmptyIterable extends TypeSafeMatcher> { + /** + * Constructor, best called from {@link #emptyIterable()} or + * {@link #emptyIterableOf(Class)}. + */ + public IsEmptyIterable() { + } + @Override public boolean matchesSafely(Iterable iterable) { return !iterable.iterator().hasNext(); @@ -27,22 +36,29 @@ public void describeTo(Description description) { * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. * For example: *
    assertThat(new ArrayList<String>(), is(emptyIterable()))
    - * + * + * @param + * the matcher type. + * @return The matcher. */ public static Matcher> emptyIterable() { - return new IsEmptyIterable(); + return new IsEmptyIterable<>(); } /** * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. * For example: *
    assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
    - * + * + * @param + * the matcher type. * @param unusedToForceReturnType * the type of the iterable's content + * @return The matcher. */ @SuppressWarnings({"unchecked", "UnusedParameters"}) public static Matcher> emptyIterableOf(Class unusedToForceReturnType) { return (Matcher)emptyIterable(); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIn.java similarity index 76% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsIn.java index f030cab9a..2be7b2fc5 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIn.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIn.java @@ -7,17 +7,30 @@ import java.util.Arrays; import java.util.Collection; +/** + * Tests if a collection contains a matching object. + * @param the type of the objects in the collection + */ public class IsIn extends BaseMatcher { + private final Collection collection; + /** + * Constructor, best called from {@link #in(Collection)}. + * @param collection the expected element matchers + */ public IsIn(Collection collection) { this.collection = collection; } - + + /** + * Constructor, best called from {@link #in(Object[])}. + * @param elements the expected elements + */ public IsIn(T[] elements) { collection = Arrays.asList(elements); } - + @SuppressWarnings("SuspiciousMethodCalls") @Override public boolean matches(Object o) { @@ -29,36 +42,39 @@ public void describeTo(Description buffer) { buffer.appendText("one of "); buffer.appendValueList("{", ", ", "}", collection); } - + /** * Creates a matcher that matches when the examined object is found within the * specified collection. * For example: *
    assertThat("foo", isIn(Arrays.asList("bar", "foo")))
    - * + * * @deprecated use is(in(...)) instead - * + * @param + * the matcher type. * @param collection * the collection in which matching items must be found - * + * @return The matcher. */ @Deprecated public static Matcher isIn(Collection collection) { return in(collection); } - + /** * Creates a matcher that matches when the examined object is found within the * specified collection. * For example: *
    assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
    - * + * + * @param + * the matcher type. * @param collection * the collection in which matching items must be found - * + * @return The matcher. */ public static Matcher in(Collection collection) { - return new IsIn(collection); + return new IsIn<>(collection); } /** @@ -66,60 +82,69 @@ public static Matcher in(Collection collection) { * specified array. * For example: *
    assertThat("foo", isIn(new String[]{"bar", "foo"}))
    - * + * * @deprecated use is(in(...)) instead - * + * @param + * the matcher type. * @param elements * the array in which matching items must be found - * + * @return The matcher. */ @Deprecated public static Matcher isIn(T[] elements) { return in(elements); } - + /** * Creates a matcher that matches when the examined object is found within the * specified array. * For example: *
    assertThat("foo", is(in(new String[]{"bar", "foo"})))
    - * + * + * @param + * the matcher type. * @param elements * the array in which matching items must be found - * + * @return The matcher. */ public static Matcher in(T[] elements) { - return new IsIn(elements); + return new IsIn<>(elements); } - + /** * Creates a matcher that matches when the examined object is equal to one of the * specified elements. * For example: *
    assertThat("foo", isOneOf("bar", "foo"))
    - * + * * @deprecated use is(oneOf(...)) instead - * + * @param + * the matcher type. * @param elements - * the elements amongst which matching items will be found - * + * the elements amongst which matching items will be found + * @return The matcher. */ + @SafeVarargs @Deprecated public static Matcher isOneOf(T... elements) { return oneOf(elements); } - + /** * Creates a matcher that matches when the examined object is equal to one of the * specified elements. * For example: *
    assertThat("foo", is(oneOf("bar", "foo")))
    - * + * + * @param + * the matcher type. * @param elements - * the elements amongst which matching items will be found - * + * the elements amongst which matching items will be found + * @return The matcher. */ + @SafeVarargs public static Matcher oneOf(T... elements) { return in(elements); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java similarity index 82% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java index 4933e38a8..ad1b951d8 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java @@ -11,25 +11,38 @@ import static org.hamcrest.core.IsEqual.equalTo; +/** + * Tests if an iterable contains matching elements in any order. + * + * @param the type of items in the iterable. + */ public class IsIterableContainingInAnyOrder extends TypeSafeDiagnosingMatcher> { + private final Collection> matchers; + /** + * Constructor, best called from one of the static "containsInAnyOrder" factory methods. + * @param matchers the matchers + * @see #containsInAnyOrder(Object[]) + * @see #containsInAnyOrder(Collection) + * @see #containsInAnyOrder(Matcher[]) + */ public IsIterableContainingInAnyOrder(Collection> matchers) { this.matchers = matchers; } - + @Override protected boolean matchesSafely(Iterable items, Description mismatchDescription) { - final Matching matching = new Matching(matchers, mismatchDescription); + final Matching matching = new Matching<>(matchers, mismatchDescription); for (T item : items) { if (! matching.matches(item)) { return false; } } - + return matching.isFinished(items); } - + @Override public void describeTo(Description description) { description.appendText("iterable with items ") @@ -42,10 +55,10 @@ private static class Matching { private final Description mismatchDescription; public Matching(Collection> matchers, Description mismatchDescription) { - this.matchers = new ArrayList>(matchers); + this.matchers = new ArrayList<>(matchers); this.mismatchDescription = mismatchDescription; } - + public boolean matches(S item) { if (matchers.isEmpty()) { mismatchDescription.appendText("no match for: ").appendValue(item); @@ -92,12 +105,17 @@ private boolean isMatched(S item) { * For example: *

    *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static Matcher> containsInAnyOrder(Matcher... itemMatchers) { - return containsInAnyOrder(Arrays.asList(itemMatchers)); + List> itemMatchersList = Arrays.asList(itemMatchers); + return containsInAnyOrder(itemMatchersList); } /** @@ -116,17 +134,21 @@ public static Matcher> containsInAnyOrder(Matcher *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
    - * + * + * @param + * the matcher type. * @param items * the items that must equal the items provided by an examined {@link Iterable} in any order + * @return The matcher. */ + @SafeVarargs public static Matcher> containsInAnyOrder(T... items) { - List> matchers = new ArrayList>(); + List> matchers = new ArrayList<>(); for (T item : items) { matchers.add(equalTo(item)); } - - return new IsIterableContainingInAnyOrder(matchers); + + return new IsIterableContainingInAnyOrder<>(matchers); } /** @@ -143,12 +165,15 @@ public static Matcher> containsInAnyOrder(T... items) *

    *

    For example:

    *
    assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} + * @return The matcher. */ public static Matcher> containsInAnyOrder(Collection> itemMatchers) { - return new IsIterableContainingInAnyOrder(itemMatchers); + return new IsIterableContainingInAnyOrder<>(itemMatchers); } -} +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java similarity index 81% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java index 630956639..dfb9d1289 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java @@ -8,19 +8,34 @@ import java.util.ArrayList; import java.util.List; -import static java.util.Arrays.asList; -import static org.hamcrest.core.IsEqual.equalTo; - +import static java.util.Collections.singletonList; +import static org.hamcrest.collection.ArrayMatching.asEqualMatchers; + +/** + * Tests if an iterable contains matching elements in order. + * + * @param the type of items in the iterable. + */ public class IsIterableContainingInOrder extends TypeSafeDiagnosingMatcher> { + private final List> matchers; + /** + * Constructor, best called from one of the static "contains" factory methods. + * @param matchers the matchers + * + * @see #contains(Object[]) + * @see #contains(Matcher) + * @see #contains(Matcher[]) + * @see #contains(List) + */ public IsIterableContainingInOrder(List> matchers) { this.matchers = matchers; } @Override protected boolean matchesSafely(Iterable iterable, Description mismatchDescription) { - final MatchSeries matchSeries = new MatchSeries(matchers, mismatchDescription); + final MatchSeries matchSeries = new MatchSeries<>(matchers, mismatchDescription); for (E item : iterable) { if (!matchSeries.matches(item)) { return false; @@ -88,17 +103,16 @@ private void describeMismatch(Matcher matcher, F item) { * must be of the same length as the number of specified items. * For example: *
    assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
    - * + * + * @param + * the matcher type. * @param items * the items that must equal the items provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static Matcher> contains(E... items) { - List> matchers = new ArrayList>(); - for (E item : items) { - matchers.add(equalTo(item)); - } - - return contains(matchers); + return contains(asEqualMatchers(items)); } /** @@ -107,14 +121,17 @@ public static Matcher> contains(E... items) { * For a positive match, the examined iterable must only yield one item. * For example: *
    assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher that must be satisfied by the single item provided by an * examined {@link Iterable} + * @return The matcher. */ @SuppressWarnings("unchecked") public static Matcher> contains(final Matcher itemMatcher) { - return contains(new ArrayList>(asList(itemMatcher))); + return contains(new ArrayList>(singletonList(itemMatcher))); } /** @@ -124,15 +141,19 @@ public static Matcher> contains(final MatcherassertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar"))) - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items provided by an examined {@link Iterable} + * @return The matcher. */ + @SafeVarargs public static Matcher> contains(Matcher... itemMatchers) { // required for JDK 1.6 //noinspection RedundantTypeArguments final List> nullSafeWithExplicitTypeMatchers = NullSafety.nullSafe(itemMatchers); - return contains(nullSafeWithExplicitTypeMatchers); + return contains(nullSafeWithExplicitTypeMatchers); } /** @@ -142,12 +163,16 @@ public static Matcher> contains(Matcher... * must be of the same length as the specified list of matchers. * For example: *
    assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the corresponding item provided by * an examined {@link Iterable} + * @return The matcher. */ public static Matcher> contains(List> itemMatchers) { - return new IsIterableContainingInOrder(itemMatchers); + return new IsIterableContainingInOrder<>(itemMatchers); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java similarity index 83% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java index b0b9db23c..5d39f7527 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInRelativeOrder.java @@ -10,16 +10,26 @@ import static java.util.Arrays.asList; import static org.hamcrest.core.IsEqual.equalTo; +/** + * Tests if an iterable contains matching elements in relative order. + * + * @param the type of items in the iterable. + */ public class IsIterableContainingInRelativeOrder extends TypeSafeDiagnosingMatcher> { private final List> matchers; + /** + * Constructor, best called from {@link #containsInRelativeOrder(Object[])} , + * {@link #containsInRelativeOrder(Matcher[])}, or {@link #containsInRelativeOrder(List)}. + * @param matchers the matchers + */ public IsIterableContainingInRelativeOrder(List> matchers) { this.matchers = matchers; } @Override protected boolean matchesSafely(Iterable iterable, Description mismatchDescription) { - MatchSeriesInRelativeOrder matchSeriesInRelativeOrder = new MatchSeriesInRelativeOrder(matchers, mismatchDescription); + MatchSeriesInRelativeOrder matchSeriesInRelativeOrder = new MatchSeriesInRelativeOrder<>(matchers, mismatchDescription); matchSeriesInRelativeOrder.processItems(iterable); return matchSeriesInRelativeOrder.isFinished(); } @@ -73,12 +83,16 @@ public boolean isFinished() { * corresponding item in the specified items, in the same relative order * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
    - * + * + * @param + * the matcher type. * @param items * the items that must be contained within items provided by an examined {@link Iterable} in the same relative order + * @return The matcher. */ + @SafeVarargs public static Matcher> containsInRelativeOrder(E... items) { - List> matchers = new ArrayList>(); + List> matchers = new ArrayList<>(); for (E item : items) { matchers.add(equalTo(item)); } @@ -92,12 +106,16 @@ public static Matcher> containsInRelativeOrder(E... it * matcher in the specified matchers, in the same relative order. * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers that must be satisfied by the items provided by an examined {@link Iterable} in the same relative order + * @return The matcher. */ + @SafeVarargs public static Matcher> containsInRelativeOrder(Matcher... itemMatchers) { - return containsInRelativeOrder(asList(itemMatchers)); + return containsInRelativeOrder((List) asList(itemMatchers)); } /** @@ -106,12 +124,16 @@ public static Matcher> containsInRelativeOrder(Matcher * matcher in the specified list of matchers, in the same relative order. * For example: *
    assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
    - * + * + * @param + * the matcher type. * @param itemMatchers * a list of matchers, each of which must be satisfied by the items provided by * an examined {@link Iterable} in the same relative order + * @return The matcher. */ public static Matcher> containsInRelativeOrder(List> itemMatchers) { - return new IsIterableContainingInRelativeOrder(itemMatchers); + return new IsIterableContainingInRelativeOrder<>(itemMatchers); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableWithSize.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableWithSize.java similarity index 76% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableWithSize.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsIterableWithSize.java index 0a1535fe9..ea36fb441 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableWithSize.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableWithSize.java @@ -7,12 +7,21 @@ import static org.hamcrest.core.IsEqual.equalTo; +/** + * Matches if iterable size satisfies a size matcher. + * + * @param the iterable element type + */ public class IsIterableWithSize extends FeatureMatcher, Integer> { + /** + * Constructor, best called from {@link #iterableWithSize(int)} or + * {@link #iterableWithSize(Matcher)}. + * @param sizeMatcher checks the expected size of the iterable + */ public IsIterableWithSize(Matcher sizeMatcher) { super(sizeMatcher, "an iterable with size", "iterable size"); } - @Override protected Integer featureValueOf(Iterable actual) { @@ -29,12 +38,15 @@ protected Integer featureValueOf(Iterable actual) { * matcher. * For example: *
    assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
    - * + * + * @param + * the matcher type. * @param sizeMatcher * a matcher for the number of items that should be yielded by an examined {@link Iterable} + * @return The matcher. */ public static Matcher> iterableWithSize(Matcher sizeMatcher) { - return new IsIterableWithSize(sizeMatcher); + return new IsIterableWithSize<>(sizeMatcher); } /** @@ -43,11 +55,15 @@ public static Matcher> iterableWithSize(Matcher * size argument. * For example: *
    assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
    - * + * + * @param + * the matcher type. * @param size * the number of items that should be yielded by an examined {@link Iterable} + * @return The matcher. */ public static Matcher> iterableWithSize(int size) { return iterableWithSize(equalTo(size)); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java b/hamcrest/src/main/java/org/hamcrest/collection/IsMapContaining.java similarity index 69% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsMapContaining.java index c29801eaa..1c0d38de1 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapContaining.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsMapContaining.java @@ -10,10 +10,28 @@ import static org.hamcrest.core.IsAnything.anything; import static org.hamcrest.core.IsEqual.equalTo; -public class IsMapContaining extends TypeSafeMatcher> { +/** + * Matches if map keys, values or entries match the value matchers. + * @param the type of the map keys + * @param the type of the map values + */ +public class IsMapContaining extends TypeSafeMatcher> { + private final Matcher keyMatcher; private final Matcher valueMatcher; + /** + * Constructor, best called from one of the static factory methods (hasKey, hasValue, + * or hasEntry). + * @param keyMatcher matcher for expected keys + * @param valueMatcher matcher for expected values + * @see #hasKey(Object) + * @see #hasKey(Matcher) + * @see #hasValue(Object) + * @see #hasValue(Matcher) + * @see #hasEntry(Object, Object) + * @see #hasEntry(Matcher, Matcher) + */ public IsMapContaining(Matcher keyMatcher, Matcher valueMatcher) { this.keyMatcher = keyMatcher; this.valueMatcher = valueMatcher; @@ -49,14 +67,19 @@ public void describeTo(Description description) { * value satisfies the specified valueMatcher. * For example: *
    assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param keyMatcher * the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry * @param valueMatcher * the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry + * @return The matcher. */ - public static Matcher> hasEntry(Matcher keyMatcher, Matcher valueMatcher) { - return new IsMapContaining(keyMatcher, valueMatcher); + public static Matcher> hasEntry(Matcher keyMatcher, Matcher valueMatcher) { + return new IsMapContaining<>(keyMatcher, valueMatcher); } /** @@ -65,27 +88,35 @@ public static Matcher> hasEntry(Matchervalue. * For example: *
    assertThat(myMap, hasEntry("bar", "foo"))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param key * the key that, in combination with the value, must be describe at least one entry * @param value * the value that, in combination with the key, must be describe at least one entry + * @return The matcher. */ - public static Matcher> hasEntry(K key, V value) { - return new IsMapContaining(equalTo(key), equalTo(value)); + public static Matcher> hasEntry(K key, V value) { + return new IsMapContaining<>(equalTo(key), equalTo(value)); } - + /** * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains * at least one key that satisfies the specified matcher. * For example: *
    assertThat(myMap, hasKey(equalTo("bar")))
    - * + * + * @param + * the map key type. * @param keyMatcher * the matcher that must be satisfied by at least one key + * @return The matcher. */ public static Matcher> hasKey(Matcher keyMatcher) { - return new IsMapContaining(keyMatcher, anything()); + return new IsMapContaining<>(keyMatcher, anything()); } /** @@ -93,12 +124,15 @@ public static Matcher> hasEntry(K key, V valu * at least one key that is equal to the specified key. * For example: *
    assertThat(myMap, hasKey("bar"))
    - * + * + * @param + * the map key type. * @param key * the key that satisfying maps must contain + * @return The matcher. */ public static Matcher> hasKey(K key) { - return new IsMapContaining(equalTo(key), anything()); + return new IsMapContaining<>(equalTo(key), anything()); } /** @@ -106,12 +140,15 @@ public static Matcher> hasEntry(K key, V valu * at least one value that satisfies the specified valueMatcher. * For example: *
    assertThat(myMap, hasValue(equalTo("foo")))
    - * + * + * @param + * the value type. * @param valueMatcher * the matcher that must be satisfied by at least one value + * @return The matcher. */ public static Matcher> hasValue(Matcher valueMatcher) { - return new IsMapContaining(anything(), valueMatcher); + return new IsMapContaining<>(anything(), valueMatcher); } /** @@ -119,11 +156,15 @@ public static Matcher> hasEntry(K key, V valu * at least one value that is equal to the specified value. * For example: *
    assertThat(myMap, hasValue("foo"))
    - * + * + * @param + * the value type. * @param value * the value that satisfying maps must contain + * @return The matcher. */ public static Matcher> hasValue(V value) { - return new IsMapContaining(anything(), equalTo(value)); + return new IsMapContaining<>(anything(), equalTo(value)); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapWithSize.java b/hamcrest/src/main/java/org/hamcrest/collection/IsMapWithSize.java similarity index 70% rename from hamcrest-library/src/main/java/org/hamcrest/collection/IsMapWithSize.java rename to hamcrest/src/main/java/org/hamcrest/collection/IsMapWithSize.java index 0132390be..cce315b09 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/collection/IsMapWithSize.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsMapWithSize.java @@ -9,8 +9,18 @@ /** * Matches if map size satisfies a nested matcher. + * + * @param the map key type. + * @param the map value type. */ public final class IsMapWithSize extends FeatureMatcher, Integer> { + + /** + * Constructor, best called from {@link #aMapWithSize(int)}, {@link #aMapWithSize(Matcher)}, + * or {@link #anEmptyMap()}. + * @param sizeMatcher matcher for the expected size of the map + */ + @SuppressWarnings("WeakerAccess") public IsMapWithSize(Matcher sizeMatcher) { super(sizeMatcher, "a map with size", "map size"); } @@ -25,12 +35,17 @@ protected Integer featureValueOf(Map actual) { * a value that satisfies the specified matcher. * For example: *
    assertThat(myMap, is(aMapWithSize(equalTo(2))))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param sizeMatcher * a matcher for the size of an examined {@link java.util.Map} + * @return The matcher. */ public static Matcher> aMapWithSize(Matcher sizeMatcher) { - return new IsMapWithSize(sizeMatcher); + return new IsMapWithSize<>(sizeMatcher); } /** @@ -38,23 +53,31 @@ protected Integer featureValueOf(Map actual) { * a value equal to the specified size. * For example: *
    assertThat(myMap, is(aMapWithSize(2)))
    - * + * + * @param + * the map key type. + * @param + * the map value type. * @param size * the expected size of an examined {@link java.util.Map} + * @return The matcher. */ public static Matcher> aMapWithSize(int size) { - Matcher matcher = equalTo(size); - return IsMapWithSize.aMapWithSize(matcher); + return IsMapWithSize.aMapWithSize(equalTo(size)); } - + /** * Creates a matcher for {@link java.util.Map}s that matches when the size() method returns * zero. * For example: *
    assertThat(myMap, is(anEmptyMap()))
    - * + * + * @param the map key type. + * @param the map value type. + * @return The matcher. */ public static Matcher> anEmptyMap() { return IsMapWithSize.aMapWithSize(equalTo(0)); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/collection/package-info.java b/hamcrest/src/main/java/org/hamcrest/collection/package-info.java new file mode 100644 index 000000000..f0e6d370d --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/collection/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers of arrays and collections. + */ +package org.hamcrest.collection; diff --git a/hamcrest-library/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java b/hamcrest/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java similarity index 83% rename from hamcrest-library/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java rename to hamcrest/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java index cf5221137..3f0cbc48d 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java +++ b/hamcrest/src/main/java/org/hamcrest/comparator/ComparatorMatcherBuilder.java @@ -8,6 +8,10 @@ import static java.lang.Integer.signum; +/** + * Builder for matchers that allow matchers to use a corresponding Compartor + * @param the type of the value being compared/matched. + */ public final class ComparatorMatcherBuilder { private final Comparator comparator; @@ -17,9 +21,13 @@ public final class ComparatorMatcherBuilder { * Creates a matcher factory for matchers of {@code Comparable}s. * For example: *
    assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1))
    + * + * @param + * the matcher type. + * @return The matcher. */ public static > ComparatorMatcherBuilder usingNaturalOrdering() { - return new ComparatorMatcherBuilder(new Comparator() { + return new ComparatorMatcherBuilder<>(new Comparator() { @Override public int compare(T o1, T o2) { return o1.compareTo(o2); @@ -35,9 +43,15 @@ public int compare(T o1, T o2) { * return -o1.compareTo(o2); * } * }).lessThan(4)) + * + * @param + * the matcher type. + * @param comparator + * the comparator for the matcher to use. + * @return The matcher. */ public static ComparatorMatcherBuilder comparedBy(Comparator comparator) { - return new ComparatorMatcherBuilder(comparator, true); + return new ComparatorMatcherBuilder<>(comparator, true); } private ComparatorMatcherBuilder(Comparator comparator, boolean includeComparatorInDescription) { @@ -115,9 +129,10 @@ private static String asText(int comparison) { *
    assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1))
    * * @param value the value which, when passed to the Comparator supplied to this builder, should return zero + * @return The matcher. */ public Matcher comparesEqualTo(T value) { - return new ComparatorMatcher(comparator, value, ComparatorMatcher.EQUAL, ComparatorMatcher.EQUAL, includeComparatorInDescription); + return new ComparatorMatcher<>(comparator, value, ComparatorMatcher.EQUAL, ComparatorMatcher.EQUAL, includeComparatorInDescription); } /** @@ -129,9 +144,10 @@ public Matcher comparesEqualTo(T value) { * * @param value the value which, when passed to the Comparator supplied to this builder, should return greater * than zero + * @return The matcher. */ public Matcher greaterThan(T value) { - return new ComparatorMatcher(comparator, value, ComparatorMatcher.GREATER_THAN, ComparatorMatcher.GREATER_THAN, includeComparatorInDescription); + return new ComparatorMatcher<>(comparator, value, ComparatorMatcher.GREATER_THAN, ComparatorMatcher.GREATER_THAN, includeComparatorInDescription); } /** @@ -143,9 +159,10 @@ public Matcher greaterThan(T value) { * * @param value the value which, when passed to the Comparator supplied to this builder, should return greater * than or equal to zero + * @return The matcher. */ public Matcher greaterThanOrEqualTo(T value) { - return new ComparatorMatcher(comparator, value, ComparatorMatcher.EQUAL, ComparatorMatcher.GREATER_THAN, includeComparatorInDescription); + return new ComparatorMatcher<>(comparator, value, ComparatorMatcher.EQUAL, ComparatorMatcher.GREATER_THAN, includeComparatorInDescription); } /** @@ -157,9 +174,10 @@ public Matcher greaterThanOrEqualTo(T value) { * * @param value the value which, when passed to the Comparator supplied to this builder, should return less * than zero + * @return The matcher. */ public Matcher lessThan(T value) { - return new ComparatorMatcher(comparator, value, ComparatorMatcher.LESS_THAN, ComparatorMatcher.LESS_THAN, includeComparatorInDescription); + return new ComparatorMatcher<>(comparator, value, ComparatorMatcher.LESS_THAN, ComparatorMatcher.LESS_THAN, includeComparatorInDescription); } /** @@ -171,8 +189,10 @@ public Matcher lessThan(T value) { * * @param value the value which, when passed to the Comparator supplied to this builder, should return less * than or equal to zero + * @return The matcher. */ public Matcher lessThanOrEqualTo(T value) { - return new ComparatorMatcher(comparator, value, ComparatorMatcher.LESS_THAN, ComparatorMatcher.EQUAL, includeComparatorInDescription); + return new ComparatorMatcher<>(comparator, value, ComparatorMatcher.LESS_THAN, ComparatorMatcher.EQUAL, includeComparatorInDescription); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/comparator/package-info.java b/hamcrest/src/main/java/org/hamcrest/comparator/package-info.java new file mode 100644 index 000000000..6a934c9ce --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/comparator/package-info.java @@ -0,0 +1,4 @@ +/** + * Helper classes for building matcher comparators. + */ +package org.hamcrest.comparator; \ No newline at end of file diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/AllOf.java b/hamcrest/src/main/java/org/hamcrest/core/AllOf.java similarity index 67% rename from hamcrest-core/src/main/java/org/hamcrest/core/AllOf.java rename to hamcrest/src/main/java/org/hamcrest/core/AllOf.java index 06e999ade..8d43b84a8 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/AllOf.java +++ b/hamcrest/src/main/java/org/hamcrest/core/AllOf.java @@ -3,17 +3,35 @@ import org.hamcrest.Description; import org.hamcrest.DiagnosingMatcher; import org.hamcrest.Matcher; +import org.hamcrest.collection.ArrayMatching; import java.util.Arrays; /** * Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so * subsequent matchers are not called if an earlier matcher returns false. + * + * @param the matched value type */ public class AllOf extends DiagnosingMatcher { private final Iterable> matchers; + /** + * Constructor, best called from {@link #allOf(Matcher[])}. + * @param matchers the matchers + * @see #allOf(Matcher[]) + */ + @SafeVarargs + public AllOf(Matcher ... matchers) { + this(Arrays.asList(matchers)); + } + + /** + * Constructor, best called from {@link #allOf(Iterable)}. + * @param matchers the matchers + * @see #allOf(Iterable) + */ public AllOf(Iterable> matchers) { this.matchers = matchers; } @@ -39,6 +57,12 @@ public void describeTo(Description description) { * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. */ public static Matcher allOf(Iterable> matchers) { return new AllOf<>(matchers); @@ -48,9 +72,16 @@ public static Matcher allOf(Iterable> matchers) { * Creates a matcher that matches if the examined object matches ALL of the specified matchers. * For example: *
    assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * all the matchers must pass. + * @return The matcher. */ @SafeVarargs public static Matcher allOf(Matcher... matchers) { - return allOf(Arrays.asList(matchers)); + return allOf((Iterable) Arrays.asList(matchers)); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/AnyOf.java b/hamcrest/src/main/java/org/hamcrest/core/AnyOf.java similarity index 61% rename from hamcrest-core/src/main/java/org/hamcrest/core/AnyOf.java rename to hamcrest/src/main/java/org/hamcrest/core/AnyOf.java index 03cc210e3..0b08488c6 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/AnyOf.java +++ b/hamcrest/src/main/java/org/hamcrest/core/AnyOf.java @@ -2,15 +2,33 @@ import org.hamcrest.Description; import org.hamcrest.Matcher; +import org.hamcrest.collection.ArrayMatching; import java.util.Arrays; /** * Calculates the logical disjunction of multiple matchers. Evaluation is shortcut, so * subsequent matchers are not called if an earlier matcher returns true. + * + * @param the matched value type */ public class AnyOf extends ShortcutCombination { + /** + * Constructor, best called from {@link #anyOf(Matcher[])}. + * @param matchers the matchers + * @see #anyOf(Matcher[]) + */ + @SafeVarargs + public AnyOf(Matcher ... matchers) { + this(Arrays.asList(matchers)); + } + + /** + * Constructor, best called from {@link #anyOf(Iterable)}. + * @param matchers the matchers + * @see #anyOf(Iterable) + */ public AnyOf(Iterable> matchers) { super(matchers); } @@ -29,18 +47,31 @@ public void describeTo(Description description) { * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. */ public static AnyOf anyOf(Iterable> matchers) { return new AnyOf<>(matchers); } - + /** * Creates a matcher that matches if the examined object matches ANY of the specified matchers. * For example: *
    assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
    + * + * @param + * the matcher type. + * @param matchers + * any the matchers must pass. + * @return The matcher. */ @SafeVarargs public static AnyOf anyOf(Matcher... matchers) { - return anyOf(Arrays.asList(matchers)); + return anyOf((Iterable) Arrays.asList(matchers)); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/core/CombinableMatcher.java b/hamcrest/src/main/java/org/hamcrest/core/CombinableMatcher.java new file mode 100644 index 000000000..f17c9afb6 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/core/CombinableMatcher.java @@ -0,0 +1,161 @@ +package org.hamcrest.core; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +import java.util.ArrayList; + +/** + * Allows matchers of the same type to be combined using + * either/or, or + * both/and. + * + * For example: + * + *
    {@code  import static org.hamcrest.core.CombinableMatcher.either;
    + * import static org.hamcrest.core.CombinableMatcher.both;
    + * import static org.hamcrest.Matchers.equalTo;
    + * import static org.hamcrest.Matchers.not;
    + *
    + * Matcher either_3_or_4 = either(equalTo(3)).or(equalTo(4));
    + * Matcher neither_3_nor_4 = both(not(equalTo(3))).and(not(equalTo(4)));}
    + * + * @param the type of matcher being combined. + * @see #either(Matcher) + * @see #both(Matcher) + */ +public class CombinableMatcher extends TypeSafeDiagnosingMatcher { + + private final Matcher matcher; + + /** + * Constructor, best called from either or both. + * @param matcher the starting matcher + * @see #either(Matcher) + * @see #both(Matcher) + */ + public CombinableMatcher(Matcher matcher) { + this.matcher = matcher; + } + + @Override + protected boolean matchesSafely(T item, Description mismatch) { + if (!matcher.matches(item)) { + matcher.describeMismatch(item, mismatch); + return false; + } + return true; + } + + @Override + public void describeTo(Description description) { + description.appendDescriptionOf(matcher); + } + + /** + * Specify the second matcher in a CombinableMatcher pair. + * @param other the second matcher + * @return the combined matcher + */ + public CombinableMatcher and(Matcher other) { + return new CombinableMatcher<>(new AllOf<>(templatedListWith(other))); + } + + /** + * Specify the second matcher in a CombinableMatcher pair. + * @param other the second matcher + * @return the combined matcher + */ + public CombinableMatcher or(Matcher other) { + return new CombinableMatcher<>(new AnyOf<>(templatedListWith(other))); + } + + private ArrayList> templatedListWith(Matcher other) { + ArrayList> matchers = new ArrayList<>(); + matchers.add(matcher); + matchers.add(other); + return matchers; + } + + /** + * Creates a matcher that matches when both of the specified matchers match the examined object. + * For example: + *
    assertThat("fab", both(containsString("a")).and(containsString("b")))
    + * + * @param the matcher type. + * @param matcher the matcher to combine, and both must pass. + * @return The matcher. + */ + public static CombinableBothMatcher both(Matcher matcher) { + return new CombinableBothMatcher<>(matcher); + } + + /** + * Allows syntactic sugar of using both and and. + * @param the combined matcher type + * @see #both(Matcher) + * @see #and(Matcher) + */ + public static final class CombinableBothMatcher { + private final Matcher first; + + /** + * Constructor, best called from {@link #both(Matcher)}. + * @param matcher the first matcher + */ + public CombinableBothMatcher(Matcher matcher) { + this.first = matcher; + } + + /** + * Specify the second matcher in a CombinableMatcher pair. + * @param other the second matcher + * @return the combined matcher + */ + public CombinableMatcher and(Matcher other) { + return new CombinableMatcher(first).and(other); + } + } + + /** + * Creates a matcher that matches when either of the specified matchers match the examined object. + * For example: + *
    assertThat("fan", either(containsString("a")).or(containsString("b")))
    + * + * @param the matcher type. + * @param matcher the matcher to combine, and either must pass. + * @return The matcher. + */ + public static CombinableEitherMatcher either(Matcher matcher) { + return new CombinableEitherMatcher<>(matcher); + } + + /** + * Allows syntactic sugar of using either and or. + * @param the combined matcher type + * @see #either(Matcher) + * @see #or(Matcher) + */ + public static final class CombinableEitherMatcher { + private final Matcher first; + + /** + * Constructor, best called from {@link #either(Matcher)} + * @param matcher the matcher + */ + public CombinableEitherMatcher(Matcher matcher) { + this.first = matcher; + } + + /** + * Specify the second matcher in a CombinableMatcher pair. + * @param other the second matcher + * @return the combined matcher + */ + public CombinableMatcher or(Matcher other) { + return new CombinableMatcher(first).or(other); + } + } + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/DescribedAs.java b/hamcrest/src/main/java/org/hamcrest/core/DescribedAs.java similarity index 67% rename from hamcrest-core/src/main/java/org/hamcrest/core/DescribedAs.java rename to hamcrest/src/main/java/org/hamcrest/core/DescribedAs.java index 23876095a..c89451e66 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/DescribedAs.java +++ b/hamcrest/src/main/java/org/hamcrest/core/DescribedAs.java @@ -10,20 +10,29 @@ /** * Provides a custom description to another matcher. + * + * @param the matched value type */ public class DescribedAs extends BaseMatcher { + private final String descriptionTemplate; private final Matcher matcher; private final Object[] values; - - private final static Pattern ARG_PATTERN = Pattern.compile("%([0-9]+)"); - + + private final static Pattern ARG_PATTERN = Pattern.compile("%([0-9]+)"); + + /** + * Constructor, best called from {@link #describedAs(String, Matcher, Object...)}. + * @param descriptionTemplate the new description for the wrapped matcher + * @param matcher the matcher to wrap + * @param values optional values to insert into the tokenised description + */ public DescribedAs(String descriptionTemplate, Matcher matcher, Object[] values) { this.descriptionTemplate = descriptionTemplate; this.matcher = matcher; this.values = values.clone(); } - + @Override public boolean matches(Object o) { return matcher.matches(o); @@ -32,19 +41,19 @@ public boolean matches(Object o) { @Override public void describeTo(Description description) { java.util.regex.Matcher arg = ARG_PATTERN.matcher(descriptionTemplate); - + int textStart = 0; while (arg.find()) { description.appendText(descriptionTemplate.substring(textStart, arg.start())); description.appendValue(values[parseInt(arg.group(1))]); textStart = arg.end(); } - + if (textStart < descriptionTemplate.length()) { description.appendText(descriptionTemplate.substring(textStart)); } } - + @Override public void describeMismatch(Object item, Description description) { matcher.describeMismatch(item, description); @@ -54,16 +63,16 @@ public void describeMismatch(Object item, Description description) { * Wraps an existing matcher, overriding its description with that specified. All other functions are * delegated to the decorated matcher, including its mismatch description. * For example: - *
    describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
    - * - * @param description - * the new description for the wrapped matcher - * @param matcher - * the matcher to wrap - * @param values - * optional values to insert into the tokenised description + *
    describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
    + * + * @param the matcher type. + * @param descriptionTemplate the new description for the wrapped matcher + * @param matcher the matcher to wrap + * @param values optional values to insert into the tokenised description + * @return The matcher. */ - public static Matcher describedAs(String description, Matcher matcher, Object... values) { - return new DescribedAs(description, matcher, values); + public static Matcher describedAs(String descriptionTemplate, Matcher matcher, Object... values) { + return new DescribedAs<>(descriptionTemplate, matcher, values); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/Every.java b/hamcrest/src/main/java/org/hamcrest/core/Every.java similarity index 77% rename from hamcrest-core/src/main/java/org/hamcrest/core/Every.java rename to hamcrest/src/main/java/org/hamcrest/core/Every.java index 757b7b461..bf3d809fb 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/Every.java +++ b/hamcrest/src/main/java/org/hamcrest/core/Every.java @@ -4,9 +4,19 @@ import org.hamcrest.Matcher; import org.hamcrest.TypeSafeDiagnosingMatcher; +/** + * A matcher that applies a delegate matcher to every item in an {@link Iterable}. + * + * @param the type of the items in the iterable + */ public class Every extends TypeSafeDiagnosingMatcher> { + private final Matcher matcher; + /** + * Constructor, best called from {@link #everyItem(Matcher)}. + * @param matcher a matcher used to check every item in the iterable. + */ public Every(Matcher matcher) { this.matcher= matcher; } @@ -34,11 +44,15 @@ public void describeTo(Description description) { * itemMatcher. * For example: *
    assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} + * @return The matcher. */ public static Matcher> everyItem(final Matcher itemMatcher) { - return new Every(itemMatcher); + return new Every<>(itemMatcher); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/Is.java b/hamcrest/src/main/java/org/hamcrest/core/Is.java similarity index 71% rename from hamcrest-core/src/main/java/org/hamcrest/core/Is.java rename to hamcrest/src/main/java/org/hamcrest/core/Is.java index ec22238ec..3fc323322 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/Is.java +++ b/hamcrest/src/main/java/org/hamcrest/core/Is.java @@ -5,7 +5,6 @@ import org.hamcrest.Matcher; import static org.hamcrest.core.IsEqual.equalTo; -import static org.hamcrest.core.IsInstanceOf.instanceOf; /** * Decorates another Matcher, retaining the behaviour but allowing tests @@ -13,10 +12,17 @@ * * For example: assertThat(cheese, equalTo(smelly)) * vs. assertThat(cheese, is(equalTo(smelly))) + * + * @param the matched value type */ public class Is extends BaseMatcher { + private final Matcher matcher; + /** + * Constructor, best called from {@link #is(Object)}, {@link #is(Matcher)}, or {@link #isA(Class)}. + * @param matcher the matcher to wrap + */ public Is(Matcher matcher) { this.matcher = matcher; } @@ -43,10 +49,15 @@ public void describeMismatch(Object item, Description mismatchDescription) { *
    assertThat(cheese, is(equalTo(smelly)))
    * instead of: *
    assertThat(cheese, equalTo(smelly))
    - * + * + * @param + * the matcher type. + * @param matcher + * the matcher to wrap. + * @return The matcher. */ public static Matcher is(Matcher matcher) { - return new Is(matcher); + return new Is<>(matcher); } /** @@ -55,7 +66,12 @@ public static Matcher is(Matcher matcher) { *
    assertThat(cheese, is(smelly))
    * instead of: *
    assertThat(cheese, is(equalTo(smelly)))
    - * + * + * @param + * the matcher type. + * @param value + * the value to check. + * @return The matcher. */ public static Matcher is(T value) { return is(equalTo(value)); @@ -67,10 +83,15 @@ public static Matcher is(T value) { *
    assertThat(cheese, isA(Cheddar.class))
    * instead of: *
    assertThat(cheese, is(instanceOf(Cheddar.class)))
    - * + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ - public static Matcher isA(Class type) { - final Matcher typeMatcher = instanceOf(type); - return is(typeMatcher); + public static Matcher isA(Class type) { + return is(IsInstanceOf.instanceOf(type)); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsAnything.java b/hamcrest/src/main/java/org/hamcrest/core/IsAnything.java similarity index 65% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsAnything.java rename to hamcrest/src/main/java/org/hamcrest/core/IsAnything.java index 4c71a9b2d..9d1a51b86 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsAnything.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsAnything.java @@ -4,22 +4,35 @@ import org.hamcrest.Description; import org.hamcrest.Matcher; - /** * A matcher that always returns true. + * + * @param the matched value type */ public class IsAnything extends BaseMatcher { private final String message; + /** + * Constructor, best called from {@link #anything()}. + */ public IsAnything() { this("ANYTHING"); } + /** + * Constructor, best called from {@link #anything(String)}. + * @param message matcher description + */ public IsAnything(String message) { this.message = message; } + /** + * Always returns true. + * @param o the object against which the matcher is evaluated. + * @return true + */ @Override public boolean matches(Object o) { return true; @@ -32,10 +45,10 @@ public void describeTo(Description description) { /** * Creates a matcher that always matches, regardless of the examined object. + * + * @return The matcher. */ - public static Matcher anything() { - return new IsAnything(); - } + public static Matcher anything() { return new IsAnything<>(); } /** * Creates a matcher that always matches, regardless of the examined object, but describes @@ -43,8 +56,10 @@ public static Matcher anything() { * * @param description * a meaningful {@link String} used when describing itself + * @return The matcher. */ public static Matcher anything(String description) { - return new IsAnything(description); + return new IsAnything<>(description); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/core/IsCollectionContaining.java b/hamcrest/src/main/java/org/hamcrest/core/IsCollectionContaining.java new file mode 100644 index 000000000..112bb02d8 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/core/IsCollectionContaining.java @@ -0,0 +1,118 @@ +package org.hamcrest.core; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +/** + * @param the collection element type + * @deprecated As of release 2.1, replaced by {@link IsIterableContaining}. + */ +@Deprecated +public class IsCollectionContaining extends TypeSafeDiagnosingMatcher> { + + private final IsIterableContaining delegate; + + /** + * Constructor, best called from one of the static factory methods. + * @param elementMatcher matches the expected element + * @see #hasItem(Object) + * @see #hasItem(Matcher) + * @see #hasItems(Object[]) + * @see #hasItems(Matcher[]) + */ + public IsCollectionContaining(Matcher elementMatcher) { + this.delegate = new IsIterableContaining<>(elementMatcher); + } + + @Override + protected boolean matchesSafely(Iterable collection, Description mismatchDescription) { + return delegate.matchesSafely(collection, mismatchDescription); + } + + @Override + public void describeTo(Description description) { + delegate.describeTo(description); + } + + /** + * Creates a matcher for {@link Iterable}s that only matches when a single pass over the + * examined {@link Iterable} yields at least one item that is matched by the specified + * itemMatcher. Whilst matching, the traversal of the examined {@link Iterable} + * will stop as soon as a matching item is found. + * For example: + *
    assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
    + * + * @deprecated As of version 2.1, use {@link IsIterableContaining#hasItem(Matcher)}. + * + * @param + * the matcher type. + * @param itemMatcher + * the matcher to apply to items provided by the examined {@link Iterable} + * @return The matcher. + */ + public static Matcher> hasItem(Matcher itemMatcher) { + return IsIterableContaining.hasItem(itemMatcher); + } + + /** + * Creates a matcher for {@link Iterable}s that only matches when a single pass over the + * examined {@link Iterable} yields at least one item that is equal to the specified + * item. Whilst matching, the traversal of the examined {@link Iterable} + * will stop as soon as a matching item is found. + * For example: + *
    assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
    + * + * @deprecated As of version 2.1, use {@link IsIterableContaining#hasItem(Object)}. + * @param + * the matcher type. + * @param item + * the item to compare against the items provided by the examined {@link Iterable} + * @return The matcher. + */ + public static Matcher> hasItem(T item) { + // Doesn't forward to hasItem() method so compiler can sort out generics. + return IsIterableContaining.hasItem(item); + } + + /** + * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the + * examined {@link Iterable} yield at least one item that is matched by the corresponding + * matcher from the specified itemMatchers. Whilst matching, each traversal of + * the examined {@link Iterable} will stop as soon as a matching item is found. + * For example: + *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
    + * + * @deprecated As of version 2.1, use {@link IsIterableContaining#hasItems(Matcher[])}}. + * @param + * the matcher type. + * @param itemMatchers + * the matchers to apply to items provided by the examined {@link Iterable} + * @return The matcher. + */ + @SafeVarargs + public static Matcher> hasItems(Matcher... itemMatchers) { + return IsIterableContaining.hasItems(itemMatchers); + } + + /** + * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the + * examined {@link Iterable} yield at least one item that is equal to the corresponding + * item from the specified items. Whilst matching, each traversal of the + * examined {@link Iterable} will stop as soon as a matching item is found. + * For example: + *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
    + * + * @deprecated As of version 2.1, use {@link IsIterableContaining#hasItems(Object[])}}. + * @param + * the matcher type. + * @param items + * the items to compare against the items provided by the examined {@link Iterable} + * @return The matcher. + */ + @SafeVarargs + public static Matcher> hasItems(T... items) { + return IsIterableContaining.hasItems(items); + } + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsEqual.java b/hamcrest/src/main/java/org/hamcrest/core/IsEqual.java similarity index 84% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsEqual.java rename to hamcrest/src/main/java/org/hamcrest/core/IsEqual.java index 860e85e82..388ac52fc 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsEqual.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsEqual.java @@ -6,14 +6,20 @@ import java.lang.reflect.Array; - /** * Is the value equal to another value, as tested by the - * {@link java.lang.Object#equals} invokedMethod? + * {@link java.lang.Object#equals} method. + * + * @param the matched value type */ public class IsEqual extends BaseMatcher { + private final Object expectedValue; + /** + * Constructor, best called from {@link #equalTo(Object)} or {@link #equalToObject(Object)}. + * @param equalArg the expected value + */ public IsEqual(T equalArg) { expectedValue = equalArg; } @@ -32,11 +38,11 @@ private static boolean areEqual(Object actual, Object expected) { if (actual == null) { return expected == null; } - + if (expected != null && isArray(actual)) { return isArray(expected) && areArraysEqual(actual, expected); } - + return actual.equals(expected); } @@ -65,33 +71,43 @@ private static boolean isArray(Object o) { * Creates a matcher that matches when the examined object is logically equal to the specified * operand, as determined by calling the {@link java.lang.Object#equals} method on * the examined object. - * + * *

    If the specified operand is null then the created matcher will only match if * the examined object's equals method returns true when passed a * null (which would be a violation of the equals contract), unless the * examined object itself is null, in which case the matcher will return a positive * match.

    - * + * *

    The created matcher provides a special behaviour when examining Arrays, whereby * it will match if both the operand and the examined object are arrays of the same length and * contain items that are equal to each other (according to the above rules) in the same - * indexes.

    + * indexes.

    * For example: *
          * assertThat("foo", equalTo("foo"));
          * assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
          * 
    - * + * + * @param + * the matcher type. + * @param operand + * the value to check. + * @return The matcher. */ public static Matcher equalTo(T operand) { - return new IsEqual(operand); + return new IsEqual<>(operand); } /** * Creates an {@link org.hamcrest.core.IsEqual} matcher that does not enforce the values being * compared to be of the same static type. + * + * @param operand + * the value to check. + * @return The matcher. */ public static Matcher equalToObject(Object operand) { - return new IsEqual(operand); + return new IsEqual<>(operand); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsInstanceOf.java b/hamcrest/src/main/java/org/hamcrest/core/IsInstanceOf.java similarity index 88% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsInstanceOf.java rename to hamcrest/src/main/java/org/hamcrest/core/IsInstanceOf.java index 5a508c9b5..0a984087f 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsInstanceOf.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsInstanceOf.java @@ -4,12 +4,12 @@ import org.hamcrest.DiagnosingMatcher; import org.hamcrest.Matcher; - /** * Tests whether the value is an instance of a class. * Classes of basic types will be converted to the relevant "Object" classes */ public class IsInstanceOf extends DiagnosingMatcher { + private final Class expectedClass; private final Class matchableClass; @@ -25,14 +25,14 @@ public IsInstanceOf(Class expectedClass) { } private static Class matchableClass(Class expectedClass) { - if (boolean.class.equals(expectedClass)) return Boolean.class; - if (byte.class.equals(expectedClass)) return Byte.class; - if (char.class.equals(expectedClass)) return Character.class; - if (double.class.equals(expectedClass)) return Double.class; - if (float.class.equals(expectedClass)) return Float.class; - if (int.class.equals(expectedClass)) return Integer.class; - if (long.class.equals(expectedClass)) return Long.class; - if (short.class.equals(expectedClass)) return Short.class; + if (boolean.class.equals(expectedClass)) return Boolean.class; + if (byte.class.equals(expectedClass)) return Byte.class; + if (char.class.equals(expectedClass)) return Character.class; + if (double.class.equals(expectedClass)) return Double.class; + if (float.class.equals(expectedClass)) return Float.class; + if (int.class.equals(expectedClass)) return Integer.class; + if (long.class.equals(expectedClass)) return Long.class; + if (short.class.equals(expectedClass)) return Short.class; return expectedClass; } @@ -42,12 +42,12 @@ protected boolean matches(Object item, Description mismatch) { mismatch.appendText("null"); return false; } - + if (!matchableClass.isInstance(item)) { mismatch.appendValue(item).appendText(" is a " + item.getClass().getName()); return false; } - + return true; } @@ -60,28 +60,38 @@ public void describeTo(Description description) { * Creates a matcher that matches when the examined object is an instance of the specified type, * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the * the examined object. - * + * *

    The created matcher assumes no relationship between specified type and the examined object.

    * For example: *
    assertThat(new Canoe(), instanceOf(Paddlable.class));
    - * + * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ @SuppressWarnings("unchecked") public static Matcher instanceOf(Class type) { return (Matcher) new IsInstanceOf(type); } - + /** * Creates a matcher that matches when the examined object is an instance of the specified type, * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the * the examined object. - * + * *

    The created matcher forces a relationship between specified type and the examined object, and should be * used when it is necessary to make generics conform, for example in the JMock clause * with(any(Thing.class))

    * For example: *
    assertThat(new Canoe(), instanceOf(Canoe.class));
    * + * @param + * the matcher type. + * @param type + * the type to check. + * @return The matcher. */ @SuppressWarnings("unchecked") public static Matcher any(Class type) { diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsCollectionContaining.java b/hamcrest/src/main/java/org/hamcrest/core/IsIterableContaining.java similarity index 70% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsCollectionContaining.java rename to hamcrest/src/main/java/org/hamcrest/core/IsIterableContaining.java index c55853dea..67bb3e33d 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsCollectionContaining.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsIterableContaining.java @@ -10,15 +10,28 @@ import static org.hamcrest.core.AllOf.allOf; import static org.hamcrest.core.IsEqual.equalTo; -public class IsCollectionContaining extends TypeSafeDiagnosingMatcher> { +/** + * Tests if an iterable contains matching elements. + * @param the type of items in the iterable + */ +public class IsIterableContaining extends TypeSafeDiagnosingMatcher> { + private final Matcher elementMatcher; - public IsCollectionContaining(Matcher elementMatcher) { + /** + * Constructor, best called from one of the static factory methods. + * @param elementMatcher matches the expected element + * @see #hasItem(Object) + * @see #hasItem(Matcher) + * @see #hasItems(Object[]) + * @see #hasItems(Matcher[]) + */ + public IsIterableContaining(Matcher elementMatcher) { this.elementMatcher = elementMatcher; } @Override - protected boolean matchesSafely(Iterable collection, Description mismatchDescription) { + protected boolean matchesSafely(Iterable collection, Description mismatchDescription) { if (isEmpty(collection)) { mismatchDescription.appendText("was empty"); return false; @@ -43,7 +56,7 @@ protected boolean matchesSafely(Iterable collection, Description mism return false; } - private boolean isEmpty(Iterable iterable) { + private boolean isEmpty(Iterable iterable) { return ! iterable.iterator().hasNext(); } @@ -54,7 +67,6 @@ public void describeTo(Description description) { .appendDescriptionOf(elementMatcher); } - /** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is matched by the specified @@ -62,12 +74,15 @@ public void describeTo(Description description) { * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
    - * + * + * @param + * the matcher type. * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ - public static Matcher> hasItem(Matcher itemMatcher) { - return new IsCollectionContaining<>(itemMatcher); + public static Matcher> hasItem(Matcher itemMatcher) { + return new IsIterableContaining<>(itemMatcher); } /** @@ -77,13 +92,16 @@ public static Matcher> hasItem(Matcher itemMa * will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
    - * + * + * @param + * the matcher type. * @param item * the item to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ - public static Matcher> hasItem(T item) { + public static Matcher> hasItem(T item) { // Doesn't forward to hasItem() method so compiler can sort out generics. - return new IsCollectionContaining<>(equalTo(item)); + return new IsIterableContaining<>(equalTo(item)); } /** @@ -93,22 +111,25 @@ public static Matcher> hasItem(T item) { * the examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
    - * + * + * @param + * the matcher type. * @param itemMatchers * the matchers to apply to items provided by the examined {@link Iterable} + * @return The matcher. */ @SafeVarargs - public static Matcher> hasItems(Matcher... itemMatchers) { - List>> all = new ArrayList<>(itemMatchers.length); - + public static Matcher> hasItems(Matcher... itemMatchers) { + List>> all = new ArrayList<>(itemMatchers.length); + for (Matcher elementMatcher : itemMatchers) { // Doesn't forward to hasItem() method so compiler can sort out generics. - all.add(new IsCollectionContaining<>(elementMatcher)); + all.add(new IsIterableContaining<>(elementMatcher)); } - + return allOf(all); } - + /** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is equal to the corresponding @@ -116,17 +137,20 @@ public static Matcher> hasItems(Matcher... itemMatche * examined {@link Iterable} will stop as soon as a matching item is found. * For example: *
    assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
    - * + * + * @param + * the matcher type. * @param items * the items to compare against the items provided by the examined {@link Iterable} + * @return The matcher. */ @SafeVarargs - public static Matcher> hasItems(T... items) { - List>> all = new ArrayList<>(items.length); + public static Matcher> hasItems(T... items) { + List>> all = new ArrayList<>(items.length); for (T item : items) { all.add(hasItem(item)); } - + return allOf(all); } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsNot.java b/hamcrest/src/main/java/org/hamcrest/core/IsNot.java similarity index 78% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsNot.java rename to hamcrest/src/main/java/org/hamcrest/core/IsNot.java index d5cf9c069..20e411505 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsNot.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsNot.java @@ -6,13 +6,20 @@ import static org.hamcrest.core.IsEqual.equalTo; - /** * Calculates the logical negation of a matcher. + * + * @param the matched value type */ public class IsNot extends BaseMatcher { + private final Matcher matcher; + /** + * Constructor, best called from {@link #not(Object)} or + * {@link #not(Matcher)}. + * @param matcher the matcher to negate + */ public IsNot(Matcher matcher) { this.matcher = matcher; } @@ -27,18 +34,20 @@ public void describeTo(Description description) { description.appendText("not ").appendDescriptionOf(matcher); } - /** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * For example: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param matcher * the matcher whose sense should be inverted + * @return The matcher. */ public static Matcher not(Matcher matcher) { - return new IsNot(matcher); + return new IsNot<>(matcher); } /** @@ -47,11 +56,15 @@ public static Matcher not(Matcher matcher) { *
    assertThat(cheese, is(not(smelly)))
    * instead of: *
    assertThat(cheese, is(not(equalTo(smelly))))
    - * + * + * @param + * the matcher type. * @param value * the value that any examined object should not equal + * @return The matcher. */ public static Matcher not(T value) { return not(equalTo(value)); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsNull.java b/hamcrest/src/main/java/org/hamcrest/core/IsNull.java similarity index 60% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsNull.java rename to hamcrest/src/main/java/org/hamcrest/core/IsNull.java index 9ebf080f8..4cc390bad 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsNull.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsNull.java @@ -8,8 +8,19 @@ /** * Is the value null? + * + * @param the matched value type */ public class IsNull extends BaseMatcher { + + /** + * Constructor, best called from {@link #nullValue()}, + * {@link #nullValue(Class)}, {@link #notNullValue()}, + * or {@link #notNullValue(Class)}. + */ + public IsNull() { + } + @Override public boolean matches(Object o) { return o == null; @@ -21,13 +32,14 @@ public void describeTo(Description description) { } /** - * Creates a matcher that matches if examined object is null. + *

    Creates a matcher that matches if examined object is null. + *

    * For example: - *
    assertThat(cheese, is(nullValue())
    - * + *
    {@code assertThat(cheese, is(nullValue())}
    + * @return The matcher */ public static Matcher nullValue() { - return new IsNull(); + return new IsNull<>(); } /** @@ -36,23 +48,26 @@ public static Matcher nullValue() { *
    assertThat(cheese, is(notNullValue()))
    * instead of: *
    assertThat(cheese, is(not(nullValue())))
    - * + * + * @return The matcher. */ public static Matcher notNullValue() { return not(nullValue()); } /** - * Creates a matcher that matches if examined object is null. Accepts a - * single dummy argument to facilitate type inference. + *

    Creates a matcher that matches if examined object is null. + * Accepts a single dummy argument to facilitate type inference. + *

    * For example: - *
    assertThat(cheese, is(nullValue(Cheese.class))
    - * - * @param type - * dummy parameter used to infer the generic type of the returned matcher + *
    {@code assertThat(cheese, is(nullValue(Cheese.class))}
    + * + * @param the matcher type. + * @param type dummy parameter used to infer the generic type of the returned matcher + * @return The matcher. */ public static Matcher nullValue(Class type) { - return new IsNull(); + return new IsNull<>(); } /** @@ -62,13 +77,15 @@ public static Matcher nullValue(Class type) { *
    assertThat(cheese, is(notNullValue(X.class)))
    * instead of: *
    assertThat(cheese, is(not(nullValue(X.class))))
    - * + * + * @param + * the matcher type. * @param type * dummy parameter used to infer the generic type of the returned matcher - * + * @return The matcher. */ public static Matcher notNullValue(Class type) { return not(nullValue(type)); } -} +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsSame.java b/hamcrest/src/main/java/org/hamcrest/core/IsSame.java similarity index 73% rename from hamcrest-core/src/main/java/org/hamcrest/core/IsSame.java rename to hamcrest/src/main/java/org/hamcrest/core/IsSame.java index cbc3971bd..f27f232ab 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/IsSame.java +++ b/hamcrest/src/main/java/org/hamcrest/core/IsSame.java @@ -4,13 +4,20 @@ import org.hamcrest.Description; import org.hamcrest.Matcher; - /** * Is the value the same object as another value? + * + * @param the matched value type */ public class IsSame extends BaseMatcher { + private final T object; - + + /** + * Constructor, best called from {@link #sameInstance(Object)} or + * {@link #theInstance(Object)}. + * @param object the object to check + */ public IsSame(T object) { this.object = object; } @@ -26,26 +33,33 @@ public void describeTo(Description description) { .appendValue(object) .appendText(")"); } - + /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static Matcher sameInstance(T target) { - return new IsSame(target); + return new IsSame<>(target); } - + /** * Creates a matcher that matches only when the examined object is the same instance as * the specified target object. * + * @param + * the matcher type. * @param target * the target instance against which others should be assessed + * @return The matcher. */ public static Matcher theInstance(T target) { - return new IsSame(target); + return new IsSame<>(target); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/ShortcutCombination.java b/hamcrest/src/main/java/org/hamcrest/core/ShortcutCombination.java similarity index 58% rename from hamcrest-core/src/main/java/org/hamcrest/core/ShortcutCombination.java rename to hamcrest/src/main/java/org/hamcrest/core/ShortcutCombination.java index 30b33af58..b21eaa876 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/ShortcutCombination.java +++ b/hamcrest/src/main/java/org/hamcrest/core/ShortcutCombination.java @@ -11,13 +11,23 @@ abstract class ShortcutCombination extends BaseMatcher { public ShortcutCombination(Iterable> matchers) { this.matchers = matchers; } - + @Override public abstract boolean matches(Object o); - + @Override public abstract void describeTo(Description description); - + + /** + * Evaluates the argument o against the delegate matchers. + * + * Evaluation will stop at the first matcher that evaluates to the value of the + * shortcut argument. + * + * @param o the value to check + * @param shortcut the match result to be checked against all delegate matchers + * @return the value of shortcut if all delegate matchers give the same value + */ protected boolean matches(Object o, boolean shortcut) { for (Matcher matcher : matchers) { if (matcher.matches(o) == shortcut) { @@ -26,8 +36,14 @@ protected boolean matches(Object o, boolean shortcut) { } return !shortcut; } - + + /** + * Describe this matcher to description + * @param description the description target + * @param operator the separate to use when joining the matcher descriptions + */ public void describeTo(Description description, String operator) { description.appendList("(", " " + operator + " ", ")", matchers); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/StringContains.java b/hamcrest/src/main/java/org/hamcrest/core/StringContains.java similarity index 66% rename from hamcrest-core/src/main/java/org/hamcrest/core/StringContains.java rename to hamcrest/src/main/java/org/hamcrest/core/StringContains.java index 9e0a4ab27..a46f47878 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/StringContains.java +++ b/hamcrest/src/main/java/org/hamcrest/core/StringContains.java @@ -3,9 +3,22 @@ import org.hamcrest.Matcher; /** - * Tests if the argument is a string that contains a substring. + * Tests if the argument is a string that contains a specific substring. */ public class StringContains extends SubstringMatcher { + + /** + * Constructor, best used with {@link #containsString(String)}. + * @param substring the expected substring. + */ + public StringContains(String substring) { this(false, substring); } + + /** + * Constructor, best used with {@link #containsString(String)} or + * {@link #containsStringIgnoringCase(String)}. + * @param ignoringCase whether to ignore case when matching + * @param substring the expected substring. + */ public StringContains(boolean ignoringCase, String substring) { super("containing", ignoringCase, substring); } @@ -20,10 +33,10 @@ protected boolean evalSubstringOf(String s) { * {@link String} anywhere. * For example: *
    assertThat("myStringOfNote", containsString("ring"))
    - * + * * @param substring * the substring that the returned matcher will expect to find within any examined string - * + * @return The matcher. */ public static Matcher containsString(String substring) { return new StringContains(false, substring); @@ -33,11 +46,11 @@ public static Matcher containsString(String substring) { * Creates a matcher that matches if the examined {@link String} contains the specified * {@link String} anywhere, ignoring case. * For example: - *
    assertThat("myStringOfNote", containsString("ring"))
    + *
    assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
    * * @param substring * the substring that the returned matcher will expect to find within any examined string - * + * @return The matcher. */ public static Matcher containsStringIgnoringCase(String substring) { return new StringContains(true, substring); diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/StringEndsWith.java b/hamcrest/src/main/java/org/hamcrest/core/StringEndsWith.java similarity index 59% rename from hamcrest-core/src/main/java/org/hamcrest/core/StringEndsWith.java rename to hamcrest/src/main/java/org/hamcrest/core/StringEndsWith.java index 6a6d1a023..9734b3911 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/StringEndsWith.java +++ b/hamcrest/src/main/java/org/hamcrest/core/StringEndsWith.java @@ -3,10 +3,23 @@ import org.hamcrest.Matcher; /** - * Tests if the argument is a string that contains a substring. + * Tests if the argument is a string that ends with a specific substring. */ public class StringEndsWith extends SubstringMatcher { - public StringEndsWith(boolean ignoringCase, String substring) { super("ending with", ignoringCase, substring); } + + /** + * Constructor, best used with {@link #endsWith(String)}. + * @param suffix the expected end of the string. + */ + public StringEndsWith(String suffix) { this(false, suffix); } + + /** + * Constructor, best used with {@link #endsWith(String)} or + * {@link #endsWithIgnoringCase(String)}. + * @param ignoringCase whether to ignore case when matching + * @param suffix the expected end of the string. + */ + public StringEndsWith(boolean ignoringCase, String suffix) { super("ending with", ignoringCase, suffix); } @Override protected boolean evalSubstringOf(String s) { @@ -18,9 +31,10 @@ protected boolean evalSubstringOf(String s) { * {@link String}. * For example: *
    assertThat("myStringOfNote", endsWith("Note"))
    - * + * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ public static Matcher endsWith(String suffix) { return new StringEndsWith(false, suffix); @@ -30,10 +44,11 @@ public static Matcher endsWith(String suffix) { * Creates a matcher that matches if the examined {@link String} ends with the specified * {@link String}, ignoring case. * For example: - *
    assertThat("myStringOfNote", endsWith("Note"))
    + *
    assertThat("myStringOfNote", endsWithIgnoringCase("note"))
    * * @param suffix * the substring that the returned matcher will expect at the end of any examined string + * @return The matcher. */ public static Matcher endsWithIgnoringCase(String suffix) { return new StringEndsWith(true, suffix); diff --git a/hamcrest/src/main/java/org/hamcrest/core/StringRegularExpression.java b/hamcrest/src/main/java/org/hamcrest/core/StringRegularExpression.java new file mode 100644 index 000000000..790aeb505 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/core/StringRegularExpression.java @@ -0,0 +1,71 @@ +package org.hamcrest.core; + +import java.util.regex.Pattern; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +/** + * A matcher that checks a string against a regular expression. + * + * @author borettim + * @author sf105 + */ +public class StringRegularExpression extends TypeSafeDiagnosingMatcher { + + /** + * Constructor, best used from {@link #matchesRegex(String)}. + * @param pattern the regular expression to match against + */ + protected StringRegularExpression(Pattern pattern) { + this.pattern = pattern; + } + + private Pattern pattern; + + @Override + public void describeTo(Description description) { + description.appendText("a string matching the pattern ").appendValue(pattern); + } + + @Override + protected boolean matchesSafely(String actual, Description mismatchDescription) { + if (!pattern.matcher(actual).matches()) { + mismatchDescription.appendText("the string was ").appendValue(actual); + return false; + } + return true; + } + + /** + * Creates a matcher that checks if the examined string matches a specified {@link java.util.regex.Pattern}. + * + *
    +   * assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
    +   * 
    + * + * @param pattern + * the pattern to be used. + * @return The matcher. + */ + public static Matcher matchesRegex(Pattern pattern) { + return new StringRegularExpression(pattern); + } + + /** + * Creates a matcher that checks if the examined string matches a specified regex. + * + *
    +   * assertThat("abc", matchesRegex("ˆ[a-z]+$"));
    +   * 
    + * + * @param regex + * The regex to be used for the validation. + * @return The matcher. + */ + public static Matcher matchesRegex(String regex) { + return matchesRegex(Pattern.compile(regex)); + } + +} diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/StringStartsWith.java b/hamcrest/src/main/java/org/hamcrest/core/StringStartsWith.java similarity index 59% rename from hamcrest-core/src/main/java/org/hamcrest/core/StringStartsWith.java rename to hamcrest/src/main/java/org/hamcrest/core/StringStartsWith.java index fe7b990da..75713d42e 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/StringStartsWith.java +++ b/hamcrest/src/main/java/org/hamcrest/core/StringStartsWith.java @@ -3,10 +3,23 @@ import org.hamcrest.Matcher; /** - * Tests if the argument is a string that contains a substring. + * Tests if the argument is a string that starts with a specific substring. */ public class StringStartsWith extends SubstringMatcher { - public StringStartsWith(boolean ignoringCase, String substring) { super("starting with", ignoringCase, substring); } + + /** + * Constructor, best used with {@link #startsWith(String)}. + * @param prefix the expected start of the string. + */ + public StringStartsWith(String prefix) { this(false, prefix); } + + /** + * Constructor, best used with {@link #startsWith(String)} or + * {@link #startsWithIgnoringCase(String)}. + * @param ignoringCase whether to ignore case when matching + * @param prefix the expected start of the string. + */ + public StringStartsWith(boolean ignoringCase, String prefix) { super("starting with", ignoringCase, prefix); } @Override protected boolean evalSubstringOf(String s) { return converted(s).startsWith(converted(substring)); } @@ -18,9 +31,10 @@ public class StringStartsWith extends SubstringMatcher { *

    * For example: *
    assertThat("myStringOfNote", startsWith("my"))
    - * + * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ public static Matcher startsWith(String prefix) { return new StringStartsWith(false, prefix); } @@ -30,10 +44,11 @@ public class StringStartsWith extends SubstringMatcher { * {@link String}, ignoring case *

    * For example: - *
    assertThat("myStringOfNote", startsWith("my"))
    + *
    assertThat("myStringOfNote", startsWithIgnoringCase("My"))
    * * @param prefix * the substring that the returned matcher will expect at the start of any examined string + * @return The matcher. */ public static Matcher startsWithIgnoringCase(String prefix) { return new StringStartsWith(true, prefix); } diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/SubstringMatcher.java b/hamcrest/src/main/java/org/hamcrest/core/SubstringMatcher.java similarity index 61% rename from hamcrest-core/src/main/java/org/hamcrest/core/SubstringMatcher.java rename to hamcrest/src/main/java/org/hamcrest/core/SubstringMatcher.java index 85c6657e3..80b6a4fe1 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/core/SubstringMatcher.java +++ b/hamcrest/src/main/java/org/hamcrest/core/SubstringMatcher.java @@ -3,6 +3,13 @@ import org.hamcrest.Description; import org.hamcrest.TypeSafeMatcher; +/** + * Common behaviour for matchers that check substrings. + * + * @see StringContains + * @see StringEndsWith + * @see StringStartsWith + */ public abstract class SubstringMatcher extends TypeSafeMatcher { // TODO: Replace String with CharSequence to allow for easy interoperability between @@ -10,12 +17,22 @@ public abstract class SubstringMatcher extends TypeSafeMatcher { private final String relationship; private final boolean ignoringCase; + /** The substring to match */ protected final String substring; + /** + * Build a SubstringMatcher. + * @param relationship a description of the matcher, such as "containing", "ending with", or "starting with" + * @param ignoringCase true for case-insensitive match + * @param substring the substring to match + */ protected SubstringMatcher(String relationship, boolean ignoringCase, String substring) { this.relationship = relationship; this.ignoringCase = ignoringCase; this.substring = substring; + if (null == substring) { + throw new IllegalArgumentException("missing substring"); + } } @Override @@ -26,7 +43,7 @@ public boolean matchesSafely(String item) { public void describeMismatchSafely(String item, Description mismatchDescription) { mismatchDescription.appendText("was \"").appendText(item).appendText("\""); } - + @Override public void describeTo(Description description) { description.appendText("a string ") @@ -38,7 +55,18 @@ public void describeTo(Description description) { } } + /** + * Helper method to allow subclasses to handle case insensitivity. + * @param arg the string to adjust for case + * @return the input string in lowercase if ignoring case, otherwise the original string + */ protected String converted(String arg) { return ignoringCase ? arg.toLowerCase() : arg; } + + /** + * Checks if the input matches the specific substring. + * @param string the string to check + * @return the result of the match + */ protected abstract boolean evalSubstringOf(String string); } diff --git a/hamcrest/src/main/java/org/hamcrest/core/package-info.java b/hamcrest/src/main/java/org/hamcrest/core/package-info.java new file mode 100644 index 000000000..19c433d90 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/core/package-info.java @@ -0,0 +1,4 @@ +/** + * Fundamental matchers of objects and values, and composite matchers. + */ +package org.hamcrest.core; diff --git a/hamcrest/src/main/java/org/hamcrest/exception/ThrowsException.java b/hamcrest/src/main/java/org/hamcrest/exception/ThrowsException.java new file mode 100644 index 000000000..aebb96b7c --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/exception/ThrowsException.java @@ -0,0 +1,149 @@ +package org.hamcrest.exception; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.hamcrest.core.IsInstanceOf; + +import static org.hamcrest.core.IsAnything.anything; +import static org.hamcrest.core.IsEqual.equalTo; + +/** + * Tests if a Runnable throws a matching exception. + * + * @param the type of the matched Runnable + */ +public class ThrowsException extends TypeSafeDiagnosingMatcher { + private final IsInstanceOf classMatcher; + private final Matcher messageMatcher; + + /** + * Constructor, best called from one of the static {@link #throwsException()} methods. + * @param classMatcher the matcher for the type of the exception + * @param messageMatcher the matcher for the exception message + */ + public ThrowsException(IsInstanceOf classMatcher, Matcher messageMatcher) { + this.classMatcher = classMatcher; + this.messageMatcher = messageMatcher; + } + + /** + * Matcher for {@link Runnable} that expects an exception to be thrown + * + * @param type of the Runnable + * @return The matcher. + */ + public static Matcher throwsException() { + return throwsException(Throwable.class); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception equal + * to the provided throwable + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwable the Throwable class against which examined exceptions are compared + * @return The matcher. + */ + public static Matcher throwsException(U throwable) { + return throwsException(throwable.getClass(), throwable.getMessage()); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the + * provided throwableClass class + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass) { + return new ThrowsException<>(new IsInstanceOf(throwableClass), anything("")); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the + * provided throwableClass class and has a message equal to the provided + * message + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @param exactMessage the String against which examined exception messages are compared + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass, String exactMessage) { + return throwsException(throwableClass, equalTo(exactMessage)); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided + * throwableClass class and has a message matching the provided + * messageMatcher + * + * @param type of the Runnable + * @param type of the Throwable + * @param throwableClass the Throwable class against which examined exceptions are compared + * @param messageMatcher matcher to validate exception's message + * @return The matcher. + */ + public static Matcher throwsException(Class throwableClass, Matcher messageMatcher) { + return new ThrowsException<>(new IsInstanceOf(throwableClass), messageMatcher); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception with a message equal to the provided message + * + * @param type of the Runnable + * @param exactMessage the String against which examined exception messages are compared + * @return The matcher. + */ + public static Matcher throwsExceptionWithMessage(String exactMessage) { + return throwsException(Throwable.class, equalTo(exactMessage)); + } + + /** + * Matcher for {@link Throwable} that expects that the Runnable throws an exception with a message matching the provided messageMatcher + * + * @param type of the Runnable + * @param messageMatcher matcher to validate exception's message + * @return The matcher. + */ + public static Matcher throwsExceptionWithMessage(Matcher messageMatcher) { + return throwsException(Throwable.class, messageMatcher); + } + + @Override + protected boolean matchesSafely(T runnable, Description mismatchDescription) { + try { + runnable.run(); + mismatchDescription.appendText("the runnable didn't throw"); + return false; + } catch (Throwable t) { + boolean classMatches = classMatcher.matches(t); + if (!classMatches) { + mismatchDescription.appendText("thrown exception class was ").appendText(t.getClass().getName()); + } + + boolean messageMatches = messageMatcher.matches(t.getMessage()); + if (!messageMatches) { + if (!classMatches) { + mismatchDescription.appendText(" and the "); + } + mismatchDescription.appendText("thrown exception message "); + messageMatcher.describeMismatch(t.getMessage(), mismatchDescription); + } + + return classMatches && messageMatches; + } + } + + @Override + public void describeTo(Description description) { + description + .appendText("a runnable throwing ").appendDescriptionOf(classMatcher) + .appendText(" with message ").appendDescriptionOf(messageMatcher); + } +} diff --git a/hamcrest/src/main/java/org/hamcrest/exception/package-info.java b/hamcrest/src/main/java/org/hamcrest/exception/package-info.java new file mode 100644 index 000000000..8b85543e9 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/exception/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers of exceptions. + */ +package org.hamcrest.exception; diff --git a/hamcrest-core/src/main/java/org/hamcrest/internal/ArrayIterator.java b/hamcrest/src/main/java/org/hamcrest/internal/ArrayIterator.java similarity index 98% rename from hamcrest-core/src/main/java/org/hamcrest/internal/ArrayIterator.java rename to hamcrest/src/main/java/org/hamcrest/internal/ArrayIterator.java index 03e4c43e3..a92942e72 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/internal/ArrayIterator.java +++ b/hamcrest/src/main/java/org/hamcrest/internal/ArrayIterator.java @@ -4,16 +4,17 @@ import java.util.Iterator; public class ArrayIterator implements Iterator { + private final Object array; private int currentIndex = 0; - + public ArrayIterator(Object array) { if (!array.getClass().isArray()) { throw new IllegalArgumentException("not an array"); } this.array = array; } - + @Override public boolean hasNext() { return currentIndex < Array.getLength(array); @@ -23,9 +24,10 @@ public boolean hasNext() { public Object next() { return Array.get(array, currentIndex++); } - + @Override public void remove() { throw new UnsupportedOperationException("cannot remove items from an array"); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/internal/NullSafety.java b/hamcrest/src/main/java/org/hamcrest/internal/NullSafety.java similarity index 93% rename from hamcrest-core/src/main/java/org/hamcrest/internal/NullSafety.java rename to hamcrest/src/main/java/org/hamcrest/internal/NullSafety.java index 9310abfc0..d27349a4d 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/internal/NullSafety.java +++ b/hamcrest/src/main/java/org/hamcrest/internal/NullSafety.java @@ -7,12 +7,14 @@ import java.util.List; public class NullSafety { + @SuppressWarnings("unchecked") public static List> nullSafe(Matcher[] itemMatchers) { - final List> matchers = new ArrayList>(itemMatchers.length); + final List> matchers = new ArrayList<>(itemMatchers.length); for (final Matcher itemMatcher : itemMatchers) { matchers.add((Matcher) (itemMatcher == null ? IsNull.nullValue() : itemMatcher)); } return matchers; } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java b/hamcrest/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java similarity index 55% rename from hamcrest-core/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java rename to hamcrest/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java index ada74d6bb..b04d5701f 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java +++ b/hamcrest/src/main/java/org/hamcrest/internal/ReflectiveTypeFinder.java @@ -1,43 +1,58 @@ +package org.hamcrest.internal; + +import java.lang.reflect.Method; + /** - * The TypeSafe classes, and their descendants, need a mechanism to find out what type has been used as a parameter - * for the concrete matcher. Unfortunately, this type is lost during type erasure so we need to use reflection - * to get it back, by picking out the type of a known parameter to a known method. - * The catch is that, with bridging methods, this type is only visible in the class that actually implements + *

    Find the declared type of a parameterized type at runtime, bypassing normal type erasure problems. + *

    + *

    The TypeSafe classes, and their descendants, need a mechanism to find out what type has been used as a parameter + * for the concrete matcher. Unfortunately, this type is lost during type erasure, so we need to use reflection + * to get it back, by picking out the type of a known parameter to a known method. + * The catch is that, with bridging methods, this type is only visible in the class that actually implements * the expected method, so the ReflectiveTypeFinder needs to be applied to that class or a subtype. - * - * For example, the abstract TypeSafeDiagnosingMatcher<T> defines an abstract method - *

    protected abstract boolean matchesSafely(T item, Description mismatchDescription);
    - * By default it uses new ReflectiveTypeFinder("matchesSafely", 2, 0); to find the + *

    + *

    For example, the abstract TypeSafeDiagnosingMatcher<T> defines an abstract method + * protected abstract boolean matchesSafely(T item, Description mismatchDescription); + * By default, it uses new ReflectiveTypeFinder("matchesSafely", 2, 0); to find the * parameterised type. If we create a TypeSafeDiagnosingMatcher<String>, the type * finder will return String.class. - * - * A FeatureMatcher is an abstract subclass of TypeSafeDiagnosingMatcher. + *

    + *

    Another example: a FeatureMatcher is an abstract subclass of TypeSafeDiagnosingMatcher. * Although it has a templated implementation of matchesSafely(<T>, Description);, the * actual run-time signature of this is matchesSafely(Object, Description);. Instead, - * we must find the type by reflecting on the concrete implementation of - *

    protected abstract U featureValueOf(T actual);
    + * we must find the type by reflecting on the concrete implementation of + * protected abstract U featureValueOf(T actual);, * a method which is declared in FeatureMatcher. - * - * In short, use this to extract a type from a method in the leaf class of a templated class hierarchy. - * + *

    + *

    In short, use this to extract a type from a method in the leaf class of a templated class hierarchy. + *

    + * * @author Steve Freeman * @author Nat Pryce */ -package org.hamcrest.internal; - -import java.lang.reflect.Method; - public class ReflectiveTypeFinder { + private final String methodName; private final int expectedNumberOfParameters; private final int typedParameter; + /** + * Create a ReflectiveTypeFinder for a specific parameter on a specific method. + * @param methodName the name of a method in the leaf class that has a templated type + * @param expectedNumberOfParameters the expected number of parameters to the method + * @param typedParameter the index of the parameter that has the type information we want to look up + */ public ReflectiveTypeFinder(String methodName, int expectedNumberOfParameters, int typedParameter) { this.methodName = methodName; this.expectedNumberOfParameters = expectedNumberOfParameters; this.typedParameter = typedParameter; } - + + /** + * Find the parameterized type from the specified parameter on the specified method. + * @param fromClass the class containing the method with the parameterized type + * @return the method parameter type + */ public Class findExpectedType(Class fromClass) { for (Class c = fromClass; c != Object.class; c = c.getSuperclass()) { for (Method method : c.getDeclaredMethods()) { @@ -53,18 +68,18 @@ public Class findExpectedType(Class fromClass) { * @param method The method to examine. * @return true if this method references the relevant type */ - protected boolean canObtainExpectedTypeFrom(Method method) { + private boolean canObtainExpectedTypeFrom(Method method) { return method.getName().equals(methodName) && method.getParameterTypes().length == expectedNumberOfParameters && !method.isSynthetic(); } - /** * @param method The method from which to extract * @return The type we're looking for */ - protected Class expectedTypeFrom(Method method) { + private Class expectedTypeFrom(Method method) { return method.getParameterTypes()[typedParameter]; } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValue.java b/hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValue.java similarity index 98% rename from hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValue.java rename to hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValue.java index 6537018a6..6a5415cb6 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValue.java +++ b/hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValue.java @@ -4,8 +4,9 @@ import org.hamcrest.SelfDescribing; public class SelfDescribingValue implements SelfDescribing { + private T value; - + public SelfDescribingValue(T value) { this.value = value; } @@ -14,4 +15,5 @@ public SelfDescribingValue(T value) { public void describeTo(Description description) { description.appendValue(value); } + } diff --git a/hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java b/hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java similarity index 98% rename from hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java rename to hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java index bc8f8f43a..ba79806e5 100644 --- a/hamcrest-core/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java +++ b/hamcrest/src/main/java/org/hamcrest/internal/SelfDescribingValueIterator.java @@ -5,12 +5,13 @@ import java.util.Iterator; public class SelfDescribingValueIterator implements Iterator { + private Iterator values; - + public SelfDescribingValueIterator(Iterator values) { this.values = values; } - + @Override public boolean hasNext() { return values.hasNext(); @@ -25,4 +26,5 @@ public SelfDescribing next() { public void remove() { values.remove(); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/internal/package-info.java b/hamcrest/src/main/java/org/hamcrest/internal/package-info.java new file mode 100644 index 000000000..76947703e --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/internal/package-info.java @@ -0,0 +1,4 @@ +/** + * Internal helper classes used by Hamcrest internals. + */ +package org.hamcrest.internal; \ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/io/FileMatchers.java b/hamcrest/src/main/java/org/hamcrest/io/FileMatchers.java similarity index 65% rename from hamcrest-library/src/main/java/org/hamcrest/io/FileMatchers.java rename to hamcrest/src/main/java/org/hamcrest/io/FileMatchers.java index 88288b07a..cd4d354a5 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/io/FileMatchers.java +++ b/hamcrest/src/main/java/org/hamcrest/io/FileMatchers.java @@ -10,44 +10,90 @@ import static org.hamcrest.core.IsEqual.equalTo; +/** + * Matchers for properties of files. + */ public final class FileMatchers { + private FileMatchers() { + } + + /** + * A matcher that checks if a directory exists. + * @return the file matcher + */ public static Matcher anExistingDirectory() { return fileChecker(IS_DIRECTORY, "an existing directory", "is not a directory"); } + /** + * A matcher that checks if a file or directory exists. + * @return the file matcher + */ public static Matcher anExistingFileOrDirectory() { return fileChecker(EXISTS, "an existing file or directory", "does not exist"); } + /** + * A matcher that checks if a file exists. + * @return the file matcher + */ public static Matcher anExistingFile() { return fileChecker(IS_FILE, "an existing File", "is not a file"); } + /** + * A matcher that checks if a file is readable. + * @return the file matcher + */ public static Matcher aReadableFile() { return fileChecker(CAN_READ, "a readable File", "cannot be read"); } + /** + * A matcher that checks if a directory is writable. + * @return the file matcher + */ public static Matcher aWritableFile() { return fileChecker(CAN_WRITE, "a writable File", "cannot be written to"); } + /** + * A matcher that checks if a file has a specific size. + * @param size the expected size + * @return the file matcher + */ public static Matcher aFileWithSize(long size) { return aFileWithSize(equalTo(size)); } + /** + * A matcher that checks if a file size matches an expected size. + * @param expected matcher for the expected size + * @return the file matcher + */ public static Matcher aFileWithSize(final Matcher expected) { return new FeatureMatcher(expected, "A file with size", "size") { @Override protected Long featureValueOf(File actual) { return actual.length(); } }; } + /** + * A matcher that checks if a file name matches an expected name. + * @param expected the expected name + * @return the file matcher + */ public static Matcher aFileNamed(final Matcher expected) { return new FeatureMatcher(expected, "A file with name", "name") { @Override protected String featureValueOf(File actual) { return actual.getName(); } }; } + /** + * A matcher that checks if a file canonical path matches an expected path. + * @param expected the expected path + * @return the file matcher + */ public static Matcher aFileWithCanonicalPath(final Matcher expected) { return new FeatureMatcher(expected, "A file with canonical path", "path") { @Override protected String featureValueOf(File actual) { @@ -60,31 +106,60 @@ public static Matcher aFileWithCanonicalPath(final Matcher expecte }; } + /** + * A matcher that checks if a file absolute path matches an expected path. + * @param expected the expected path + * @return the file matcher + */ public static Matcher aFileWithAbsolutePath(final Matcher expected) { return new FeatureMatcher(expected, "A file with absolute path", "path") { @Override protected String featureValueOf(File actual) { return actual.getAbsolutePath(); } }; } - public static interface FileStatus { + /** + * Checks the status of a {@link File}. + */ + public interface FileStatus { + /** + * Checks the give file against a status. + * @param actual the file to check + * @return true if the file status matches, otherwise false. + */ boolean check(File actual); } + /** + * Checks if a {@link File} is writable. + */ public static final FileStatus CAN_WRITE = new FileStatus() { @Override public boolean check(File actual) { return actual.canWrite(); } }; + + /** + * Checks if a {@link File} is readable. + */ public static final FileStatus CAN_READ = new FileStatus() { @Override public boolean check(File actual) { return actual.canRead(); } }; + /** + * Checks if a {@link File} is a file. + */ public static final FileStatus IS_FILE = new FileStatus() { @Override public boolean check(File actual) { return actual.isFile(); } }; + /** + * Checks if a {@link File} is a directory. + */ public static final FileStatus IS_DIRECTORY = new FileStatus() { @Override public boolean check(File actual) { return actual.isDirectory(); } }; + /** + * Checks if a {@link File} is a exists. + */ public static final FileStatus EXISTS = new FileStatus() { @Override public boolean check(File actual) { return actual.exists(); } }; @@ -94,7 +169,7 @@ private static Matcher fileChecker(final FileStatus fileStatus, final Stri public boolean matchesSafely(File actual, Description mismatchDescription) { final boolean result = fileStatus.check(actual); if (!result) { - mismatchDescription.appendText(failureDescription); + mismatchDescription.appendText(String.format("'%s' %s", actual, failureDescription)); } return result; } @@ -104,4 +179,5 @@ public void describeTo(Description description) { } }; } + } diff --git a/hamcrest/src/main/java/org/hamcrest/io/package-info.java b/hamcrest/src/main/java/org/hamcrest/io/package-info.java new file mode 100644 index 000000000..a187b6e7f --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/io/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers that perform file comparisons. + */ +package org.hamcrest.io; \ No newline at end of file diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java b/hamcrest/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java similarity index 83% rename from hamcrest-library/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java rename to hamcrest/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java index d9cb02642..d2f23f937 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java +++ b/hamcrest/src/main/java/org/hamcrest/number/BigDecimalCloseTo.java @@ -3,15 +3,25 @@ import org.hamcrest.Description; import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher; +import org.hamcrest.collection.ArrayMatching; import java.math.BigDecimal; import java.math.MathContext; +/** + * A matcher that checks a {@link BigDecimal} is close to an expected value. + */ public class BigDecimalCloseTo extends TypeSafeMatcher { private final BigDecimal delta; private final BigDecimal value; + /** + * Constructor, best called from {@link #closeTo(BigDecimal, BigDecimal)}. + * @param value the expected value + * @param error the acceptable difference from the expected value + * @see #closeTo(BigDecimal, BigDecimal) + */ public BigDecimalCloseTo(BigDecimal value, BigDecimal error) { this.delta = error; this.value = value; @@ -49,15 +59,15 @@ private BigDecimal actualDelta(BigDecimal item) { * is done by BigDecimals {@link java.math.BigDecimal#compareTo(java.math.BigDecimal)} method. * For example: *
    assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
    - * + * * @param operand * the expected value of matching BigDecimals * @param error * the delta (+/-) within which matches will be allowed + * @return The matcher. */ public static Matcher closeTo(BigDecimal operand, BigDecimal error) { return new BigDecimalCloseTo(operand, error); } } - diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java b/hamcrest/src/main/java/org/hamcrest/number/IsCloseTo.java similarity index 85% rename from hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java rename to hamcrest/src/main/java/org/hamcrest/number/IsCloseTo.java index 3b6967dce..34c0aa532 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/number/IsCloseTo.java +++ b/hamcrest/src/main/java/org/hamcrest/number/IsCloseTo.java @@ -6,15 +6,19 @@ import static java.lang.Math.abs; - /** - * Is the value a number equal to a value within some range of - * acceptable error? + * Is the value a number equal to a value within some range of acceptable error? */ public class IsCloseTo extends TypeSafeMatcher { + private final double delta; private final double value; + /** + * Constructor, best called from {@link #closeTo(double, double)}. + * @param value the expected value + * @param error the acceptable difference from the expected value + */ public IsCloseTo(double value, double error) { this.delta = error; this.value = value; @@ -51,13 +55,15 @@ private double actualDelta(Double item) { * to the specified operand, within a range of +/- error. * For example: *
    assertThat(1.03, is(closeTo(1.0, 0.03)))
    - * + * * @param operand * the expected value of matching doubles * @param error * the delta (+/-) within which matches will be allowed + * @return The matcher. */ public static Matcher closeTo(double operand, double error) { return new IsCloseTo(operand, error); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/IsNaN.java b/hamcrest/src/main/java/org/hamcrest/number/IsNaN.java similarity index 96% rename from hamcrest-library/src/main/java/org/hamcrest/number/IsNaN.java rename to hamcrest/src/main/java/org/hamcrest/number/IsNaN.java index 415a9a2b7..ae87e28af 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/number/IsNaN.java +++ b/hamcrest/src/main/java/org/hamcrest/number/IsNaN.java @@ -4,7 +4,6 @@ import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher; - /** * Is the value a number actually not a number (NaN)? */ @@ -31,8 +30,11 @@ public void describeTo(Description description) { * Creates a matcher of {@link Double}s that matches when an examined double is not a number. * For example: *
    assertThat(Double.NaN, is(notANumber()))
    + * + * @return The matcher. */ public static Matcher notANumber() { return new IsNaN(); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparison.java b/hamcrest/src/main/java/org/hamcrest/number/OrderingComparison.java similarity index 88% rename from hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparison.java rename to hamcrest/src/main/java/org/hamcrest/number/OrderingComparison.java index 8a77713db..d3fe15453 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparison.java +++ b/hamcrest/src/main/java/org/hamcrest/number/OrderingComparison.java @@ -3,6 +3,9 @@ import org.hamcrest.Matcher; import org.hamcrest.comparator.ComparatorMatcherBuilder; +/** + * Static methods for building ordering comparisons. + */ public class OrderingComparison { private OrderingComparison() { @@ -15,7 +18,10 @@ private OrderingComparison() { * For example: *
    assertThat(1, comparesEqualTo(1))
    * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return zero + * @return The matcher. */ public static > Matcher comparesEqualTo(T value) { return ComparatorMatcherBuilder.usingNaturalOrdering().comparesEqualTo(value); @@ -28,8 +34,11 @@ public static > Matcher comparesEqualTo(T value) { * For example: *
    assertThat(2, greaterThan(1))
    * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return greater * than zero + * @return The matcher. */ public static > Matcher greaterThan(T value) { return ComparatorMatcherBuilder.usingNaturalOrdering().greaterThan(value); @@ -42,8 +51,11 @@ public static > Matcher greaterThan(T value) { * For example: *
    assertThat(1, greaterThanOrEqualTo(1))
    * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return greater * than or equal to zero + * @return The matcher. */ public static > Matcher greaterThanOrEqualTo(T value) { return ComparatorMatcherBuilder.usingNaturalOrdering().greaterThanOrEqualTo(value); @@ -56,8 +68,11 @@ public static > Matcher greaterThanOrEqualTo(T value) * For example: *
    assertThat(1, lessThan(2))
    * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return less * than zero + * @return The matcher. */ public static > Matcher lessThan(T value) { return ComparatorMatcherBuilder.usingNaturalOrdering().lessThan(value); @@ -70,10 +85,14 @@ public static > Matcher lessThan(T value) { * For example: *
    assertThat(1, lessThanOrEqualTo(1))
    * + * @param + * the matcher type. * @param value the value which, when passed to the compareTo method of the examined object, should return less * than or equal to zero + * @return The matcher. */ public static > Matcher lessThanOrEqualTo(T value) { return ComparatorMatcherBuilder.usingNaturalOrdering().lessThanOrEqualTo(value); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/number/package-info.java b/hamcrest/src/main/java/org/hamcrest/number/package-info.java new file mode 100644 index 000000000..58782082d --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/number/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers that perform numeric comparisons. + */ +package org.hamcrest.number; diff --git a/hamcrest/src/main/java/org/hamcrest/object/HasEqualValues.java b/hamcrest/src/main/java/org/hamcrest/object/HasEqualValues.java new file mode 100644 index 000000000..dfd55c4f0 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/object/HasEqualValues.java @@ -0,0 +1,94 @@ +package org.hamcrest.object; + +import org.hamcrest.Description; +import org.hamcrest.DiagnosingMatcher; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.hamcrest.core.IsEqual; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; + +import static java.lang.String.format; + +/** + * A matcher that checks if an object as equal fields values to an expected object. + * @param the type of the object being matched. + */ +public class HasEqualValues extends TypeSafeDiagnosingMatcher { + + private final T expectedObject; + private final List fieldMatchers; + + /** + * Constructor + * @param expectedObject the object with expected field values. + */ + public HasEqualValues(T expectedObject) { + super(expectedObject.getClass()); + this.expectedObject = expectedObject; + this.fieldMatchers = fieldMatchers(expectedObject); + } + + @Override + protected boolean matchesSafely(T item, Description mismatch) { + for (FieldMatcher fieldMatcher : fieldMatchers) { + if (!fieldMatcher.matches(item, mismatch)) { + return false; + } + } + return true; + } + + @Override + public void describeTo(Description description) { + description.appendText(expectedObject.getClass().getSimpleName()) + .appendText(" has values ") + .appendList("[", ", ", "]", fieldMatchers); + } + + private static class FieldMatcher extends DiagnosingMatcher { + private final Field field; + private final Matcher matcher; + + public FieldMatcher(Field field, Object expectedObject) { + this.field = field; + this.matcher = IsEqual.equalTo(uncheckedGet(field, expectedObject)); + } + @Override + protected boolean matches(Object item, Description mismatch) { + final Object actual = uncheckedGet(field, item); + if (!matcher.matches(actual)) { + mismatch.appendText("'").appendText(field.getName()).appendText("' "); + matcher.describeMismatch(actual, mismatch); + return false; + } + return true; + } + + @Override + public void describeTo(Description description) { + description.appendText(field.getName()) + .appendText(": ") + .appendDescriptionOf(matcher); + } + } + + private static List fieldMatchers(Object expectedObject) { + final List result = new ArrayList<>(); + for (Field field : expectedObject.getClass().getFields()) { + result.add(new FieldMatcher(field, expectedObject)); + } + return result; + } + + private static Object uncheckedGet(Field field, Object object) { + try { + return field.get(object); + } catch (Exception e) { + throw new AssertionError(format("IllegalAccess, reading field '%s' from %s", field.getName(), object)); + } + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java b/hamcrest/src/main/java/org/hamcrest/object/HasToString.java similarity index 68% rename from hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java rename to hamcrest/src/main/java/org/hamcrest/object/HasToString.java index 2dab9de4c..336b8227e 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/object/HasToString.java +++ b/hamcrest/src/main/java/org/hamcrest/object/HasToString.java @@ -5,11 +5,20 @@ import static org.hamcrest.core.IsEqual.equalTo; +/** + * A Matcher that checks the output of the toString() method. + * @param The Matcher type. + */ public class HasToString extends FeatureMatcher { + + /** + * Constructor, best called from {@link #hasToString(String)} or {@link #hasToString(Matcher)}. + * @param toStringMatcher expected result from calling toString() + */ public HasToString(Matcher toStringMatcher) { super(toStringMatcher, "with toString()", "toString()"); } - + @Override protected String featureValueOf(T actual) { return String.valueOf(actual); @@ -20,12 +29,15 @@ protected String featureValueOf(T actual) { * returns a value that satisfies the specified matcher. * For example: *
    assertThat(true, hasToString(equalTo("TRUE")))
    - * + * + * @param + * the matcher type. * @param toStringMatcher * the matcher used to verify the toString result + * @return The matcher. */ public static Matcher hasToString(Matcher toStringMatcher) { - return new HasToString(toStringMatcher); + return new HasToString<>(toStringMatcher); } /** @@ -33,11 +45,15 @@ public static Matcher hasToString(Matcher toStringMatcher * returns a value equalTo the specified string. * For example: *
    assertThat(true, hasToString("TRUE"))
    - * + * + * @param + * the matcher type. * @param expectedToString * the expected toString result + * @return The matcher. */ public static Matcher hasToString(String expectedToString) { - return new HasToString(equalTo(expectedToString)); + return new HasToString<>(equalTo(expectedToString)); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java b/hamcrest/src/main/java/org/hamcrest/object/IsCompatibleType.java similarity index 73% rename from hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java rename to hamcrest/src/main/java/org/hamcrest/object/IsCompatibleType.java index e1410a47b..10b86f085 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/object/IsCompatibleType.java +++ b/hamcrest/src/main/java/org/hamcrest/object/IsCompatibleType.java @@ -4,38 +4,51 @@ import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher; +/** + * A matcher of {@link Class} that matches when the specified baseType is assignable from the examined class. + * @param the type of the class + */ public class IsCompatibleType extends TypeSafeMatcher> { + private final Class type; - + + /** + * Constructor, best called from {@link #typeCompatibleWith(Class)}. + * @param type the expected type + */ public IsCompatibleType(Class type) { this.type = type; } - + @Override public boolean matchesSafely(Class cls) { return type.isAssignableFrom(cls); } - + @Override public void describeMismatchSafely(Class cls, Description mismatchDescription) { mismatchDescription.appendValue(cls.getName()); } - + @Override public void describeTo(Description description) { description.appendText("type < ").appendText(type.getName()); } - + /** * Creates a matcher of {@link Class} that matches when the specified baseType is * assignable from the examined class. * For example: *
    assertThat(Integer.class, typeCompatibleWith(Number.class))
    - * + * + * @param + * the matcher type. * @param baseType * the base class to examine classes against + * @return The matcher. */ public static Matcher> typeCompatibleWith(Class baseType) { - return new IsCompatibleType(baseType); + return new IsCompatibleType<>(baseType); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java b/hamcrest/src/main/java/org/hamcrest/object/IsEventFrom.java similarity index 88% rename from hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java rename to hamcrest/src/main/java/org/hamcrest/object/IsEventFrom.java index 43b64d464..b31a14784 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/object/IsEventFrom.java +++ b/hamcrest/src/main/java/org/hamcrest/object/IsEventFrom.java @@ -6,14 +6,19 @@ import java.util.EventObject; - /** * Tests if the value is an event announced by a specific object. */ public class IsEventFrom extends TypeSafeDiagnosingMatcher { + private final Class eventClass; private final Object source; + /** + * Constructor, best called from {@link #eventFrom(Object)} or {@link #eventFrom(Class, Object)}. + * @param eventClass the expected class of the event + * @param source the expected source of the event + */ public IsEventFrom(Class eventClass, Object source) { this.eventClass = eventClass; this.source = source; @@ -25,7 +30,7 @@ public boolean matchesSafely(EventObject item, Description mismatchDescription) mismatchDescription.appendText("item type was " + item.getClass().getName()); return false; } - + if (!eventHasSameSource(item)) { mismatchDescription.appendText("source was ").appendValue(item.getSource()); return false; @@ -33,7 +38,6 @@ public boolean matchesSafely(EventObject item, Description mismatchDescription) return true; } - private boolean eventHasSameSource(EventObject ev) { return ev.getSource() == source; } @@ -51,11 +55,12 @@ public void describeTo(Description description) { * derived from eventClass announced by source. * For example: *
    assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
    - * + * * @param eventClass * the class of the event to match on * @param source * the source of the event + * @return The matcher. */ public static Matcher eventFrom(Class eventClass, Object source) { return new IsEventFrom(eventClass, source); @@ -66,11 +71,13 @@ public static Matcher eventFrom(Class eventC * announced by source. * For example: *
    assertThat(myEvent, is(eventFrom(myBean)))
    - * + * * @param source * the source of the event + * @return The matcher. */ public static Matcher eventFrom(Object source) { return eventFrom(EventObject.class, source); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/object/package-info.java b/hamcrest/src/main/java/org/hamcrest/object/package-info.java new file mode 100644 index 000000000..b6f56b574 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/object/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers that inspect objects and classes. + */ +package org.hamcrest.object; diff --git a/hamcrest/src/main/java/org/hamcrest/optional/OptionalEmpty.java b/hamcrest/src/main/java/org/hamcrest/optional/OptionalEmpty.java new file mode 100644 index 000000000..eafef28a8 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/optional/OptionalEmpty.java @@ -0,0 +1,42 @@ +package org.hamcrest.optional; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +import java.util.Optional; + +/** + * Matcher that expects an empty {@link Optional}. + + * @param type of {@link Optional} value + */ +public class OptionalEmpty extends TypeSafeDiagnosingMatcher> { + + /** + * Constructor, best called from {@link #emptyOptional()}. + */ + public OptionalEmpty() { + } + + /** + * Matcher that expects empty {@link Optional}. + * + * @param type of optional value + * @return The matcher. + */ + public static Matcher> emptyOptional() { + return new OptionalEmpty<>(); + } + + @Override + protected boolean matchesSafely(Optional value, Description mismatchDescription) { + mismatchDescription.appendText("is " + value); + return !value.isPresent(); + } + + @Override + public void describeTo(Description description) { + description.appendText("empty"); + } +} diff --git a/hamcrest/src/main/java/org/hamcrest/optional/OptionalWithValue.java b/hamcrest/src/main/java/org/hamcrest/optional/OptionalWithValue.java new file mode 100644 index 000000000..ebd571d18 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/optional/OptionalWithValue.java @@ -0,0 +1,73 @@ +package org.hamcrest.optional; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.hamcrest.core.IsAnything; + +import java.util.Optional; + +import static org.hamcrest.core.IsEqual.equalTo; + +/** + * Matcher for {@link Optional} that expects that value is present. + * + * @param type of {@link Optional} value + */ +public class OptionalWithValue extends TypeSafeDiagnosingMatcher> { + + private final Matcher matcher; + + /** + * Constructor. + * + * @param matcher matcher to validate present optional value + */ + public OptionalWithValue(Matcher matcher) { + this.matcher = matcher; + } + + /** + * Matcher for {@link Optional} that expects that value is present. + * + * @param type of optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue() { + return new OptionalWithValue<>(IsAnything.anything("any")); + } + + /** + * Matcher for {@link Optional} that expects that value is present and is equal to value + * + * @param type of optional value + * @param value to validate present optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue(T value) { + return new OptionalWithValue<>(equalTo(value)); + } + + /** + * Matcher for {@link Optional} that expects that value is present and matches matcher + * + * @param type of optional value + * @param matcher matcher to validate present optional value + * @return The matcher. + */ + public static Matcher> optionalWithValue(Matcher matcher) { + return new OptionalWithValue<>(matcher); + } + + @Override + protected boolean matchesSafely(Optional value, Description mismatchDescription) { + mismatchDescription.appendText("is " + value); + return value.isPresent() && matcher.matches(value.get()); + } + + @Override + public void describeTo(Description description) { + description.appendText("present and matches ") + .appendDescriptionOf(matcher); + } +} diff --git a/hamcrest/src/main/java/org/hamcrest/optional/package-info.java b/hamcrest/src/main/java/org/hamcrest/optional/package-info.java new file mode 100644 index 000000000..5be420505 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/optional/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers that perform comparisons on {@link java.util.Optional} instances. + */ +package org.hamcrest.optional; diff --git a/hamcrest/src/main/java/org/hamcrest/package-info.java b/hamcrest/src/main/java/org/hamcrest/package-info.java new file mode 100644 index 000000000..220086b38 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/package-info.java @@ -0,0 +1,4 @@ +/** + * Top level matcher classes and interfaces. + */ +package org.hamcrest; \ No newline at end of file diff --git a/hamcrest/src/main/java/org/hamcrest/text/CharSequenceLength.java b/hamcrest/src/main/java/org/hamcrest/text/CharSequenceLength.java new file mode 100644 index 000000000..06ca9676c --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/text/CharSequenceLength.java @@ -0,0 +1,64 @@ +package org.hamcrest.text; + +import org.hamcrest.FeatureMatcher; +import org.hamcrest.Matcher; + +import java.math.BigDecimal; + +import static org.hamcrest.CoreMatchers.equalTo; + +/** + * A Matcher that checks the length of a string. + * @author Marco Leichsenring + * @author Steve Freeman + */ +public class CharSequenceLength extends FeatureMatcher { + + + /** + * Constructor, best called from {@link #hasLength(Matcher)}. + * @param lengthMatcher the expected length + * @see #hasLength(Matcher) + */ + @SuppressWarnings("WeakerAccess") + public CharSequenceLength(Matcher lengthMatcher) { + super(lengthMatcher, "a CharSequence with length", "length"); + } + + @Override + protected Integer featureValueOf(CharSequence actual) { + return actual.length(); + } + + /** + * Creates a matcher of {@link CharSequence} that matches when a char sequence has the given length + * For example: + * + *
    +     * assertThat("text", hasLength(4))
    +     * 
    + * + * @param length the expected length of the string + * @return The matcher. + */ + public static Matcher hasLength(int length) { + return new CharSequenceLength(equalTo(length)); + } + + /** + * Creates a matcher of {@link CharSequence} that matches when a char sequence has the given length + * For example: + * + *
    +      * assertThat("text", hasLength(lessThan(4)))
    +      * 
    + * + * @param lengthMatcher the expected length of the string + * @return The matcher. + */ + @SuppressWarnings("WeakerAccess") + public static Matcher hasLength(Matcher lengthMatcher) { + return new CharSequenceLength(lengthMatcher); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsBlankString.java b/hamcrest/src/main/java/org/hamcrest/text/IsBlankString.java similarity index 95% rename from hamcrest-library/src/main/java/org/hamcrest/text/IsBlankString.java rename to hamcrest/src/main/java/org/hamcrest/text/IsBlankString.java index b168541b0..c026fac26 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/text/IsBlankString.java +++ b/hamcrest/src/main/java/org/hamcrest/text/IsBlankString.java @@ -1,4 +1,3 @@ - package org.hamcrest.text; import org.hamcrest.Description; @@ -14,6 +13,7 @@ * Matches blank Strings (and null). */ public final class IsBlankString extends TypeSafeMatcher { + private static final IsBlankString BLANK_INSTANCE = new IsBlankString(); @SuppressWarnings("unchecked") private static final Matcher NULL_OR_BLANK_INSTANCE = anyOf(nullValue(), BLANK_INSTANCE); @@ -37,6 +37,8 @@ public void describeTo(Description description) { * zero or more whitespace characters and nothing else. * For example: *
    assertThat("  ", is(blankString()))
    + * + * @return The matcher. */ public static Matcher blankString() { return BLANK_INSTANCE; @@ -47,9 +49,11 @@ public static Matcher blankString() { * contains zero or more whitespace characters and nothing else. * For example: *
    assertThat(((String)null), is(blankOrNullString()))
    - * + * + * @return The matcher. */ public static Matcher blankOrNullString() { return NULL_OR_BLANK_INSTANCE; } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsEmptyString.java b/hamcrest/src/main/java/org/hamcrest/text/IsEmptyString.java similarity index 93% rename from hamcrest-library/src/main/java/org/hamcrest/text/IsEmptyString.java rename to hamcrest/src/main/java/org/hamcrest/text/IsEmptyString.java index bbe568145..1c1c3759b 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/text/IsEmptyString.java +++ b/hamcrest/src/main/java/org/hamcrest/text/IsEmptyString.java @@ -1,4 +1,3 @@ - package org.hamcrest.text; import org.hamcrest.Description; @@ -12,6 +11,7 @@ * Matches empty Strings (and null). */ public final class IsEmptyString extends TypeSafeMatcher { + private static final IsEmptyString INSTANCE = new IsEmptyString(); @SuppressWarnings("unchecked") private static final Matcher NULL_OR_EMPTY_INSTANCE = anyOf(nullValue(), INSTANCE); @@ -32,8 +32,9 @@ public void describeTo(Description description) { * Creates a matcher of {@link String} that matches when the examined string has zero length. * For example: *
    assertThat("", isEmptyString())
    - * + * * @deprecated use is(emptyString()) instead + * @return The matcher. */ @Deprecated public static Matcher isEmptyString() { @@ -44,7 +45,8 @@ public static Matcher isEmptyString() { * Creates a matcher of {@link String} that matches when the examined string has zero length. * For example: *
    assertThat("", is(emptyString()))
    - * + * + * @return The matcher. */ public static Matcher emptyString() { return INSTANCE; @@ -55,9 +57,9 @@ public static Matcher emptyString() { * has zero length. * For example: *
    assertThat(((String)null), isEmptyOrNullString())
    - * + * * @deprecated use is(emptyOrNullString()) instead - * + * @return The matcher. */ @Deprecated public static Matcher isEmptyOrNullString() { @@ -69,9 +71,11 @@ public static Matcher isEmptyOrNullString() { * has zero length. * For example: *
    assertThat(((String)null), is(emptyOrNullString()))
    - * + * + * @return The matcher. */ public static Matcher emptyOrNullString() { return NULL_OR_EMPTY_INSTANCE; } + } diff --git a/hamcrest/src/main/java/org/hamcrest/text/IsEqualCompressingWhiteSpace.java b/hamcrest/src/main/java/org/hamcrest/text/IsEqualCompressingWhiteSpace.java new file mode 100644 index 000000000..4a4c4c677 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/text/IsEqualCompressingWhiteSpace.java @@ -0,0 +1,91 @@ +package org.hamcrest.text; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; + +/** + * Tests if a string is equal to another string, compressing any changes in whitespace. + */ +public class IsEqualCompressingWhiteSpace extends TypeSafeMatcher { + + // TODO: Replace String with CharSequence to allow for easy interoperability between + // String, StringBuffer, StringBuilder, CharBuffer, etc (joe). + + private final String string; + + /** + * Constructor, best called from {@link #equalToCompressingWhiteSpace(String)}. + * @param string the expected string + */ + public IsEqualCompressingWhiteSpace(String string) { + if (string == null) { + throw new IllegalArgumentException("Non-null value required"); + } + this.string = string; + } + + /** + * Gets the string + * @return the string + */ + protected String getString() { + return string; + } + + @Override + public boolean matchesSafely(String item) { + return stripSpaces(string).equals(stripSpaces(item)); + } + + @Override + public void describeMismatchSafely(String item, Description mismatchDescription) { + mismatchDescription.appendText("was ").appendValue(item); + } + + @Override + public void describeTo(Description description) { + description.appendText("a string equal to ") + .appendValue(string) + .appendText(" compressing white space"); + } + + /** + * Strips spaces + * @param toBeStripped the string to be stripped + * @return the stripped string + */ + public String stripSpaces(String toBeStripped) { + return toBeStripped.replaceAll("[\\p{Z}\\p{C}]+", " ").trim(); + } + + /** + * @deprecated {@link #equalToCompressingWhiteSpace(String)} + * @param expectedString + * the expected value of matched strings + * @return The matcher. + */ + public static Matcher equalToIgnoringWhiteSpace(String expectedString) { + return new IsEqualCompressingWhiteSpace(expectedString); + } + + /** + * Creates a matcher of {@link String} that matches when the examined string is equal to + * the specified expectedString, when whitespace differences are (mostly) ignored. To be + * exact, the following whitespace rules are applied: + *
      + *
    • all leading and trailing whitespace of both the expectedString and the examined string are ignored
    • + *
    • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
    • + *
    + * For example: + *
    assertThat("   my\tfoo  bar ", equalToCompressingWhiteSpace(" my  foo bar"))
    + * + * @param expectedString + * the expected value of matched strings + * @return The matcher. + */ + public static Matcher equalToCompressingWhiteSpace(String expectedString) { + return new IsEqualCompressingWhiteSpace(expectedString); + } + +} diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java b/hamcrest/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java similarity index 84% rename from hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java rename to hamcrest/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java index 00586f60e..482265d8a 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java +++ b/hamcrest/src/main/java/org/hamcrest/text/IsEqualIgnoringCase.java @@ -14,9 +14,13 @@ public class IsEqualIgnoringCase extends TypeSafeMatcher { private final String string; + /** + * Constructor, best called from {@link #equalToIgnoringCase(String)}. + * @param string the expected string + */ public IsEqualIgnoringCase(String string) { if (string == null) { - throw new IllegalArgumentException("Non-null value required by IsEqualIgnoringCase()"); + throw new IllegalArgumentException("Non-null value required"); } this.string = string; } @@ -30,12 +34,12 @@ public boolean matchesSafely(String item) { public void describeMismatchSafely(String item, Description mismatchDescription) { mismatchDescription.appendText("was ").appendValue(item); } - + @Override public void describeTo(Description description) { - description.appendText("equalToIgnoringCase(") + description.appendText("a string equal to ") .appendValue(string) - .appendText(")"); + .appendText(" ignoring case"); } /** @@ -43,9 +47,10 @@ public void describeTo(Description description) { * the specified expectedString, ignoring case. * For example: *
    assertThat("Foo", equalToIgnoringCase("FOO"))
    - * + * * @param expectedString * the expected value of matched strings + * @return The matcher. */ public static Matcher equalToIgnoringCase(String expectedString) { return new IsEqualIgnoringCase(expectedString); diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/MatchesPattern.java b/hamcrest/src/main/java/org/hamcrest/text/MatchesPattern.java similarity index 75% rename from hamcrest-library/src/main/java/org/hamcrest/text/MatchesPattern.java rename to hamcrest/src/main/java/org/hamcrest/text/MatchesPattern.java index e0eda0a80..a211f96b4 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/text/MatchesPattern.java +++ b/hamcrest/src/main/java/org/hamcrest/text/MatchesPattern.java @@ -6,9 +6,18 @@ import java.util.regex.Pattern; +/** + * Tests if a string matches a regular expression. + */ public class MatchesPattern extends TypeSafeMatcher { + private final Pattern pattern; + /** + * Constructor, best called from {@link #matchesPattern(String)} or + * {@link #matchesPattern(Pattern)}. + * @param pattern the regular expression to match + */ public MatchesPattern(Pattern pattern) { this.pattern = pattern; } @@ -26,6 +35,10 @@ public void describeTo(Description description) { /** * Creates a matcher of {@link java.lang.String} that matches when the examined string * exactly matches the given {@link java.util.regex.Pattern}. + * + * @param pattern + * the text pattern to match. + * @return The matcher. */ public static Matcher matchesPattern(Pattern pattern) { return new MatchesPattern(pattern); @@ -34,8 +47,12 @@ public static Matcher matchesPattern(Pattern pattern) { /** * Creates a matcher of {@link java.lang.String} that matches when the examined string * exactly matches the given regular expression, treated as a {@link java.util.regex.Pattern}. + * + * @param regex the regex to match. + * @return The matcher. */ public static Matcher matchesPattern(String regex) { return new MatchesPattern(Pattern.compile(regex)); } + } diff --git a/hamcrest-library/src/main/java/org/hamcrest/text/StringContainsInOrder.java b/hamcrest/src/main/java/org/hamcrest/text/StringContainsInOrder.java similarity index 87% rename from hamcrest-library/src/main/java/org/hamcrest/text/StringContainsInOrder.java rename to hamcrest/src/main/java/org/hamcrest/text/StringContainsInOrder.java index f5d24ff60..8b70f2943 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/text/StringContainsInOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/text/StringContainsInOrder.java @@ -6,9 +6,17 @@ import java.util.Arrays; +/** + * Tests if a string contains the given substrings in order. + */ public class StringContainsInOrder extends TypeSafeMatcher { + private final Iterable substrings; + /** + * Constructor, best called from {@link #stringContainsInOrder(Iterable)} + * @param substrings the substrings that must be contained within matching strings + */ public StringContainsInOrder(Iterable substrings) { this.substrings = substrings; } @@ -16,38 +24,40 @@ public StringContainsInOrder(Iterable substrings) { @Override public boolean matchesSafely(String s) { int fromIndex = 0; - + for (String substring : substrings) { fromIndex = s.indexOf(substring, fromIndex); if (fromIndex == -1) { return false; } + fromIndex++; } - + return true; } - + @Override public void describeMismatchSafely(String item, Description mismatchDescription) { mismatchDescription.appendText("was \"").appendText(item).appendText("\""); } - + @Override public void describeTo(Description description) { description.appendText("a string containing ") .appendValueList("", ", ", "", substrings) .appendText(" in order"); } - + /** * Creates a matcher of {@link String} that matches when the examined string contains all of * the specified substrings, considering the order of their appearance. * For example: *
    assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
    * fails as "foo" occurs before "bar" in the string "myfoobarbaz" - * + * * @param substrings * the substrings that must be contained within matching strings + * @return The matcher. */ public static Matcher stringContainsInOrder(Iterable substrings) { return new StringContainsInOrder(substrings); @@ -62,8 +72,10 @@ public static Matcher stringContainsInOrder(Iterable substrings) * * @param substrings * the substrings that must be contained within matching strings + * @return The matcher. */ public static Matcher stringContainsInOrder(String... substrings) { return new StringContainsInOrder(Arrays.asList(substrings)); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/text/package-info.java b/hamcrest/src/main/java/org/hamcrest/text/package-info.java new file mode 100644 index 000000000..a9613e428 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/text/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers that perform text comparisons. + */ +package org.hamcrest.text; diff --git a/hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java b/hamcrest/src/main/java/org/hamcrest/xml/HasXPath.java similarity index 85% rename from hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java rename to hamcrest/src/main/java/org/hamcrest/xml/HasXPath.java index 30ed081a7..fcaa9a077 100644 --- a/hamcrest-library/src/main/java/org/hamcrest/xml/HasXPath.java +++ b/hamcrest/src/main/java/org/hamcrest/xml/HasXPath.java @@ -22,28 +22,33 @@ * @author Steve Freeman */ public class HasXPath extends TypeSafeDiagnosingMatcher { + + /** + * Null NamespaceContext, used to document deliberate use + * of no namespace. + */ public static final NamespaceContext NO_NAMESPACE_CONTEXT = null; - private static final IsAnything WITH_ANY_CONTENT = new IsAnything(""); - private static final Condition.Step NODE_EXISTS = nodeExists(); + private static final IsAnything WITH_ANY_CONTENT = new IsAnything<>(""); + private static final Condition.Step NODE_EXISTS = nodeExists(); private final Matcher valueMatcher; private final XPathExpression compiledXPath; private final String xpathString; private final QName evaluationMode; /** - * @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. + * Constructor, best called from one of the hasXPath static factory methods. + * @param xPathExpression the target xpath + * @param valueMatcher matcher for the expected value */ public HasXPath(String xPathExpression, Matcher valueMatcher) { this(xPathExpression, NO_NAMESPACE_CONTEXT, valueMatcher); } /** - * @param xPathExpression XPath expression. - * @param namespaceContext Resolves XML namespace prefixes in the 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. + * Constructor, best called from one of the hasXPath static factory methods. + * @param xPathExpression the target xpath + * @param namespaceContext the namespace for matching nodes + * @param valueMatcher matcher for the expected value */ public HasXPath(String xPathExpression, NamespaceContext namespaceContext, Matcher valueMatcher) { this(xPathExpression, namespaceContext, valueMatcher, STRING); @@ -105,17 +110,17 @@ private static XPathExpression compiledXPath(String xPathExpression, NamespaceCo } } - /** * Creates a matcher of {@link org.w3c.dom.Node}s that matches when the examined node has a value at the * specified xPath that satisfies the specified valueMatcher. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
    - * + * * @param xPath * the target xpath * @param valueMatcher * matcher for the value at the specified xpath + * @return The matcher. */ public static Matcher hasXPath(String xPath, Matcher valueMatcher) { return hasXPath(xPath, NO_NAMESPACE_CONTEXT, valueMatcher); @@ -127,13 +132,14 @@ public static Matcher hasXPath(String xPath, Matcher valueMatcher) * the specified valueMatcher. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
    - * + * * @param xPath * the target xpath * @param namespaceContext * the namespace for matching nodes * @param valueMatcher * matcher for the value at the specified xpath + * @return The matcher. */ public static Matcher hasXPath(String xPath, NamespaceContext namespaceContext, Matcher valueMatcher) { return new HasXPath(xPath, namespaceContext, valueMatcher, STRING); @@ -144,9 +150,9 @@ public static Matcher hasXPath(String xPath, NamespaceContext namespaceCon * at the specified xPath, with any content. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese"))
    - * - * @param xPath - * the target xpath + * + * @param xPath the target xpath + * @return The matcher. */ public static Matcher hasXPath(String xPath) { return hasXPath(xPath, NO_NAMESPACE_CONTEXT); @@ -157,13 +163,13 @@ public static Matcher hasXPath(String xPath) { * at the specified xPath within the specified namespace context, with any content. * For example: *
    assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
    - * - * @param xPath - * the target xpath - * @param namespaceContext - * the namespace for matching nodes + * + * @param xPath the target xpath + * @param namespaceContext the namespace for matching nodes + * @return The matcher. */ public static Matcher hasXPath(String xPath, NamespaceContext namespaceContext) { return new HasXPath(xPath, namespaceContext, WITH_ANY_CONTENT, XPathConstants.NODE); } + } diff --git a/hamcrest/src/main/java/org/hamcrest/xml/package-info.java b/hamcrest/src/main/java/org/hamcrest/xml/package-info.java new file mode 100644 index 000000000..2c974c658 --- /dev/null +++ b/hamcrest/src/main/java/org/hamcrest/xml/package-info.java @@ -0,0 +1,4 @@ +/** + * Matchers of XML documents. + */ +package org.hamcrest.xml; diff --git a/hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java b/hamcrest/src/test/java/org/hamcrest/BaseDescriptionTest.java similarity index 61% rename from hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java rename to hamcrest/src/test/java/org/hamcrest/BaseDescriptionTest.java index 8b707254e..05ae52523 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/BaseDescriptionTest.java +++ b/hamcrest/src/test/java/org/hamcrest/BaseDescriptionTest.java @@ -1,8 +1,8 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public final class BaseDescriptionTest { @@ -14,65 +14,102 @@ public final class BaseDescriptionTest { } }; - @Test public void + @Test public void describesAppendedNullValue() { baseDescription.appendValue(null); assertEquals("null", result.toString()); } - @Test public void + @Test public void quotesAppendedStringValue() { baseDescription.appendValue("foo"); assertEquals("\"foo\"", result.toString()); } - @Test public void + @Test public void quotesAppendedCharacterValue() { baseDescription.appendValue('f'); assertEquals("\"f\"", result.toString()); } - @Test public void + @Test public void + quotesAppendedTab() { + baseDescription.appendValue('\t'); + assertEquals("\"\\t\"", result.toString()); + } + + @Test public void + quotesAppendedNewLine() { + baseDescription.appendValue('\n'); + assertEquals("\"\\n\"", result.toString()); + } + + @Test public void + quotesAppendedLineReturn() { + baseDescription.appendValue('\r'); + assertEquals("\"\\r\"", result.toString()); + } + + @Test public void + quotesAppendedBackslash() { + baseDescription.appendValue('\\'); + assertEquals("\"\\\\\"", result.toString()); + } + + @Test public void + quotesAppendedDoubleQuotes() { + baseDescription.appendValue('"'); + assertEquals("\"\\\"\"", result.toString()); + } + + @Test public void + bracketsAppendedByteValue() { + baseDescription.appendValue(Byte.valueOf("2")); + assertEquals("<2b>", result.toString()); + } + + @Test public void bracketsAppendedShortValue() { baseDescription.appendValue(Short.valueOf("2")); assertEquals("<2s>", result.toString()); } - @Test public void + @Test public void bracketsAppendedLongValue() { baseDescription.appendValue(Long.valueOf("2")); assertEquals("<2L>", result.toString()); } - @Test public void + @Test public void bracketsAppendedFloatValue() { baseDescription.appendValue(Float.valueOf("1.2")); assertEquals("<1.2F>", result.toString()); } - @Test public void + @Test public void describesAppendedArrayValue() { baseDescription.appendValue(new String[] {"2", "3"}); assertEquals("[\"2\", \"3\"]", result.toString()); } - @Test public void + @Test public void bracketsAppendedObjectValue() { final Object value = new Object(); baseDescription.appendValue(value); assertEquals("<" + value.toString() + ">", result.toString()); } - - @Test public void + + @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/src/test/java/org/hamcrest/BaseMatcherTest.java similarity index 85% rename from hamcrest-core/src/test/java/org/hamcrest/BaseMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/BaseMatcherTest.java index e663f0413..c7d73cb62 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/BaseMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/BaseMatcherTest.java @@ -1,8 +1,8 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public final class BaseMatcherTest { @@ -23,4 +23,5 @@ public void describeTo(Description description) { assertEquals("SOME DESCRIPTION", someMatcher.toString()); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/CustomMatcherTest.java similarity index 80% rename from hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/CustomMatcherTest.java index 08649f7a3..736a58c37 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/CustomMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/CustomMatcherTest.java @@ -1,8 +1,9 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.assertDescription; -import static org.hamcrest.AbstractMatcherTest.assertDescription; public final class CustomMatcherTest { @@ -17,4 +18,5 @@ public boolean matches(Object item) { assertDescription("I match strings", matcher); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java similarity index 91% rename from hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java index 2c867126c..5820fd88f 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/CustomTypeSafeMatcherTest.java @@ -1,10 +1,11 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; public final class CustomTypeSafeMatcherTest { + private static final String STATIC_DESCRIPTION = "I match non empty strings"; private final Matcher customMatcher = new CustomTypeSafeMatcher(STATIC_DESCRIPTION) { @@ -33,9 +34,10 @@ public void describeMismatchSafely(String item, Description mismatchDescription) isNullSafe() { assertNullSafe(customMatcher); } - + @Test public void copesWithUnknownTypes() { assertUnknownTypeSafe(customMatcher); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/FeatureMatcherTest.java similarity index 88% rename from hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/FeatureMatcherTest.java index f0cbdd5b7..82e89aa25 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/FeatureMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/FeatureMatcherTest.java @@ -1,12 +1,13 @@ package org.hamcrest; import org.hamcrest.core.IsEqual; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; -import static org.junit.Assert.assertEquals; +import static org.hamcrest.test.MatcherAssertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; public final class FeatureMatcherTest { + private final FeatureMatcher resultMatcher = resultMatcher(); @Test public void @@ -28,9 +29,9 @@ public final class FeatureMatcherTest { @Test public void doesNotThrowClassCastException() { resultMatcher.matches(new ShouldNotMatch()); - StringDescription mismatchDescription = new StringDescription(); + StringDescription mismatchDescription = new StringDescription(); resultMatcher.describeMismatch(new ShouldNotMatch(), mismatchDescription); - assertEquals("was ", mismatchDescription.toString()); + assertEquals("was ShouldNotMatch ", mismatchDescription.toString()); } public static class Match extends IsEqual { @@ -54,7 +55,7 @@ public String getResult() { public static class ShouldNotMatch { @Override public String toString() { return "ShouldNotMatch"; } - } + } private static FeatureMatcher resultMatcher() { return new FeatureMatcher(new Match("bar"), "Thingy with result", "result") { diff --git a/hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java b/hamcrest/src/test/java/org/hamcrest/MatcherAssertTest.java similarity index 80% rename from hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java rename to hamcrest/src/test/java/org/hamcrest/MatcherAssertTest.java index b57c4d77b..93da7636f 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/MatcherAssertTest.java +++ b/hamcrest/src/test/java/org/hamcrest/MatcherAssertTest.java @@ -1,10 +1,10 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.IsEqual.equalTo; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; public final class MatcherAssertTest { @@ -12,8 +12,9 @@ public final class MatcherAssertTest { includesDescriptionOfTestedValueInErrorMessage() { String expected = "expected"; String actual = "actual"; + String endLine = System.lineSeparator(); - String expectedMessage = "identifier\nExpected: \"expected\"\n but: was \"actual\""; + String expectedMessage = "identifier" + endLine + "Expected: \"expected\"" + endLine + " but: was \"actual\""; try { assertThat("identifier", actual, equalTo(expected)); @@ -30,8 +31,9 @@ public final class MatcherAssertTest { descriptionCanBeElided() { String expected = "expected"; String actual = "actual"; + String endLine = System.lineSeparator(); - String expectedMessage = "\nExpected: \"expected\"\n but: was \"actual\""; + String expectedMessage = endLine + "Expected: \"expected\"" + endLine + " but: was \"actual\""; try { assertThat(actual, equalTo(expected)); @@ -78,7 +80,8 @@ public void describeMismatch(Object item, Description mismatchDescription) { } }; - String expectedMessage = "\nExpected: Something cool\n but: Not cool"; + String endLine = System.lineSeparator(); + String expectedMessage = endLine + "Expected: Something cool" + endLine + " but: Not cool"; try { assertThat("Value", matcherWithCustomMismatchDescription); @@ -93,4 +96,5 @@ public void describeMismatch(Object item, Description mismatchDescription) { canAssertSubtypes() { assertThat(1, equalTo((Number) 1)); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java b/hamcrest/src/test/java/org/hamcrest/NullDescriptionTest.java similarity index 79% rename from hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java rename to hamcrest/src/test/java/org/hamcrest/NullDescriptionTest.java index cccece0a6..dc5ac4ab4 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/NullDescriptionTest.java +++ b/hamcrest/src/test/java/org/hamcrest/NullDescriptionTest.java @@ -1,9 +1,9 @@ package org.hamcrest; import org.hamcrest.Description.NullDescription; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public final class NullDescriptionTest { diff --git a/hamcrest/src/test/java/org/hamcrest/TypeSafeDiagnosingMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/TypeSafeDiagnosingMatcherTest.java new file mode 100644 index 000000000..610620745 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/TypeSafeDiagnosingMatcherTest.java @@ -0,0 +1,81 @@ +package org.hamcrest; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; + +/** + * @author Steve Freeman 2016 http://www.hamcrest.com + */ +@SuppressWarnings("WeakerAccess") +public class TypeSafeDiagnosingMatcherTest { + + @Test public void + describesMismatches() { + assertMismatchDescription("was null", STRING_MATCHER, null); + assertMismatchDescription("was Character \"c\"", STRING_MATCHER, 'c'); + assertMismatchDescription("mismatching", STRING_MATCHER, "other"); + } + + @Test public void + detects_non_builtin_types() { + final Matcher matcher = new TypeSafeDiagnosingMatcher() { + @Override + protected boolean matchesSafely(NotBuiltIn item, Description mismatchDescription) { + return true; + } + + @Override public void describeTo(Description description) { description.appendText("a not builtin"); } + }; + + assertMatches("not built in", matcher, new NotBuiltIn()); + assertDoesNotMatch("other not built in", (Matcher)matcher, new OtherNotBuiltIn()); + } + + @Test public void + filters_type_for_subclassed_matcher_when_expected_type_passed_in() { + final Matcher matcher = new SubMatcher<>(new NotBuiltIn()); + + assertMatches("not built in", matcher, new NotBuiltIn()); + assertDoesNotMatch("other not built in", (Matcher)matcher, new OtherNotBuiltIn()); + } + + @Test public void + but_cannot_detect_generic_type_in_subclassed_matcher_using_reflection() { + final Matcher matcher = new SubMatcher<>(); + + assertMatches("not built in", matcher, new NotBuiltIn()); + assertMatches("other not built in", (Matcher)matcher, new OtherNotBuiltIn()); + } + + private static final TypeSafeDiagnosingMatcher STRING_MATCHER = new TypeSafeDiagnosingMatcher() { + @Override + protected boolean matchesSafely(String item, Description mismatchDescription) { + mismatchDescription.appendText("mismatching"); + return false; + } + + @Override + public void describeTo(Description description) { } + }; + + public static class SubMatcher extends TypeSafeDiagnosingMatcher { + public SubMatcher() { + super(); + } + public SubMatcher(T expectedObject) { + super(expectedObject.getClass()); + } + @Override protected boolean matchesSafely(T item, Description mismatchDescription) { return true; } + @Override public void describeTo(Description description) { description.appendText("sub type"); } + } + + public static class NotBuiltIn { + public final String value = "not built in"; + @Override public String toString() { return "NotBuiltIn"; } + } + + public static class OtherNotBuiltIn { // empty + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/TypeSafeMatcherTest.java similarity index 84% rename from hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/TypeSafeMatcherTest.java index e23bab8fa..6fa6caef9 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/TypeSafeMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/TypeSafeMatcherTest.java @@ -1,11 +1,13 @@ package org.hamcrest; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.assertMismatchDescription; -import static org.junit.Assert.assertFalse; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; +import static org.junit.jupiter.api.Assertions.assertFalse; +@SuppressWarnings("WeakerAccess") public final class TypeSafeMatcherTest { + private final Matcher matcher = new TypeSafeMatcherSubclass(); public static class TypeSafeMatcherSubclass extends TypeSafeMatcher { @@ -37,4 +39,5 @@ public void describeTo(Description description) { assertMismatchDescription("was a java.lang.Integer (<3>)", (Matcher)matcher, 3); assertMismatchDescription("The mismatch", matcher, "a string"); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyTest.java b/hamcrest/src/test/java/org/hamcrest/beans/HasPropertyTest.java similarity index 63% rename from hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyTest.java rename to hamcrest/src/test/java/org/hamcrest/beans/HasPropertyTest.java index 314797f47..9a5b06d41 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/beans/HasPropertyTest.java +++ b/hamcrest/src/test/java/org/hamcrest/beans/HasPropertyTest.java @@ -1,9 +1,9 @@ package org.hamcrest.beans; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.beans.HasProperty.hasProperty; /** @@ -15,12 +15,13 @@ */ public final class HasPropertyTest { - private final HasPropertyWithValueTest.BeanWithoutInfo bean = new HasPropertyWithValueTest.BeanWithoutInfo("a bean"); + private final HasPropertyWithValueTest.BeanWithoutInfo bean = new HasPropertyWithValueTest.BeanWithoutInfo("a bean", false); + private final HasPropertyWithValueTest.RecordLikeBeanWithoutInfo record = new HasPropertyWithValueTest.RecordLikeBeanWithoutInfo("a record", false); @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = hasProperty("irrelevant"); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -28,11 +29,14 @@ public final class HasPropertyTest { @Test public void matchesWhenThePropertyExists() { assertMatches(hasProperty("writeOnlyProperty"), bean); + assertMatches(hasProperty("property"), record); } @Test public void doesNotMatchIfPropertyDoesNotExist() { assertDoesNotMatch(hasProperty("aNonExistentProp"), bean); + assertDoesNotMatch(hasProperty("aNonExistentProp"), record); + assertDoesNotMatch(hasProperty("notAGetterMethod"), record); } @Test public void @@ -44,5 +48,8 @@ public final class HasPropertyTest { describesAMismatch() { assertMismatchDescription("no \"aNonExistentProp\" in <[Person: a bean]>", hasProperty("aNonExistentProp"), bean); + assertMismatchDescription("no \"aNonExistentProp\" in <[Person: a record]>", + hasProperty("aNonExistentProp"), record); } + } diff --git a/hamcrest/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java b/hamcrest/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java new file mode 100644 index 000000000..a7dcc00d0 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/beans/HasPropertyWithValueTest.java @@ -0,0 +1,281 @@ +package org.hamcrest.beans; + +import org.hamcrest.*; +import org.hamcrest.core.IsEqual; +import org.hamcrest.test.AbstractMatcherTest; +import org.junit.jupiter.api.Test; + +import java.beans.IntrospectionException; +import java.beans.PropertyDescriptor; +import java.beans.SimpleBeanInfo; +import java.util.Objects; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.beans.HasPropertyWithValue.hasProperty; +import static org.hamcrest.beans.HasPropertyWithValue.hasPropertyAtPath; +import static org.hamcrest.core.IsAnything.anything; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * @author Iain McGinniss + * @author Nat Pryce + * @author Steve Freeman + * @since 1.1.0 + */ +@SuppressWarnings("UnusedDeclaration") +public class HasPropertyWithValueTest extends AbstractMatcherTest { + + private final BeanWithoutInfo shouldMatch = new BeanWithoutInfo("is expected", true); + private final BeanWithoutInfo shouldNotMatch = new BeanWithoutInfo("not expected", false); + + private final RecordLikeBeanWithoutInfo recordShouldMatch = new RecordLikeBeanWithoutInfo("is expected", true); + private final RecordLikeBeanWithoutInfo recordShouldNotMatch = new RecordLikeBeanWithoutInfo("not expected", false); + + private final BeanWithInfo beanWithInfo = new BeanWithInfo("with info"); + + @Override + protected Matcher createMatcher() { + return hasProperty("irrelevant", anything()); + } + + @Test + public void testMatchesBeanWithoutInfoWithMatchedNamedProperty() { + final Matcher propertyMatcher = hasProperty("property", equalTo("is expected")); + + assertMatches("with property", propertyMatcher, shouldMatch); + assertMismatchDescription("property 'property' was \"not expected\"", propertyMatcher, shouldNotMatch); + } + + @Test + public void testMatchesRecordLikeBeanWithoutInfoWithMatchedNamedProperty() { + final Matcher propertyMatcher = hasProperty("property", equalTo("is expected")); + + assertMatches("with property", propertyMatcher, recordShouldMatch); + assertMismatchDescription("property 'property' was \"not expected\"", propertyMatcher, recordShouldNotMatch); + } + + @Test + public void testMatchesBeanWithoutInfoWithMatchedNamedBooleanProperty() { + final Matcher booleanPropertyMatcher = hasProperty("booleanProperty", is(true)); + + assertMatches("with property", booleanPropertyMatcher, shouldMatch); + assertMismatchDescription("property 'booleanProperty' was ", booleanPropertyMatcher, shouldNotMatch); + } + + @Test + public void testMatchesRecordLikeBeanWithoutInfoWithMatchedNamedBooleanProperty() { + final Matcher booleanPropertyMatcher = hasProperty("booleanProperty", is(true)); + + assertMatches("with property", booleanPropertyMatcher, recordShouldMatch); + assertMismatchDescription("property 'booleanProperty' was ", booleanPropertyMatcher, recordShouldNotMatch); + } + + @Test + public void testMatchesBeanWithInfoWithMatchedNamedProperty() { + assertMatches("with bean info", hasProperty("property", equalTo("with info")), beanWithInfo); + assertMismatchDescription("property 'property' was \"with info\"", + hasProperty("property", equalTo("without info")), beanWithInfo); + } + + @Test + public void testDoesNotMatchBeanWithoutInfoOrMatchedNamedProperty() { + assertMismatchDescription("No property \"nonExistentProperty\"", + hasProperty("nonExistentProperty", anything()), shouldNotMatch); + } + + @Test + public void testDoesNotMatchRecordLikeBeanWithoutInfoOrMatchedNamedProperty() { + assertMismatchDescription("No property \"nonExistentProperty\"", + hasProperty("nonExistentProperty", anything()), recordShouldNotMatch); + } + + @Test + public void testDoesNotMatchWriteOnlyProperty() { + assertMismatchDescription("property \"writeOnlyProperty\" is not readable", + hasProperty("writeOnlyProperty", anything()), shouldNotMatch); + } + + @Test + public void testMatchesPath() { + assertMatches("1-step path", hasPropertyAtPath("property", equalTo("is expected")), shouldMatch); + assertMatches("2-step path", hasPropertyAtPath("inner.property", equalTo("is expected")), new BeanWithInner(shouldMatch)); + assertMatches("3-step path", hasPropertyAtPath("inner.inner.property", equalTo("is expected")), new BeanWithInner(new BeanWithInner(shouldMatch))); + + assertMismatchDescription("inner.No property \"wrong\"", hasPropertyAtPath("inner.wrong.property", anything()), new BeanWithInner(new BeanWithInner(shouldMatch))); + assertMismatchDescription("inner.inner.property.was \"not expected\"", hasPropertyAtPath("inner.inner.property", equalTo("something")), new BeanWithInner(new BeanWithInner(shouldNotMatch))); + } + + @Test + public void testMatchesPathForJavaRecords() { + assertMatches("1-step path", hasPropertyAtPath("property", equalTo("is expected")), recordShouldMatch); + assertMatches("2-step path", hasPropertyAtPath("inner.property", equalTo("is expected")), new BeanWithInner(recordShouldMatch)); + assertMatches("3-step path", hasPropertyAtPath("inner.inner.property", equalTo("is expected")), new BeanWithInner(new BeanWithInner(recordShouldMatch))); + + assertMismatchDescription("inner.No property \"wrong\"", hasPropertyAtPath("inner.wrong.property", anything()), new BeanWithInner(new BeanWithInner(recordShouldMatch))); + assertMismatchDescription("inner.inner.property.was \"not expected\"", hasPropertyAtPath("inner.inner.property", equalTo("something")), new BeanWithInner(new BeanWithInner(recordShouldNotMatch))); + } + + @Test + public void testDescribeTo() { + assertDescription("hasProperty(\"property\", )", hasProperty("property", equalTo(true))); + } + + @Test + public void testMatchesPropertyAndValue() { + assertMatches("property with value", hasProperty("property", anything()), beanWithInfo); + } + + @Test + public void testMatchesPropertyAndValueWithJavaRecords() { + assertMatches("property with value", hasProperty("property", anything()), recordShouldMatch); + } + + @Test + public void testDoesNotWriteMismatchIfPropertyMatches() { + Description description = new StringDescription(); + hasProperty( "property", anything()).describeMismatch(beanWithInfo, description); + assertEquals("", description.toString(), "Expected mismatch description"); + } + + @Test + public void testDescribesMissingPropertyMismatch() { + assertMismatchDescription("No property \"honk\"", hasProperty("honk", anything()), shouldNotMatch); + } + + @Test + public void testExceptionsInBeanMethodsShouldBeReportedCorrectly() { + assertMismatchDescription( + "Calling 'public java.lang.String org.hamcrest.beans.HasPropertyWithValueTest$BeanWithBug.getBroken()': \"bean failed\"", + hasProperty("broken", anything()), + new BeanWithBug()); + } + + @Test + public void testCanAccessAnAnonymousInnerClass() { + class X implements IX { + @Override + public int getTest() { + return 1; + } + } + + assertThat(new X(), HasPropertyWithValue.hasProperty("test", IsEqual.equalTo(1))); + } + + interface IX { + int getTest(); + } + + @SuppressWarnings("WeakerAccess") + public static class BeanWithoutInfo { + private String property; + private final boolean booleanProperty; + + public BeanWithoutInfo(String property, boolean booleanProperty) { + this.property = property; + this.booleanProperty = booleanProperty; + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public boolean isBooleanProperty() { return booleanProperty; } + + public void setWriteOnlyProperty(@SuppressWarnings("unused") float property) { + } + + @Override + public String toString() { + return "[Person: " + property + "]"; + } + } + + /** + * A Java Record-like class to test the functionality of + * {@link HasProperty}, {@link HasPropertyWithValue} + * with Java Records in JDK 8 environment. + * + * @see https://docs.oracle.com/en/java/javase/17/language/records.html + */ + public static final class RecordLikeBeanWithoutInfo { + private final String property; + private final boolean booleanProperty; + + public RecordLikeBeanWithoutInfo(String property, boolean booleanProperty) { + this.property = property; + this.booleanProperty = booleanProperty; + } + + public String property() { return this.property; } + public boolean booleanProperty() { return this.booleanProperty; } + public void notAGetterMethod() {} + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof RecordLikeBeanWithoutInfo)) return false; + RecordLikeBeanWithoutInfo that = (RecordLikeBeanWithoutInfo) o; + return Objects.equals(this.property, that.property) && this.booleanProperty == that.booleanProperty; + } + + @Override + public int hashCode() { + return Objects.hash(property, booleanProperty); + } + + @Override + public String toString() { + return "[Person: " + property + "]"; + } + } + + @SuppressWarnings("WeakerAccess") + public static class BeanWithInner { + private final Object inner; + + public BeanWithInner(Object inner) { this.inner = inner; } + public Object getInner() { return inner; } + } + + @SuppressWarnings("WeakerAccess") + public static class BeanWithInfo { + private final String propertyValue; + + public BeanWithInfo(String propertyValue) { this.propertyValue = propertyValue; } + public String property() { return propertyValue; } + } + + public static class BeanWithInfoBeanInfo extends SimpleBeanInfo { // TODO: No usage. Can be removed. + @Override + public PropertyDescriptor[] getPropertyDescriptors() { + try { + return new PropertyDescriptor[] { + new PropertyDescriptor("property", BeanWithInfo.class, "property", null) + }; + } catch (IntrospectionException e) { + throw new AssertionError("Introspection exception", e); + } + } + } + + @SuppressWarnings("WeakerAccess") + public static class BeanWithBug { + public String getBroken() { + throw new BeanFailed(); + } + } + + @SuppressWarnings("WeakerAccess") + public static class BeanFailed extends RuntimeException { + public BeanFailed() { super("bean failed"); } + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/beans/PropertyUtilTest.java b/hamcrest/src/test/java/org/hamcrest/beans/PropertyUtilTest.java new file mode 100644 index 000000000..bc9ba6a0c --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/beans/PropertyUtilTest.java @@ -0,0 +1,150 @@ +package org.hamcrest.beans; + +import org.junit.jupiter.api.Test; + +import java.beans.MethodDescriptor; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.*; +import java.util.stream.Collectors; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +class PropertyUtilTest { + + @Test + void testReturnsTheNamesOfAllFieldsFromTargetClass() { + SamePropertyValuesAsTest.ExampleBean input = new SamePropertyValuesAsTest.ExampleBean("test", 1, null); + + Set output = PropertyUtil.getFieldNames(input); + + assertThat(output, hasSize(3)); + assertThat(output, hasItems("stringProperty", "intProperty", "valueProperty")); + assertThat(output, not(hasItem("nonexistentField"))); + } + + @Test + void testReturnsTheNamesOfAllFieldsFromTargetRecord() { + RecordLikeClass.SmallClass smallClass1 = new RecordLikeClass.SmallClass(); + RecordLikeClass.SmallClass smallClass2 = new RecordLikeClass.SmallClass("small", 3, BigDecimal.ONE, LocalDateTime.of(2024, 1, 2, 3, 4, 5)); + RecordLikeClass input = new RecordLikeClass("uno", 22, true, new Long[] {1L, 2L, 3L}, new ArrayList<>(Arrays.asList(smallClass1, smallClass2))); + + Set output = PropertyUtil.getFieldNames(input); + + assertThat(output, hasSize(5)); + assertThat(output, hasItems("numberArray", "test", "smallClasses", "name", "age")); + assertThat(output, not(hasItem("notAGetter1"))); + assertThat(output, not(hasItem("notAGetter2"))); + assertThat(output, not(hasItem("getAge"))); + assertThat(output, not(hasItem("field1"))); + assertThat(output, not(hasItem("nonexistentField"))); + } + + @Test + void testReturnsArrayOfMethodDescriptorFromTargetClass() { + SamePropertyValuesAsTest.ExampleBean input = new SamePropertyValuesAsTest.ExampleBean("test", 1, null); + + MethodDescriptor[] output = PropertyUtil.recordReadAccessorMethodDescriptorsFor(input, Object.class); + + assertThat(output, arrayWithSize(0)); + } + + @Test + void testReturnsArrayOfMethodDescriptorFromTargetRecord() { + RecordLikeClass.SmallClass smallClass1 = new RecordLikeClass.SmallClass(); + RecordLikeClass.SmallClass smallClass2 = new RecordLikeClass.SmallClass("small", 3, BigDecimal.ONE, LocalDateTime.of(2024, 1, 2, 3, 4, 5)); + RecordLikeClass input = new RecordLikeClass("uno", 22, true, new Long[] {1L, 2L, 3L}, new ArrayList<>(Arrays.asList(smallClass1, smallClass2))); + + MethodDescriptor[] output = PropertyUtil.recordReadAccessorMethodDescriptorsFor(input, Object.class); + + assertThat(output, arrayWithSize(5)); + assertThat(Arrays.stream(output).map(MethodDescriptor::getDisplayName).collect(Collectors.toList()), + hasItems("numberArray", "test", "smallClasses", "name", "age")); + } + + + /** + * A Java Record-like class to test the functionality of + * {@link PropertyUtil} with Java Records in JDK 8 environment. + * + * @see https://docs.oracle.com/en/java/javase/17/language/records.html + */ + @SuppressWarnings("unused") + static final class RecordLikeClass { + private final String name; + private final int age; + private final boolean test; + private final Long[] numberArray; + private final List smallClasses; + + public RecordLikeClass(String name, int age, boolean test, Long[] numberArray, List smallClasses) { + this.name = name; + this.age = age; + this.test = test; + this.numberArray = numberArray; + this.smallClasses = smallClasses; + } + + public String name() { return name; } + public int age() { return age; } + public boolean test() { return test; } + public Long[] numberArray() { return numberArray; } + public List smallClasses() { return smallClasses; } + + public void notAGetter1() {} + public String notAGetter2() { return "I'm nothing"; } + public String name(String fake1, String fake2) { return name; } + public void name(String fake1) {} + public int getAge() { return 0; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof RecordLikeClass)) return false; + RecordLikeClass that = (RecordLikeClass) o; + return this.age() == that.age() && + this.test() == that.test() && + Objects.equals(this.name(), that.name()) && + Objects.deepEquals(this.numberArray(), that.numberArray())&& + Objects.equals(this.smallClasses(), that.smallClasses()); + } + + @Override + public int hashCode() { + return Objects.hash(name(), age(), test(), Arrays.hashCode(numberArray()), smallClasses()); + } + + @Override + public String toString() { + return "RecordLikeClass{" + + "name='" + name + '\'' + + ", age=" + age + + ", test=" + test + + ", numberArray=" + Arrays.toString(numberArray) + + ", smallClasses=" + smallClasses + + '}'; + } + + static class SmallClass { + private String field1; + private Integer field2; + private BigDecimal field3; + private LocalDateTime field4; + + public SmallClass() {} + + public SmallClass(String field1, Integer field2, BigDecimal field3, LocalDateTime field4) { + this.field1 = field1; + this.field2 = field2; + this.field3 = field3; + this.field4 = field4; + } + + @Override + public String toString() { + return "SmallClass{field1='" + field1 + "', field2=" + field2 + ", field3=" + field3 + ", field4=" + field4 + '}'; + } + } + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java b/hamcrest/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java new file mode 100644 index 000000000..bd5f17963 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/beans/SamePropertyValuesAsTest.java @@ -0,0 +1,211 @@ +package org.hamcrest.beans; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import java.util.Objects; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs; + +@SuppressWarnings("WeakerAccess") +public class SamePropertyValuesAsTest extends AbstractMatcherTest { + + private static final Value aValue = new Value("expected"); + private static final ExampleBean expectedBean = new ExampleBean("same", 1, aValue); + private static final ExampleBean actualBean = new ExampleBean("same", 1, aValue); + private static final ExampleRecord expectedRecord = new ExampleRecord("same", 1, aValue); + private static final ExampleRecord actualRecord = new ExampleRecord("same", 1, aValue); + + + @Override + protected Matcher createMatcher() { + return samePropertyValuesAs(expectedBean); + } + + @Test + public void test_reports_match_when_all_properties_match() { + assertMatches("matched properties", samePropertyValuesAs(expectedBean), actualBean); + assertMatches("matched properties", samePropertyValuesAs(expectedRecord), actualRecord); + } + + @Test + public void test_reports_mismatch_when_actual_type_is_not_assignable_to_expected_type() { + assertMismatchDescription("is incompatible type: ExampleBean", + samePropertyValuesAs((Object)aValue), actualBean); + assertMismatchDescription("is incompatible type: ExampleRecord", + samePropertyValuesAs((Object)aValue), actualRecord); + } + + @Test + public void test_reports_mismatch_on_first_property_difference() { + assertMismatchDescription("stringProperty was \"different\"", + samePropertyValuesAs(expectedBean), new ExampleBean("different", 1, aValue)); + assertMismatchDescription("intProperty was <2>", + samePropertyValuesAs(expectedBean), new ExampleBean("same", 2, aValue)); + assertMismatchDescription("valueProperty was ", + samePropertyValuesAs(expectedBean), new ExampleBean("same", 1, new Value("other"))); + + assertMismatchDescription("stringProperty was \"different\"", + samePropertyValuesAs(expectedRecord), new ExampleRecord("different", 1, aValue)); + assertMismatchDescription("intProperty was <2>", + samePropertyValuesAs(expectedRecord), new ExampleRecord("same", 2, aValue)); + assertMismatchDescription("valueProperty was ", + samePropertyValuesAs(expectedRecord), new ExampleRecord("same", 1, new Value("other"))); + } + + @Test + public void test_matches_beans_with_inheritance_but_no_extra_properties() { + assertMatches("sub type with same properties", + samePropertyValuesAs(expectedBean), new SubBeanWithNoExtraProperties("same", 1, aValue)); + } + + @Test + public void test_rejects_subtype_that_has_extra_properties() { + assertMismatchDescription("has extra properties called [extraProperty]", + samePropertyValuesAs(expectedBean), new SubBeanWithExtraProperty("same", 1, aValue)); + } + + @Test + public void test_ignores_extra_subtype_properties() { + final SubBeanWithExtraProperty withExtraProperty = new SubBeanWithExtraProperty("same", 1, aValue); + assertMatches("extra property", samePropertyValuesAs(expectedBean, "extraProperty"), withExtraProperty); + } + + @Test + public void test_ignores_different_properties() { + final ExampleBean differentBean = new ExampleBean("different", 1, aValue); + final ExampleRecord differentRecord = new ExampleRecord("different", 1, aValue); + assertMatches("different property", samePropertyValuesAs(expectedBean, "stringProperty"), differentBean); + assertMatches("different property", samePropertyValuesAs(expectedRecord, "stringProperty"), differentRecord); + } + + @Test + public void test_accepts_missing_properties_to_ignore() { + assertMatches("ignored property", samePropertyValuesAs(expectedBean, "notAProperty"), actualBean); + assertMatches("ignored property", samePropertyValuesAs(expectedRecord, "notAProperty"), actualRecord); + } + + @Test + public void test_can_ignore_all_properties() { + final ExampleBean differentBean = new ExampleBean("different", 2, new Value("not expected")); + final ExampleRecord differentRecord = new ExampleRecord("different", 2, new Value("not expected")); + assertMatches( + "different property", + samePropertyValuesAs(expectedBean, "stringProperty", "intProperty", "valueProperty"), + differentBean); + assertMatches( + "different property", + samePropertyValuesAs(expectedRecord, "stringProperty", "intProperty", "valueProperty"), + differentRecord); + } + + @Test + public void testDescribesItself() { + assertDescription( + "same property values as ExampleBean [intProperty: <1>, stringProperty: \"same\", valueProperty: ]", + samePropertyValuesAs(expectedBean)); + assertDescription( + "same property values as ExampleRecord [valueProperty: , stringProperty: \"same\", intProperty: <1>]", + samePropertyValuesAs(expectedRecord)); + + assertDescription( + "same property values as ExampleBean [intProperty: <1>, stringProperty: \"same\", valueProperty: ] ignoring [\"ignored1\", \"ignored2\"]", + samePropertyValuesAs(expectedBean, "ignored1", "ignored2")); + assertDescription( + "same property values as ExampleRecord [valueProperty: , stringProperty: \"same\", intProperty: <1>] ignoring [\"ignored1\", \"ignored2\"]", + samePropertyValuesAs(expectedRecord, "ignored1", "ignored2")); + } + + public static class Value { + public Value(Object value) { + this.value = value; + } + + public final Object value; + @Override + public String toString() { + return "Value " + value; + } + } + + @SuppressWarnings("unused") + public static class ExampleBean { + private String stringProperty; + private int intProperty; + private Value valueProperty; + + public ExampleBean(String stringProperty, int intProperty, Value valueProperty) { + this.stringProperty = stringProperty; + this.intProperty = intProperty; + this.valueProperty = valueProperty; + } + + public String getStringProperty() { + return stringProperty; + } + public int getIntProperty() { + return intProperty; + } + public Value getValueProperty() { + return valueProperty; + } + + @Override public String toString() { return "an ExampleBean"; } + } + + /** + * A Java Record-like class to test the functionality of + * {@link SamePropertyValuesAs} with Java Records in JDK 8 environment. + * The basic property structure is the same as {@link ExampleBean ExampleBean} for the exact comparison. + * + * @see ExampleBean ExampleBean + * @see https://docs.oracle.com/en/java/javase/17/language/records.html + */ + @SuppressWarnings("unused") + public static final class ExampleRecord { + private final String stringProperty; + private final int intProperty; + private final Value valueProperty; + + public ExampleRecord(String stringProperty, int intProperty, Value valueProperty) { + this.stringProperty = stringProperty; + this.intProperty = intProperty; + this.valueProperty = valueProperty; + } + + public String stringProperty() { return stringProperty; } + public int intProperty() { return intProperty; } + public Value valueProperty() { return valueProperty; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof ExampleRecord)) return false; + ExampleRecord that = (ExampleRecord) o; + return this.intProperty == that.intProperty && Objects.equals(this.stringProperty, that.stringProperty) && Objects.equals(this.valueProperty, that.valueProperty); + } + + @Override + public int hashCode() { + return Objects.hash(stringProperty, intProperty, valueProperty); + } + + @Override public String toString() { return "an ExampleRecord"; } + } + + public static class SubBeanWithNoExtraProperties extends ExampleBean { + public SubBeanWithNoExtraProperties(String stringProperty, int intProperty, Value valueProperty) { + super(stringProperty, intProperty, valueProperty); + } + } + + public static class SubBeanWithExtraProperty extends ExampleBean { + public SubBeanWithExtraProperty(String stringProperty, int intProperty, Value valueProperty) { + super(stringProperty, intProperty, valueProperty); + } + @SuppressWarnings("unused") + public String getExtraProperty() { return "extra"; } + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInAnyOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInAnyOrderTest.java new file mode 100644 index 000000000..6c5f19f7c --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInAnyOrderTest.java @@ -0,0 +1,49 @@ +package org.hamcrest.collection; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.core.IsEqual.equalTo; + +public class ArrayMatchingInAnyOrderTest extends AbstractMatcherTest { + + @SuppressWarnings("unchecked") + @Override + protected Matcher createMatcher() { + return ArrayMatching.arrayContainingInAnyOrder(equalTo(1), equalTo(2)); + } + + @Test + @SuppressWarnings("unchecked") + public void testHasAReadableDescription() { + assertDescription("[<1>, <2>] in any order", ArrayMatching.arrayContainingInAnyOrder(equalTo(1), equalTo(2))); + assertDescription("[<1>, <2>] in any order", ArrayMatching.arrayContainingInAnyOrder(1, 2)); + } + + @Test + public void testMatchesItemsInAnyOrder() { + assertMatches("in order", ArrayMatching.arrayContainingInAnyOrder(1, 2, 3), new Integer[] {1, 2, 3}); + assertMatches("out of order", ArrayMatching.arrayContainingInAnyOrder(1, 2, 3), new Integer[] {3, 2, 1}); + assertMatches("single", ArrayMatching.arrayContainingInAnyOrder(1), new Integer[] {1}); + } + + @Test + @SuppressWarnings("unchecked") + public void testAppliesMatchersInAnyOrder() { + assertMatches("in order", ArrayMatching.arrayContainingInAnyOrder(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3}); + assertMatches("out of order", ArrayMatching.arrayContainingInAnyOrder(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {3, 2, 1}); + assertMatches("single", ArrayMatching.arrayContainingInAnyOrder(equalTo(1)), new Integer[] {1}); + } + + @Test + public void testMismatchesItemsInAnyOrder() { + Matcher matcher = ArrayMatching.arrayContainingInAnyOrder(1, 2, 3); + assertMismatchDescription("was null", matcher, null); + assertMismatchDescription("no item matches: <1>, <2>, <3> in []", matcher, new Integer[] {}); + assertMismatchDescription("no item matches: <2>, <3> in [<1>]", matcher, new Integer[] {1}); + assertMismatchDescription("not matched: <4>", matcher, new Integer[] {4,3,2,1}); + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInOrderTest.java new file mode 100644 index 000000000..e19edfcac --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/collection/ArrayMatchingInOrderTest.java @@ -0,0 +1,53 @@ +package org.hamcrest.collection; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.collection.ArrayMatching.arrayContaining; +import static org.hamcrest.core.IsEqual.equalTo; + +public class ArrayMatchingInOrderTest extends AbstractMatcherTest { + + @SuppressWarnings("unchecked") + @Override + protected Matcher createMatcher() { + return arrayContaining(equalTo(1), equalTo(2)); + } + + @Test + @SuppressWarnings("unchecked") + public void testHasAReadableDescription() { + assertDescription("[<1>, <2>]", arrayContaining(equalTo(1), equalTo(2))); + } + + @Test + public void testMatchesItemsInOrder() { + assertMatches("in order", arrayContaining(1, 2, 3), new Integer[] {1, 2, 3}); + assertMatches("single", arrayContaining(1), new Integer[] {1}); + } + + @Test + @SuppressWarnings("unchecked") + public void testAppliesMatchersInOrder() { + assertMatches("in order", arrayContaining(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3}); + assertMatches("single", arrayContaining(equalTo(1)), new Integer[] {1}); + } + + @Test + public void testMismatchesItemsInOrder() { + Matcher matcher = arrayContaining(1, 2, 3); + assertMismatchDescription("was null", matcher, null); + assertMismatchDescription("no item was <1>", matcher, new Integer[] {}); + assertMismatchDescription("no item was <2>", matcher, new Integer[] {1}); + assertMismatchDescription("item 0: was <4>", matcher, new Integer[] {4,3,2,1}); + assertMismatchDescription("item 2: was <4>", matcher, new Integer[] {1,2, 4}); + } + + @Test + public void testCanHandleNullValuesInAnArray() { + assertMatches("with nulls", arrayContaining(null, null), new Object[]{null, null}); + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/collection/HasItemInArrayTest.java b/hamcrest/src/test/java/org/hamcrest/collection/HasItemInArrayTest.java new file mode 100644 index 000000000..cb810217e --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/collection/HasItemInArrayTest.java @@ -0,0 +1,45 @@ +package org.hamcrest.collection; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.Matchers.lessThan; +import static org.hamcrest.collection.ArrayMatching.hasItemInArray; + +public class HasItemInArrayTest extends AbstractMatcherTest { + + @Override + protected Matcher createMatcher() { + return hasItemInArray("irrelevant"); + } + + @Test + public void testMatchesAnArrayThatContainsAnElementMatchingTheGivenMatcher() { + assertMatches("should matches array that contains 'a'", + hasItemInArray("a"), new String[]{"a", "b", "c"}); + } + + @Test + public void testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher() { + assertDoesNotMatch("should not matches array that doesn't contain 'a'", + hasItemInArray("a"), new String[]{"b", "c"}); + assertDoesNotMatch("should not matches empty array", + hasItemInArray("a"), new String[0]); + assertMismatchDescription( + "mismatches were: [<3> was greater than <2>, <4> was greater than <2>, <5> was greater than <2>]", + hasItemInArray(lessThan(2)), new Integer[] {3, 4, 5}); + } + + @Test + public void testDoesNotMatchNull() { + assertDoesNotMatch("should not matches null", + hasItemInArray("a"), null); + } + + @Test + public void testHasAReadableDescription() { + assertDescription("an array containing a value less than <2>", hasItemInArray(lessThan(2))); + } +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java similarity index 91% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java index d4dc27063..5fb93ca01 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInAnyOrderTest.java @@ -1,11 +1,13 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder; import static org.hamcrest.core.IsEqual.equalTo; +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + public class IsArrayContainingInAnyOrderTest extends AbstractMatcherTest { @SuppressWarnings("unchecked") @@ -14,18 +16,21 @@ protected Matcher createMatcher() { return arrayContainingInAnyOrder(equalTo(1), equalTo(2)); } + @Test @SuppressWarnings("unchecked") public void testHasAReadableDescription() { assertDescription("[<1>, <2>] in any order", arrayContainingInAnyOrder(equalTo(1), equalTo(2))); assertDescription("[<1>, <2>] in any order", arrayContainingInAnyOrder(1, 2)); } - + + @Test public void testMatchesItemsInAnyOrder() { assertMatches("in order", arrayContainingInAnyOrder(1, 2, 3), new Integer[] {1, 2, 3}); assertMatches("out of order", arrayContainingInAnyOrder(1, 2, 3), new Integer[] {3, 2, 1}); assertMatches("single", arrayContainingInAnyOrder(1), new Integer[] {1}); } + @Test @SuppressWarnings("unchecked") public void testAppliesMatchersInAnyOrder() { assertMatches("in order", arrayContainingInAnyOrder(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3}); @@ -33,6 +38,7 @@ public void testAppliesMatchersInAnyOrder() { assertMatches("single", arrayContainingInAnyOrder(equalTo(1)), new Integer[] {1}); } + @Test public void testMismatchesItemsInAnyOrder() { Matcher matcher = arrayContainingInAnyOrder(1, 2, 3); assertMismatchDescription("was null", matcher, null); @@ -40,4 +46,5 @@ public void testMismatchesItemsInAnyOrder() { assertMismatchDescription("no item matches: <2>, <3> in [<1>]", matcher, new Integer[] {1}); assertMismatchDescription("not matched: <4>", matcher, new Integer[] {4,3,2,1}); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java similarity index 88% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java index ab1d82160..e827a3172 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java @@ -1,11 +1,13 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; -import org.hamcrest.Matcher; - +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining; import static org.hamcrest.core.IsEqual.equalTo; +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + public class IsArrayContainingInOrderTest extends AbstractMatcherTest { @SuppressWarnings("unchecked") @@ -14,22 +16,26 @@ protected Matcher createMatcher() { return arrayContaining(equalTo(1), equalTo(2)); } + @Test @SuppressWarnings("unchecked") public void testHasAReadableDescription() { assertDescription("[<1>, <2>]", arrayContaining(equalTo(1), equalTo(2))); } - + + @Test public void testMatchesItemsInOrder() { assertMatches("in order", arrayContaining(1, 2, 3), new Integer[] {1, 2, 3}); assertMatches("single", arrayContaining(1), new Integer[] {1}); } + @Test @SuppressWarnings("unchecked") public void testAppliesMatchersInOrder() { assertMatches("in order", arrayContaining(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3}); assertMatches("single", arrayContaining(equalTo(1)), new Integer[] {1}); } - + + @Test public void testMismatchesItemsInOrder() { Matcher matcher = arrayContaining(1, 2, 3); assertMismatchDescription("was null", matcher, null); @@ -39,7 +45,4 @@ public void testMismatchesItemsInOrder() { assertMismatchDescription("item 2: was <4>", matcher, new Integer[] {1,2, 4}); } - public void testCanHandleNullValuesInAnArray() { - assertMatches("with nulls", arrayContaining(null, null), new Object[]{null, null}); - } } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayTest.java similarity index 91% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsArrayTest.java index 4135d9f5f..7aeb06a44 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayTest.java @@ -1,10 +1,12 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.BaseMatcher; import org.hamcrest.Description; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsArray.array; import static org.hamcrest.core.IsEqual.equalTo; @@ -16,36 +18,43 @@ protected Matcher createMatcher() { return array(equalTo("irrelevant")); } + @Test public void testMatchesAnArrayThatMatchesAllTheElementMatchers() { assertMatches("should match array with matching elements", array(equalTo("a"), equalTo("b"), equalTo("c")), new String[]{"a", "b", "c"}); } - + + @Test public void testDoesNotMatchAnArrayWhenElementsDoNotMatch() { assertDoesNotMatch("should not match array with different elements", array(equalTo("a"), equalTo("b")), new String[]{"b", "c"}); } - + + @Test public void testDoesNotMatchAnArrayOfDifferentSize() { assertDoesNotMatch("should not match larger array", array(equalTo("a"), equalTo("b")), new String[]{"a", "b", "c"}); assertDoesNotMatch("should not match smaller array", array(equalTo("a"), equalTo("b")), new String[]{"a"}); } - + + @Test public void testDoesNotMatchNull() { assertDoesNotMatch("should not match null", array(equalTo("a")), null); } - + + @Test public void testHasAReadableDescription() { assertDescription("[\"a\", \"b\"]", array(equalTo("a"), equalTo("b"))); } - + + @Test public void testHasAReadableMismatchDescriptionUsing() { assertMismatchDescription("element <0> was \"c\"", array(equalTo("a"), equalTo("b")), new String[]{"c", "b"}); } - + + @Test public void testHasAReadableMismatchDescriptionUsingCustomMatchers() { final BaseMatcher m = new BaseMatcher() { @Override public boolean matches(Object item) { return false; } @@ -56,4 +65,5 @@ public void testHasAReadableMismatchDescriptionUsingCustomMatchers() { }; assertMismatchDescription("element <0> didn't match", array(m, equalTo("b")), new String[]{"c", "b"}); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java similarity index 88% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java index 18f607ec6..700825ddd 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsArrayWithSizeTest.java @@ -1,8 +1,10 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize; import static org.hamcrest.collection.IsArrayWithSize.emptyArray; import static org.hamcrest.core.IsEqual.equalTo; @@ -14,23 +16,28 @@ protected Matcher createMatcher() { return arrayWithSize(equalTo(2)); } + @Test public void testMatchesWhenSizeIsCorrect() { assertMatches("correct size", arrayWithSize(equalTo(3)), new Object[] {1, 2, 3}); assertDoesNotMatch("incorrect size", arrayWithSize(equalTo(2)), new Object[] {1, 2, 3}); } + @Test public void testProvidesConvenientShortcutForArrayWithSizeEqualTo() { assertMatches("correct size", arrayWithSize(3), new Object[] {1, 2, 3}); assertDoesNotMatch("incorrect size", arrayWithSize(2), new Object[] {1, 2, 3}); } + @Test public void testEmptyArray() { assertMatches("correct size", emptyArray(), new Object[] {}); assertDoesNotMatch("incorrect size", emptyArray(), new Object[] {1}); } + @Test public void testHasAReadableDescription() { assertDescription("an array with size <3>", arrayWithSize(equalTo(3))); assertDescription("an empty array", emptyArray()); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java similarity index 91% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java index b04a0c5c7..63f91b989 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsCollectionWithSizeTest.java @@ -1,14 +1,16 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; import org.hamcrest.MatcherAssert; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.Collection; import java.util.List; import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsCollectionWithSize.hasSize; import static org.hamcrest.core.IsEqual.equalTo; @@ -19,59 +21,70 @@ protected Matcher createMatcher() { return hasSize(7); } + @Test public void testMatchesWhenSizeIsCorrect() { assertMatches("correct size", hasSize(equalTo(2)), asList(null, null)); assertMismatchDescription("collection size was <3>", hasSize(equalTo(2)), asList(null, null, null)); } + @Test public void testMatchesCollectionWhenSizeIsCorrectUsingObjectElementType() { Collection list = asList(null, null); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testMatchesCollectionWhenSizeIsCorrectUsingStringElementType() { Collection list = asList("a", "b"); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testMatchesCollectionWhenSizeIsCorrectUsingWildcardElementType() { Collection list = asList("a", "b"); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testMatchesListWhenSizeIsCorrectUsingObjectElementType() { List list = asList(null, null); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testMatchesListWhenSizeIsCorrectUsingStringElementType() { List list = asList("a", "b"); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testMatchesListWhenSizeIsCorrectUsingWildcardElementType() { List list = asList("a", "b"); assertMatches("correct size", hasSize(equalTo(2)), list); assertMismatchDescription("collection size was <2>", hasSize(equalTo(3)), list); } + @Test public void testProvidesConvenientShortcutForHasSizeEqualTo() { assertMatches("correct size", hasSize(2), asList(null, null)); assertMismatchDescription("collection size was <3>", hasSize(2), asList(null, null, null)); } + @Test public void testHasAReadableDescription() { assertDescription("a collection with size <3>", hasSize(equalTo(3))); } - + + @Test public void testCompilesWithATypedCollection() { // To prove Issue 43 - ArrayList arrayList = new ArrayList(); + ArrayList arrayList = new ArrayList<>(); MatcherAssert.assertThat(arrayList, hasSize(0)); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java similarity index 81% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java index ea875e8a1..947834902 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsEmptyCollectionTest.java @@ -1,12 +1,14 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.Collection; import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsEmptyCollection.empty; import static org.hamcrest.core.Is.is; @@ -17,29 +19,34 @@ protected Matcher> createMatcher() { return empty(); } + @Test public void testMatchesAnEmptyCollection() { assertMatches("empty collection", createMatcher(), emptyCollection()); } + @Test public void testDoesNotMatchACollectionWithAnItem() { assertMismatchDescription("<[one, three]>", is(createMatcher()), collectionOfValues()); } + @Test public void testHasAReadableDescription() { assertDescription("an empty collection", createMatcher()); } + @Test public void testCompiles() { needs(IsEmptyCollection.emptyCollectionOf(String.class)); } private void needs(@SuppressWarnings("unused") Matcher> bar) { } - + private static Collection collectionOfValues() { - return new ArrayList(asList("one", "three")); + return new ArrayList<>(asList("one", "three")); } private static Collection emptyCollection() { - return new ArrayList(); + return new ArrayList<>(); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java similarity index 81% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java index 600b57603..eb83e8983 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsEmptyIterableTest.java @@ -1,12 +1,14 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.Collection; import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsEmptyIterable.emptyIterable; public class IsEmptyIterableTest extends AbstractMatcherTest { @@ -16,18 +18,22 @@ protected Matcher> createMatcher() { return emptyIterable(); } + @Test public void testMatchesAnEmptyIterable() { assertMatches("empty iterable", createMatcher(), emptyCollection()); } + @Test public void testDoesNotMatchAnIterableWithItems() { assertDoesNotMatch("iterable with an item", createMatcher(), collectionOfValues()); } + @Test public void testHasAReadableDescription() { assertDescription("an empty iterable", createMatcher()); } + @Test public void testCompiles() { needs(IsEmptyIterable.emptyIterableOf(String.class)); } @@ -35,10 +41,11 @@ public void testCompiles() { private void needs(@SuppressWarnings("unused") Matcher> bar) { } private static Collection collectionOfValues() { - return new ArrayList(asList("one", "three")); + return new ArrayList<>(asList("one", "three")); } private static Collection emptyCollection() { - return new ArrayList(); + return new ArrayList<>(); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsInTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsInTest.java similarity index 57% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsInTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsInTest.java index e9fcbdcbb..5e6fd4d33 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsInTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsInTest.java @@ -1,44 +1,55 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; import org.hamcrest.StringDescription; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Collection; +import static org.hamcrest.test.MatcherAssertions.assertDoesNotMatch; +import static org.hamcrest.test.MatcherAssertions.assertMatches; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class IsInTest extends AbstractMatcherTest { + String[] elements = {"a", "b", "c"}; @Override protected Matcher createMatcher() { - return new IsIn(elements); + return new IsIn<>(elements); } + @Test public void testReturnsTrueIfArgumentIsInCollection() { Collection collection = Arrays.asList(elements); - Matcher isIn = new IsIn(collection); - + Matcher isIn = new IsIn<>(collection); + assertMatches("a", isIn, "a"); assertMatches("b", isIn, "b"); assertMatches("c", isIn, "c"); assertDoesNotMatch("d", isIn, "d"); } - + + @Test public void testReturnsTrueIfArgumentIsInArray() { - Matcher isIn = new IsIn(elements); - + Matcher isIn = new IsIn<>(elements); + assertMatches("a", isIn, "a"); assertMatches("b", isIn, "b"); assertMatches("c", isIn, "c"); assertDoesNotMatch("d", isIn, "d"); } - + + @Test public void testHasReadableDescription() { - Matcher isIn = new IsIn(elements); - - assertEquals("description", - "one of {\"a\", \"b\", \"c\"}", - StringDescription.toString(isIn)); + Matcher isIn = new IsIn<>(elements); + + assertEquals( + "one of {\"a\", \"b\", \"c\"}", + StringDescription.toString(isIn), + "description"); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java similarity index 90% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java index 091c34755..057b3b4d3 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInAnyOrderTest.java @@ -1,12 +1,14 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; import org.hamcrest.collection.IsIterableContainingInOrderTest.WithValue; +import org.junit.jupiter.api.Test; import java.util.Collections; import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; import static org.hamcrest.collection.IsIterableContainingInOrderTest.make; import static org.hamcrest.collection.IsIterableContainingInOrderTest.value; @@ -16,39 +18,48 @@ public class IsIterableContainingInAnyOrderTest extends AbstractMatcherTest { @Override protected Matcher createMatcher() { return containsInAnyOrder(1, 2); - } + } + @Test public void testMatchesSingleItemIterable() { assertMatches("single item", containsInAnyOrder(1), asList(1)); } + @Test public void testDoesNotMatchEmpty() { assertMismatchDescription("no item matches: <1>, <2> in []", containsInAnyOrder(1, 2), Collections.emptyList()); } - + + @Test public void testMatchesIterableOutOfOrder() { assertMatches("Out of order", containsInAnyOrder(1, 2), asList(2, 1)); } - + + @Test public void testMatchesIterableInOrder() { assertMatches("In order", containsInAnyOrder(1, 2), asList(1, 2)); } - + + @Test public void testDoesNotMatchIfOneOfMultipleElementsMismatches() { assertMismatchDescription("not matched: <4>", containsInAnyOrder(1, 2, 3), asList(1, 2, 4)); } + @Test @SuppressWarnings("unchecked") public void testDoesNotMatchIfThereAreMoreElementsThanMatchers() { final Matcher> helpTheCompilerOut = containsInAnyOrder(value(1), value(3)); assertMismatchDescription("not matched: ", helpTheCompilerOut, asList(make(1), make(2), make(3))); } - + + @Test public void testDoesNotMatchIfThereAreMoreMatchersThanElements() { assertMismatchDescription("no item matches: <4> in [<1>, <2>, <3>]", containsInAnyOrder(1, 2, 3, 4), asList(1, 2, 3)); } + @Test public void testHasAReadableDescription() { assertDescription("iterable with items [<1>, <2>] in any order", containsInAnyOrder(1, 2)); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java similarity index 83% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java index 8cb1bf829..bc318bb16 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInOrderTest.java @@ -1,18 +1,21 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.FeatureMatcher; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.ArrayList; -import java.util.List; import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsIterableContainingInOrder.contains; import static org.hamcrest.core.IsEqual.equalTo; @SuppressWarnings("unchecked") public class IsIterableContainingInOrderTest extends AbstractMatcherTest { + // temporary hack until the Java type system works private final Matcher> contains123 = contains(value(1), value(2), value(3)); @@ -21,41 +24,49 @@ protected Matcher createMatcher() { return contains(1, 2); } + @Test public void testMatchingSingleItemIterable() throws Exception { - assertMatches("Single item iterable", contains(1), asList(1)); + assertMatches("Single item iterable", contains(1), singletonList(1)); } + @Test public void testMatchingMultipleItemIterable() throws Exception { assertMatches("Multiple item iterable", contains(1, 2, 3), asList(1, 2, 3)); } + @Test public void testDoesNotMatchWithMoreElementsThanExpected() throws Exception { assertMismatchDescription("not matched: <4>", contains(1, 2, 3), asList(1, 2, 3, 4)); } + @Test public void testDoesNotMatchWithFewerElementsThanExpected() throws Exception { - List valueList = asList(make(1), make(2)); - assertMismatchDescription("no item was value with <3>", contains123, valueList); + assertMismatchDescription("no item was value with <3>", contains123, asList(make(1), make(2))); } + @Test public void testDoesNotMatchIfSingleItemMismatches() throws Exception { - assertMismatchDescription("item 0: value was <3>", contains(value(4)), asList(make(3))); + assertMismatchDescription("item 0: value was <3>", contains(value(4)), singletonList(make(3))); } + @Test public void testDoesNotMatchIfOneOfMultipleItemsMismatch() throws Exception { assertMismatchDescription("item 2: value was <4>", contains123, asList(make(1), make(2), make(4))); } + @Test public void testDoesNotMatchEmptyIterable() throws Exception { assertMismatchDescription("no item was value with <4>", contains(value(4)), new ArrayList()); } + @Test public void testHasAReadableDescription() { assertDescription("iterable containing [<1>, <2>]", contains(1, 2)); } - + + @Test public void testCanHandleNullMatchers() { - assertMatches(contains(null, null), asList(null, null)); + assertMatches(contains(null, null), asList(null, null)); } public static class WithValue { @@ -74,4 +85,5 @@ public static Matcher value(int value) { @Override protected Integer featureValueOf(WithValue actual) { return actual.getValue(); } }; } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java similarity index 93% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java index 8192c8bf2..dc8662ad6 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableContainingInRelativeOrderTest.java @@ -1,18 +1,21 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.FeatureMatcher; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.List; import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder; import static org.hamcrest.core.IsEqual.equalTo; @SuppressWarnings("unchecked") public class IsIterableContainingInRelativeOrderTest extends AbstractMatcherTest { + // temporary hack until the Java type system works private final Matcher> contains123 = containsInRelativeOrder(value(1), value(2), value(3)); @@ -21,55 +24,68 @@ protected Matcher createMatcher() { return containsInRelativeOrder(1, 2); } + @Test public void testMatchingSingleItemIterable() throws Exception { assertMatches("Single item iterable", containsInRelativeOrder(1), asList(1)); } + @Test public void testMatchingMultipleItemIterable() throws Exception { assertMatches("Multiple item iterable", containsInRelativeOrder(1, 2, 3), asList(1, 2, 3)); } + @Test public void testMatchesWithMoreElementsThanExpectedAtBeginning() throws Exception { assertMatches("More elements at beginning", containsInRelativeOrder(2, 3, 4), asList(1, 2, 3, 4)); } + @Test public void testMatchesWithMoreElementsThanExpectedAtEnd() throws Exception { assertMatches("More elements at end", containsInRelativeOrder(1, 2, 3), asList(1, 2, 3, 4)); } + @Test public void testMatchesWithMoreElementsThanExpectedInBetween() throws Exception { assertMatches("More elements in between", containsInRelativeOrder(1, 3), asList(1, 2, 3)); } + @Test public void testMatchesSubSection() throws Exception { assertMatches("Sub section of iterable", containsInRelativeOrder(2, 3), asList(1, 2, 3, 4)); } + @Test public void testMatchesWithSingleGapAndNotFirstOrLast() throws Exception { assertMatches("Sub section with single gaps without a first or last match", containsInRelativeOrder(2, 4), asList(1, 2, 3, 4, 5)); } + @Test public void testMatchingSubSectionWithManyGaps() throws Exception { assertMatches("Sub section with many gaps iterable", containsInRelativeOrder(2, 4, 6), asList(1, 2, 3, 4, 5, 6, 7)); } + @Test public void testDoesNotMatchWithFewerElementsThanExpected() throws Exception { List valueList = asList(make(1), make(2)); assertMismatchDescription("value with <3> was not found after ", contains123, valueList); } + @Test public void testDoesNotMatchIfSingleItemNotFound() throws Exception { assertMismatchDescription("value with <4> was not found", containsInRelativeOrder(value(4)), asList(make(3))); } + @Test public void testDoesNotMatchIfOneOfMultipleItemsNotFound() throws Exception { assertMismatchDescription("value with <3> was not found after ", contains123, asList(make(1), make(2), make(4))); } + @Test public void testDoesNotMatchEmptyIterable() throws Exception { assertMismatchDescription("value with <4> was not found", containsInRelativeOrder(value(4)), new ArrayList()); } + @Test public void testHasAReadableDescription() { assertDescription("iterable containing [<1>, <2>] in relative order", containsInRelativeOrder(1, 2)); } @@ -90,4 +106,5 @@ public static Matcher value(int value) { @Override protected Integer featureValueOf(WithValue actual) { return actual.getValue(); } }; } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java similarity index 86% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java index 8bf65d14c..7cad42718 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsIterableWithSizeTest.java @@ -1,11 +1,13 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Collections; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsIterableWithSize.iterableWithSize; public class IsIterableWithSizeTest extends AbstractMatcherTest { @@ -15,23 +17,29 @@ protected Matcher createMatcher() { return iterableWithSize(7); } + @Test public void testMatchesEmptyIterable() throws Exception { assertMatches("Empty iterable", iterableWithSize(0), Collections.emptyList()); } + @Test public void testMatchingSingleItemIterable() throws Exception { assertMatches("Single item iterable", iterableWithSize(1), Arrays.asList(1)); } + @Test public void testMatchingMultipleItemIterable() throws Exception { assertMatches("Multiple item iterable", iterableWithSize(3), Arrays.asList(1, 2, 3)); } + @Test public void testDoesNotMatchIncorrectSize() throws Exception { assertDoesNotMatch("Incorrect size", iterableWithSize(3), Arrays.asList(1)); } + @Test public void testHasAReadableDescription() { assertDescription("an iterable with size <4>", iterableWithSize(4)); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java similarity index 80% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java index 13f067c87..bfe2aa82e 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingKeyTest.java @@ -1,13 +1,15 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsMapContaining.hasKey; public class IsMapContainingKeyTest extends AbstractMatcherTest { @@ -17,23 +19,24 @@ protected Matcher createMatcher() { return hasKey("foo"); } + @Test public void testMatchesSingletonMapContainingKey() { - Map map = new HashMap(); + Map map = new HashMap<>(); map.put("a", 1); - + assertMatches("Matches single key", hasKey("a"), map); } - + + @Test public void testMatchesMapContainingKey() { - Map map = new HashMap(); + Map map = new HashMap<>(); map.put("a", 1); map.put("b", 2); map.put("c", 3); - + assertMatches("Matches a", hasKey("a"), map); assertMatches("Matches c", hasKey("c"), map); } - // No longer compiles // public void testMatchesMapContainingKeyWithNoGenerics() { @@ -46,16 +49,18 @@ public void testMatchesMapContainingKey() { // assertMatches("Matches c", hasKey("c"), map); // } + @Test public void testMatchesMapContainingKeyWithIntegerKeys() throws Exception { - Map map = new HashMap(); + Map map = new HashMap<>(); map.put(1, "A"); map.put(2, "B"); assertThat(map, hasKey(1)); } + @Test public void testMatchesMapContainingKeyWithNumberKeys() throws Exception { - Map map = new HashMap(); + Map map = new HashMap<>(); map.put(1, "A"); map.put(2, "B"); @@ -65,20 +70,24 @@ public void testMatchesMapContainingKeyWithNumberKeys() throws Exception { // assertThat(map, hasKey(1)); } + @Test public void testHasReadableDescription() { assertDescription("map containing [\"a\"->ANYTHING]", hasKey("a")); } - + + @Test public void testDoesNotMatchEmptyMap() { - assertMismatchDescription("map was []", hasKey("Foo"), new HashMap()); + assertMismatchDescription("map was []", hasKey("Foo"), new HashMap()); } - + + @Test public void testDoesNotMatchMapMissingKey() { - Map map = new TreeMap(); + Map map = new TreeMap<>(); map.put("a", 1); map.put("b", 2); map.put("c", 3); - + assertMismatchDescription("map was [, , ]", hasKey("d"), map); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingTest.java similarity index 52% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingTest.java index f47222469..5c16f9b0e 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingTest.java @@ -1,14 +1,19 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import java.util.HashMap; import java.util.Map; import java.util.TreeMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsMapContaining.hasEntry; import static org.hamcrest.core.IsAnything.anything; import static org.hamcrest.core.IsEqual.equalTo; +import static org.junit.jupiter.api.Assertions.assertFalse; public class IsMapContainingTest extends AbstractMatcherTest { @@ -17,8 +22,9 @@ protected Matcher createMatcher() { return IsMapContaining.hasEntry("irrelevant", "irrelevant"); } + @Test public void testMatchesMapContainingMatchingKeyAndValue() { - Map map = new TreeMap(); + Map map = new TreeMap<>(); map.put("a", 1); map.put("b", 2); @@ -27,32 +33,34 @@ public void testMatchesMapContainingMatchingKeyAndValue() { assertMismatchDescription("map was [, ]", hasEntry(equalTo("c"), equalTo(3)), map); } -// no longer compiles. SF -// public void testMatchesMapContainingMatchingKeyAndValueWithoutGenerics() { -// Map map = new HashMap(); -// map.put("a", 1); -// map.put("b", 2); -// -// assertMatches("matcherA", hasEntry(equalTo("a"), equalTo(1)), map); -// assertMatches("matcherB", hasEntry(equalTo("b"), equalTo(2)), map); -// assertDoesNotMatch("matcherC", hasEntry(equalTo("c"), equalTo(3)), map); -// } -// + @Test + @SuppressWarnings("unchecked") + public void testMatchesMapContainingMatchingKeyAndValueWithoutGenerics() { + Map map = new HashMap(); + map.put("a", 1); + map.put("b", 2); + + assertMatches("matcherA", hasEntry(equalTo("a"), equalTo(1)), map); + assertMatches("matcherB", hasEntry(equalTo("b"), equalTo(2)), map); + assertFalse(hasEntry(equalTo("c"), equalTo(3)).matches(map), "matcherC"); // working around generics problem + } + + @Test public void testDoesNotMatchNull() { assertMismatchDescription("was null", hasEntry(anything(), anything()), null); } + @Test public void testHasReadableDescription() { assertDescription("map containing [\"a\"-><2>]", hasEntry(equalTo("a"), (equalTo(2)))); } - // Remaining code no longer compiles, thanks to generics. I think that's a good thing, but - // I still need to investigate how this behaves with code that doesn't use generics. - // I expect ClassCastExceptions will be thrown. - // -Joe. - -// public void testDoesNotMatchAnObjectThatIsNotAMap() { -// assertDoesNotMatch("should not matches a string", -// mapContaining(ANYTHING, ANYTHING), "not a map"); -// } + @Test + public void testTypeVariance() { + Map m = new HashMap<>(); + Integer foo = 6; + m.put("foo", foo); + assertThat(m, hasEntry("foo", foo)); + } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java similarity index 67% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java index a2d7f908d..39b1abafc 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsMapContainingValueTest.java @@ -1,13 +1,14 @@ package org.hamcrest.collection; - -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsMapContaining.hasValue; public class IsMapContainingValueTest extends AbstractMatcherTest { @@ -17,30 +18,35 @@ protected Matcher createMatcher() { return hasValue("foo"); } + @Test public void testHasReadableDescription() { assertDescription("map containing [ANYTHING->\"a\"]", hasValue("a")); } - + + @Test public void testDoesNotMatchEmptyMap() { - Map map = new HashMap(); + Map map = new HashMap<>(); assertMismatchDescription("map was []", hasValue(1), map); } - + + @Test public void testMatchesSingletonMapContainingValue() { - Map map = new HashMap(); + Map map = new HashMap<>(); map.put("a", 1); - + assertMatches("Singleton map", hasValue(1), map); } + @Test public void testMatchesMapContainingValue() { - Map map = new TreeMap(); + Map map = new TreeMap<>(); map.put("a", 1); map.put("b", 2); map.put("c", 3); - - assertMatches("hasValue 1", hasValue(1), map); - assertMatches("hasValue 3", hasValue(3), map); - assertMismatchDescription("map was [, , ]", hasValue(4), map); + + assertMatches("hasValue 1", hasValue(1), map); + assertMatches("hasValue 3", hasValue(3), map); + assertMismatchDescription("map was [, , ]", hasValue(4), map); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java b/hamcrest/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java similarity index 90% rename from hamcrest-library/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java rename to hamcrest/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java index c050924cd..ebe6a5703 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java +++ b/hamcrest/src/test/java/org/hamcrest/collection/IsMapWithSizeTest.java @@ -1,12 +1,14 @@ package org.hamcrest.collection; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; import org.hamcrest.MatcherAssert; +import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.Map; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.collection.IsMapWithSize.aMapWithSize; import static org.hamcrest.core.IsEqual.equalTo; @@ -17,66 +19,77 @@ protected Matcher createMatcher() { return aMapWithSize(7); } + @Test public void testMatchesWhenSizeIsCorrect() { assertMatches("correct size", aMapWithSize(equalTo(2)), mapWithKeys("a", "b")); assertMismatchDescription("map size was <3>", aMapWithSize(equalTo(2)), mapWithKeys("a", "b", "c")); } + @Test public void testMatchesMapWhenSizeIsCorrectUsingObjectElementType() { Map map = mapWithKeys(new Object(), new Object()); assertMatches("correct size", aMapWithSize(equalTo(2)), map); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), map); } + @Test public void testMatchesMapWhenSizeIsCorrectUsingStringElementType() { Map map = mapWithKeys("a", "b"); assertMatches("correct size", aMapWithSize(equalTo(2)), map); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), map); } + @Test public void testMatchesMapWhenSizeIsCorrectUsingWildcardElementType() { Map map = mapWithKeys("a", "b"); assertMatches("correct size", aMapWithSize(equalTo(2)), map); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), map); } + @Test public void testMatchesListWhenSizeIsCorrectUsingObjectElementType() { Map map = mapWithKeys(new Object(), new Object()); assertMatches("correct size", aMapWithSize(equalTo(2)), map); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), map); } + @Test public void testMatchesListWhenSizeIsCorrectUsingStringElementType() { Map list = mapWithKeys("a", "b"); assertMatches("correct size", aMapWithSize(equalTo(2)), list); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), list); } + @Test public void testMatchesListWhenSizeIsCorrectUsingWildcardElementType() { Map list = mapWithKeys("a", "b"); assertMatches("correct size", aMapWithSize(equalTo(2)), list); assertMismatchDescription("map size was <2>", aMapWithSize(equalTo(3)), list); } + @Test public void testProvidesConvenientShortcutForHasSizeEqualTo() { assertMatches("correct size", aMapWithSize(2), mapWithKeys(new Object(), new Object())); assertMismatchDescription("map size was <3>", aMapWithSize(2), mapWithKeys(new Object(), new Object(), new Object())); } + @Test public void testHasAReadableDescription() { assertDescription("a map with size <3>", aMapWithSize(equalTo(3))); } - + + @Test public void testCompilesWithATypedMap() { - Map arrayList = new HashMap(); + Map arrayList = new HashMap<>(); MatcherAssert.assertThat(arrayList, aMapWithSize(0)); } - + private static Map mapWithKeys(K... keys) { - final Map result = new HashMap(); + final Map result = new HashMap<>(); for (K key : keys) { result.put(key, null); } return result; } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java b/hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java similarity index 95% rename from hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java rename to hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java index a5fdb4ac6..9fe58976d 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java +++ b/hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherBuilderTest.java @@ -1,12 +1,15 @@ package org.hamcrest.comparator; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.util.Comparator; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertDescription; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; import static org.hamcrest.comparator.ComparatorMatcherBuilder.comparedBy; import static org.hamcrest.core.IsNot.not; @@ -33,6 +36,7 @@ protected Matcher createMatcher() { return integerComparatorMatcherBuilder.greaterThan(1); } + @Test public void testDescription() { assertDescription("a value greater than <1>", integerComparatorMatcherBuilder.greaterThan(1)); assertDescription("a value equal to or greater than <1>", integerComparatorMatcherBuilder.greaterThanOrEqualTo(1)); @@ -47,6 +51,7 @@ public void testDescription() { assertDescription("a value less than <1> when compared by ", comparedBy(backwardsIntegerComparator).lessThan(1)); } + @Test public void testMismatchDescriptions() { assertMismatchDescription("<0> was less than <1>", integerComparatorMatcherBuilder.greaterThan(1), 0); assertMismatchDescription("<1> was equal to <1>", integerComparatorMatcherBuilder.greaterThan(1), 1); @@ -59,46 +64,54 @@ public void testMismatchDescriptions() { assertMismatchDescription("<2> was equal to <2> when compared by ", comparedBy(backwardsIntegerComparator).lessThan(2), 2); } + @Test public void testComparesObjectsForGreaterThan() { assertThat(2, integerComparatorMatcherBuilder.greaterThan(1)); assertThat(0, not(integerComparatorMatcherBuilder.greaterThan(1))); } + @Test public void testComparesObjectsForLessThan() { assertThat(2, integerComparatorMatcherBuilder.lessThan(3)); assertThat(0, integerComparatorMatcherBuilder.lessThan(1)); } - + @Test public void testComparesObjectsForEquality() { assertThat(3, integerComparatorMatcherBuilder.comparesEqualTo(3)); assertThat("aa", stringComparatorMatcherBuilder.comparesEqualTo("aa")); } + @Test public void testAllowsForInclusiveComparisons() { assertThat("less", 1, integerComparatorMatcherBuilder.lessThanOrEqualTo(1)); assertThat("greater", 1, integerComparatorMatcherBuilder.greaterThanOrEqualTo(1)); } + @Test public void testSupportsDifferentTypesOfComparableObjects() { assertThat(1.1, doubleComparatorMatcherBuilder.greaterThan(1.0)); assertThat("cc", stringComparatorMatcherBuilder.greaterThan("bb")); } + @Test public void testComparesBigDecimalsWithDifferentScalesCorrectlyForIssue20() { assertThat(new BigDecimal("10.0"), bigDecimalComparatorMatcherBuilder.greaterThanOrEqualTo(new BigDecimal("10"))); assertThat(new BigDecimal(10), bigDecimalComparatorMatcherBuilder.greaterThanOrEqualTo(new BigDecimal("10.0"))); assertThat(new BigDecimal("2"), bigDecimalComparatorMatcherBuilder.comparesEqualTo(new BigDecimal("2.000"))); } + @Test public void testComparesCustomTypesWhoseCompareToReturnsValuesGreaterThatOne() { assertThat(new CustomInt(5), ComparatorMatcherBuilder.usingNaturalOrdering().lessThan(new CustomInt(10))); } + @Test public void testComparesByCustomComparator() { assertThat(5, comparedBy(backwardsIntegerComparator).lessThan(4)); } + @Test public void testJavadocExamples() { assertThat(1, ComparatorMatcherBuilder.usingNaturalOrdering().comparesEqualTo(1)); assertThat(2, ComparatorMatcherBuilder.usingNaturalOrdering().greaterThan(1)); @@ -125,4 +138,5 @@ public int compareTo(CustomInt other) { return value - other.value; } } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java similarity index 90% rename from hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java rename to hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java index 2bc53d4cf..772bc6a85 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java +++ b/hamcrest/src/test/java/org/hamcrest/comparator/ComparatorMatcherTest.java @@ -1,12 +1,15 @@ package org.hamcrest.comparator; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.util.Comparator; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertDescription; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; import static org.hamcrest.core.IsNot.not; import static org.hamcrest.number.OrderingComparison.*; @@ -22,6 +25,7 @@ public int compare(Integer o1, Integer o2) { }).greaterThan(1); } + @Test public void testDescription() { assertDescription("a value greater than <1>", greaterThan(1)); assertDescription("a value equal to or greater than <1>", greaterThanOrEqualTo(1)); @@ -30,6 +34,7 @@ public void testDescription() { assertDescription("a value less than <1>", lessThan(1)); } + @Test public void testMismatchDescriptions() { assertMismatchDescription("<0> was less than <1>", greaterThan(1), 0); assertMismatchDescription("<1> was equal to <1>", greaterThan(1), 1); @@ -37,38 +42,44 @@ public void testMismatchDescriptions() { assertMismatchDescription("<2> was equal to <2>", lessThan(2), 2); } + @Test public void testComparesObjectsForGreaterThan() { assertThat(2, greaterThan(1)); assertThat(0, not(greaterThan(1))); } + @Test public void testComparesObjectsForLessThan() { assertThat(2, lessThan(3)); assertThat(0, lessThan(1)); } - + @Test public void testComparesObjectsForEquality() { assertThat(3, comparesEqualTo(3)); assertThat("aa", comparesEqualTo("aa")); } + @Test public void testAllowsForInclusiveComparisons() { assertThat("less", 1, lessThanOrEqualTo(1)); assertThat("greater", 1, greaterThanOrEqualTo(1)); } + @Test public void testSupportsDifferentTypesOfComparableObjects() { assertThat(1.1, greaterThan(1.0)); assertThat("cc", greaterThan("bb")); } + @Test public void testComparesBigDecimalsWithDifferentScalesCorrectlyForIssue20() { assertThat(new BigDecimal("10.0"), greaterThanOrEqualTo(new BigDecimal("10"))); assertThat(new BigDecimal(10), greaterThanOrEqualTo(new BigDecimal("10.0"))); assertThat(new BigDecimal("2"), comparesEqualTo(new BigDecimal("2.000"))); } + @Test public void testComparesCustomTypesWhoseCompareToReturnsValuesGreaterThatOne() { assertThat(new CustomInt(5), lessThan(new CustomInt(10))); } @@ -84,4 +95,5 @@ public int compareTo(CustomInt other) { return value - other.value; } } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java b/hamcrest/src/test/java/org/hamcrest/core/AllOfTest.java similarity index 86% rename from hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java rename to hamcrest/src/test/java/org/hamcrest/core/AllOfTest.java index 481500206..e174d66d0 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/AllOfTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/AllOfTest.java @@ -1,13 +1,15 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; 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.StringContains.containsString; import static org.hamcrest.core.StringEndsWith.endsWith; import static org.hamcrest.core.StringStartsWith.startsWith; @@ -16,15 +18,15 @@ public final class AllOfTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = allOf(equalTo("irrelevant"), startsWith("irr")); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } - + @Test public void evaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() { Matcher 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"); @@ -34,11 +36,11 @@ public final class AllOfTest { @Test public void evaluatesToTheTheLogicalConjunctionOfManyOtherMatchers() { Matcher 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 matcher = allOf( @@ -46,10 +48,10 @@ public final class AllOfTest { 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\")", @@ -60,4 +62,10 @@ public final class AllOfTest { hasAMismatchDescriptionDescribingTheFirstFailingMatch() { assertMismatchDescription("\"good\" was \"bad\"", allOf(equalTo("bad"), equalTo("good")), "bad"); } + + @Test public void + varargs() { + assertThat("the text!", new AllOf<>(startsWith("the"), containsString("text"), endsWith("!"))); + } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java b/hamcrest/src/test/java/org/hamcrest/core/AnyOfTest.java similarity index 87% rename from hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java rename to hamcrest/src/test/java/org/hamcrest/core/AnyOfTest.java index 11c053cf8..013eafba6 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/AnyOfTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/AnyOfTest.java @@ -1,9 +1,10 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.AnyOf.anyOf; import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.StringEndsWith.endsWith; @@ -14,7 +15,7 @@ public final class AnyOfTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = anyOf(equalTo("irrelevant"), startsWith("irr")); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -22,7 +23,7 @@ public final class AnyOfTest { @Test public void evaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers() { Matcher 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"); @@ -32,7 +33,7 @@ public final class AnyOfTest { @Test public void evaluatesToTheTheLogicalDisjunctionOfManyOtherMatchers() { Matcher 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"); } @@ -44,7 +45,7 @@ public final class AnyOfTest { equalTo(new SampleBaseClass("bad")), equalTo(new SampleBaseClass("good")), equalTo(new SampleSubClass("ugly"))); - + assertMatches("didn't pass middle sub-matcher", matcher, new SampleSubClass("good")); } @@ -53,4 +54,10 @@ public final class AnyOfTest { assertDescription("(\"good\" or \"bad\" or \"ugly\")", anyOf(equalTo("good"), equalTo("bad"), equalTo("ugly"))); } + + @Test public void + varargs() { + assertThat("the text!", new AnyOf<>(startsWith("the"), endsWith("."))); + } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java b/hamcrest/src/test/java/org/hamcrest/core/CombinableTest.java similarity index 90% rename from hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java rename to hamcrest/src/test/java/org/hamcrest/core/CombinableTest.java index e89c493ea..56d968fea 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/CombinableTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/CombinableTest.java @@ -1,16 +1,17 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; 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 EITHER_3_OR_4 = CombinableMatcher.either(equalTo(3)).or(equalTo(4)); - private static final CombinableMatcher NOT_3_AND_NOT_4 = CombinableMatcher.both(not(equalTo(3))).and(not(equalTo(4))); + + private static final CombinableMatcher EITHER_3_OR_4 = CombinableMatcher.either(equalTo(3)).or(equalTo(4)); + private static final CombinableMatcher NOT_3_AND_NOT_4 = CombinableMatcher.both(not(equalTo(3))).and(not(equalTo(4))); @Test public void copesWithNullsAndUnknownTypes() { @@ -29,7 +30,7 @@ public final class CombinableTest { @Test public void acceptsAndRejectsThreeAnds() { CombinableMatcher tripleAnd = NOT_3_AND_NOT_4.and(equalTo(2)); - + assertMatches("tripleAnd didn't pass", tripleAnd, 2); assertDoesNotMatch("tripleAnd didn't fail", tripleAnd, 3); } @@ -49,7 +50,7 @@ public final class CombinableTest { @Test public void acceptsAndRejectsThreeOrs() { final CombinableMatcher tripleOr = EITHER_3_OR_4.or(equalTo(11)); - + assertMatches("tripleOr didn't pass", tripleOr, 11); assertDoesNotMatch("tripleOr didn't fail", tripleOr, 9); } @@ -65,4 +66,5 @@ public final class CombinableTest { @SuppressWarnings("unused") Matcher matcher = CombinableMatcher.both(equalTo("yellow")).and(notNullValue(String.class)); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java b/hamcrest/src/test/java/org/hamcrest/core/DescribedAsTest.java similarity index 93% rename from hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java rename to hamcrest/src/test/java/org/hamcrest/core/DescribedAsTest.java index 5c76af903..fcd4e868c 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/DescribedAsTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/DescribedAsTest.java @@ -1,9 +1,9 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.DescribedAs.describedAs; import static org.hamcrest.core.IsAnything.anything; import static org.hamcrest.core.IsEqual.equalTo; @@ -46,4 +46,5 @@ public final class DescribedAsTest { assertMismatchDescription("was <1>", matcher, 1); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java b/hamcrest/src/test/java/org/hamcrest/core/EveryTest.java similarity index 86% rename from hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java rename to hamcrest/src/test/java/org/hamcrest/core/EveryTest.java index e45e8813f..ac00e5bcb 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/EveryTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/EveryTest.java @@ -1,12 +1,13 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import static java.util.Arrays.asList; -import static org.hamcrest.AbstractMatcherTest.*; +import static java.util.Collections.singletonList; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.StringContains.containsString; public final class EveryTest { @@ -37,7 +38,7 @@ public final class EveryTest { @Test public void describesAMismatch() { - assertMismatchDescription("an item was \"BXB\"", matcher, asList("BXB")); + assertMismatchDescription("an item was \"BXB\"", matcher, singletonList("BXB")); } -} +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsAnythingTest.java similarity index 63% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsAnythingTest.java index 4983bf7fa..7b6aaac9d 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsAnythingTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsAnythingTest.java @@ -1,19 +1,23 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.assertDescription; -import static org.hamcrest.AbstractMatcherTest.assertMatches; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertDescription; +import static org.hamcrest.test.MatcherAssertions.assertMatches; +import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsAnything.anything; public final class IsAnythingTest { private final Matcher matcher = anything(); - private static class CustomThing { } - - @Test public void + private static class CustomThing { + } + + @Test + public void alwaysEvaluatesToTrue() { assertMatches("didn't match null", matcher, null); assertMatches("didn't match Object", matcher, new Object()); @@ -21,6 +25,11 @@ private static class CustomThing { } assertMatches("didn't match String", matcher, "hi"); } + @Test + public void compilesWithoutTypeWarnings() { + assertThat(new CustomThing(), is(anything())); + } + @Test public void hasUsefulDefaultDescription() { assertDescription("ANYTHING", matcher); diff --git a/hamcrest/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java new file mode 100644 index 000000000..a528a1ef8 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/core/IsCollectionContainingTest.java @@ -0,0 +1,110 @@ +package org.hamcrest.core; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import static java.util.Arrays.asList; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.core.IsCollectionContaining.hasItem; +import static org.hamcrest.core.IsCollectionContaining.hasItems; +import static org.hamcrest.core.IsEqual.equalTo; + +public class IsCollectionContainingTest extends AbstractMatcherTest { + + @Override + protected Matcher createMatcher() { + return hasItem(equalTo("irrelevant")); + } + + @Test + public void testMatchesACollectionThatContainsAnElementMatchingTheGivenMatcher() { + Matcher> itemMatcher = hasItem(equalTo("a")); + + assertMatches("should match list that contains 'a'", + itemMatcher, asList("a", "b", "c")); + } + + @Test + public void testDoesNotMatchCollectionThatDoesntContainAnElementMatchingTheGivenMatcher() { + final Matcher> matcher1 = hasItem(mismatchable("a")); + assertMismatchDescription("mismatches were: [mismatched: b, mismatched: c]", matcher1, asList("b", "c")); + + final Matcher> matcher2 = hasItem(equalTo("a")); + assertMismatchDescription("was empty", matcher2, new ArrayList()); + } + + @Test + public void testDoesNotMatchNull() { + assertDoesNotMatch("should not matches null", hasItem(equalTo("a")), null); + } + + @Test + public void testHasAReadableDescription() { + assertDescription("a collection containing \"a\"", hasItem(equalTo("a"))); + } + + @Test + public void testCanMatchItemWhenCollectionHoldsSuperclass() // Issue 24 + { + final Set s = new HashSet<>(); + s.add(2); + assertThat(s, new IsCollectionContaining<>(new IsEqual(2))); + assertThat(s, IsCollectionContaining.hasItem(2)); + } + + @Test + @SuppressWarnings("unchecked") + public void testMatchesAllItemsInCollection() { + final Matcher> matcher1 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("should match list containing all items", + matcher1, + asList("a", "b", "c")); + + final Matcher> matcher2 = hasItems("a", "b", "c"); + assertMatches("should match list containing all items (without matchers)", + matcher2, + asList("a", "b", "c")); + + final Matcher> matcher3 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("should match list containing all items in any order", + matcher3, + asList("c", "b", "a")); + + final Matcher> matcher4 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("should match list containing all items plus others", + matcher4, + asList("e", "c", "b", "a", "d")); + + final Matcher> matcher5 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertDoesNotMatch("should not match list unless it contains all items", + matcher5, + asList("e", "c", "b", "d")); // 'a' missing + } + + private static Matcher mismatchable(final String string) { + return new TypeSafeDiagnosingMatcher() { + @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/src/test/java/org/hamcrest/core/IsEqualTest.java similarity index 89% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsEqualTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsEqualTest.java index 9df73e4c4..f8eb1a247 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsEqualTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsEqualTest.java @@ -1,9 +1,9 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalToObject; @@ -33,7 +33,7 @@ public final class IsEqualTest { @Test public void canCompareNullValues() { final Matcher matcher = equalTo(null); - + assertMatches(matcher, null); assertDoesNotMatch(matcher, 2); assertDoesNotMatch(matcher, "hi"); @@ -77,6 +77,20 @@ public boolean equals(Object obj) { assertDoesNotMatch(matcher, null); } + @Test public void + comparesTheElementsOfArraysWithNulls() { + String[] s1 = {"a", null, "b"}; + String[] s2 = {"a", null, "b"}; + String[] s3 = {"c", "d"}; + String[] s4 = {"a", "b", "c", "d"}; + + final Matcher matcher = equalTo(s1); + assertMatches(matcher, s1); + assertMatches(matcher, s2); + assertDoesNotMatch(matcher, s3); + assertDoesNotMatch(matcher, s4); + } + @Test public void comparesTheElementsOfAnArrayOfPrimitiveTypes() { int[] i1 = new int[]{1, 2}; @@ -139,5 +153,5 @@ public String toString() { returnsGoodDescriptionIfCreatedWithNullReference() { assertDescription("null", equalTo(null)); } -} +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsInstanceOfTest.java similarity index 95% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsInstanceOfTest.java index 8dd85af1c..e7c9f60b6 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsInstanceOfTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsInstanceOfTest.java @@ -1,9 +1,9 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsInstanceOf.any; import static org.hamcrest.core.IsInstanceOf.instanceOf; @@ -61,9 +61,8 @@ public final class IsInstanceOfTest { Integer anInteger = with(any(Integer.class)); } - private static T with(@SuppressWarnings("unused") Matcher matcher) { return null; } -} +} diff --git a/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java new file mode 100644 index 000000000..a855c1793 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java @@ -0,0 +1,173 @@ +package org.hamcrest.core; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeDiagnosingMatcher; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +import static java.util.Arrays.asList; +import static java.util.Collections.singleton; +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsIterableContaining.hasItem; +import static org.hamcrest.core.IsIterableContaining.hasItems; + +public final class IsIterableContainingTest { + + @Test public void + copesWithNullsAndUnknownTypes() { + Matcher matcher = hasItem(equalTo("irrelevant")); + + assertNullSafe(matcher); + assertUnknownTypeSafe(matcher); + } + + @Test public void + matchesACollectionThatContainsAnElementForTheGivenMatcher() { + final Matcher> itemMatcher = hasItem(equalTo("a")); + + assertMatches("list containing 'a'", itemMatcher, asList("a", "b", "c")); + } + + @Test public void + doesNotMatchCollectionWithoutAnElementForGivenMatcher() { + final Matcher> matcher = hasItem(mismatchable("a")); + + assertMismatchDescription("mismatches were: [mismatched: b, mismatched: c]", matcher, asList("b", "c")); + assertMismatchDescription("was empty", matcher, new ArrayList()); + } + + @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 s = new HashSet<>(); + s.add(2); + + assertMatches(new IsIterableContaining<>(new IsEqual(2)), s); + assertMatches(IsIterableContaining.hasItem(2), s); + } + + @SuppressWarnings("unchecked") + @Test public void + matchesMultipleItemsInCollection() { + final Matcher> matcher1 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items", matcher1, asList("a", "b", "c")); + + final Matcher> matcher2 = hasItems("a", "b", "c"); + assertMatches("list containing all items (without matchers)", matcher2, asList("a", "b", "c")); + + final Matcher> matcher3 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items in any order", matcher3, asList("c", "b", "a")); + + final Matcher> matcher4 = hasItems(equalTo("a"), equalTo("b"), equalTo("c")); + assertMatches("list containing all items plus others", matcher4, asList("e", "c", "b", "a", "d")); + + final Matcher> 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> 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 mismatchable(final String string) { + return new TypeSafeDiagnosingMatcher() { + @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); + } + }; + } + + @Test public void + matchesPolymorphicTypes() { + Collection dogs = singleton(new Dog("Spot")); + Animal spotAsAnimal = new Dog("Spot"); + assertMatches(hasItem(spotAsAnimal), dogs); + Dog spotAsDog = new Dog("Spot"); + assertMatches(hasItem(spotAsDog), dogs); + + Collection animals = asList( + new Dog("Fido"), new Cat("Whiskers")); + Dog fido = new Dog("Fido"); + Matcher> dogsMatcher = hasItem(fido); + assertMatches(dogsMatcher, animals); + + Cat whiskers = new Cat("Whiskers"); + assertMatches(hasItem(whiskers), animals); + + Matcher> iterableMatcher = hasItems(fido, whiskers); + assertMatches(iterableMatcher, animals); + assertMatches(not(hasItem(spotAsAnimal)), animals); + } + + abstract static class Animal { + private final String name; + + Animal(String name) { + this.name = name; + } + + public String name() { + return this.name; + } + + @Override + public boolean equals(Object obj) { + if (obj == null) { + return false; + } + + if (getClass() != obj.getClass()) { + return false; + } + + return name.equals(((Animal) obj).name); + } + + @Override + public int hashCode() { + return name.hashCode(); + } + } + + static class Dog extends Animal { + public Dog(String name) { + super(name); + } + } + + static class Cat extends Animal { + public Cat(String name) { + super(name); + } + } +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsNotTest.java similarity index 92% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsNotTest.java index 79f468378..fe1d2d220 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsNotTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsNotTest.java @@ -1,9 +1,9 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsInstanceOf.instanceOf; import static org.hamcrest.core.IsNot.not; @@ -39,4 +39,5 @@ public final class IsNotTest { 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/src/test/java/org/hamcrest/core/IsNullTest.java similarity index 92% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsNullTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsNullTest.java index 74b046b57..c40627403 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsNullTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsNullTest.java @@ -1,13 +1,12 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsNull.notNullValue; import static org.hamcrest.core.IsNull.nullValue; - public final class IsNullTest { private final Matcher nullMatcher = nullValue(); @@ -17,7 +16,7 @@ public final class IsNullTest { copesWithNullsAndUnknownTypes() { assertNullSafe(nullMatcher); assertUnknownTypeSafe(nullMatcher); - + assertNullSafe(notNullMatcher); assertUnknownTypeSafe(notNullMatcher); } @@ -26,11 +25,11 @@ public final class IsNullTest { evaluatesToTrueIfArgumentIsNull() { assertMatches(nullMatcher, null); assertDoesNotMatch(nullMatcher, new Object()); - + assertMatches(notNullMatcher, new Object()); assertDoesNotMatch(notNullMatcher, null); } - + @Test public void supportsStaticTyping() { requiresStringMatcher(nullValue(String.class)); @@ -40,4 +39,5 @@ public final class IsNullTest { private void requiresStringMatcher(@SuppressWarnings("unused") Matcher arg) { // no-op } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsSameTest.java similarity index 93% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsSameTest.java index a4a20105d..6efa1787a 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsSameTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsSameTest.java @@ -1,19 +1,18 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsSame.sameInstance; import static org.hamcrest.core.IsSame.theInstance; - public final class IsSameTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = sameInstance("irrelevant"); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -45,4 +44,5 @@ public final class IsSameTest { returnsReadableDescriptionFromToStringWhenInitialisedWithNull() { assertDescription("sameInstance(null)", sameInstance(null)); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsTest.java similarity index 89% rename from hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java rename to hamcrest/src/test/java/org/hamcrest/core/IsTest.java index 6656e6d17..6c4a83158 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/IsTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsTest.java @@ -1,9 +1,9 @@ package org.hamcrest.core; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.Is.isA; import static org.hamcrest.core.IsEqual.equalTo; @@ -13,7 +13,7 @@ public final class IsTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = is("something"); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -35,7 +35,7 @@ public final class IsTest { @Test public void providesConvenientShortcutForIsEqualTo() { final Matcher matcher = is("A"); - + assertMatches(matcher, "A"); assertDoesNotMatch(is("A"), "B"); } @@ -43,9 +43,10 @@ public final class IsTest { @SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void providesConvenientShortcutForIsInstanceOf() { - final Matcher matcher = isA(Integer.class); + final Matcher matcher = isA(Number.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/src/test/java/org/hamcrest/core/SampleBaseClass.java similarity index 99% rename from hamcrest-core/src/test/java/org/hamcrest/core/SampleBaseClass.java rename to hamcrest/src/test/java/org/hamcrest/core/SampleBaseClass.java index baf4d8e97..39e50666c 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/SampleBaseClass.java +++ b/hamcrest/src/test/java/org/hamcrest/core/SampleBaseClass.java @@ -1,6 +1,7 @@ package org.hamcrest.core; public class SampleBaseClass { + String value; public SampleBaseClass(String value) { @@ -21,4 +22,5 @@ public boolean equals(Object obj) { public int hashCode() { return value.hashCode(); } + } diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java b/hamcrest/src/test/java/org/hamcrest/core/SampleSubClass.java similarity index 96% rename from hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java rename to hamcrest/src/test/java/org/hamcrest/core/SampleSubClass.java index bdaa160f6..0c71224c3 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/SampleSubClass.java +++ b/hamcrest/src/test/java/org/hamcrest/core/SampleSubClass.java @@ -1,7 +1,7 @@ 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/src/test/java/org/hamcrest/core/StringContainsTest.java similarity index 91% rename from hamcrest-core/src/test/java/org/hamcrest/core/StringContainsTest.java rename to hamcrest/src/test/java/org/hamcrest/core/StringContainsTest.java index 93dd05cf6..56161f8ae 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/StringContainsTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/StringContainsTest.java @@ -1,13 +1,15 @@ package org.hamcrest.core; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; 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 stringContains = containsString(EXCERPT); @@ -16,6 +18,7 @@ protected Matcher createMatcher() { return stringContains; } + @Test public void testMatchesSubstrings() { assertMatches(stringContains, EXCERPT + "END"); assertMatches(stringContains, "START" + EXCERPT); @@ -29,6 +32,7 @@ public void testMatchesSubstrings() { assertDescription("a string containing \"EXCERPT\"", stringContains); } + @Test public void testMatchesSubstringsIgnoringCase() { final Matcher ignoringCase = containsStringIgnoringCase("ExCert"); assertMatches(ignoringCase, "eXcERT" + "END"); @@ -40,4 +44,5 @@ public void testMatchesSubstringsIgnoringCase() { 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/src/test/java/org/hamcrest/core/StringEndsWithTest.java similarity index 92% rename from hamcrest-core/src/test/java/org/hamcrest/core/StringEndsWithTest.java rename to hamcrest/src/test/java/org/hamcrest/core/StringEndsWithTest.java index f482cbfa3..bfad819c6 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/StringEndsWithTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/StringEndsWithTest.java @@ -1,13 +1,15 @@ package org.hamcrest.core; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; 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 stringEndsWith = endsWith(EXCERPT); @@ -16,6 +18,7 @@ protected Matcher createMatcher() { return stringEndsWith; } + @Test public void testMatchesSubstringAtEnd() { assertDoesNotMatch(stringEndsWith, EXCERPT + "END"); assertMatches(stringEndsWith, "START" + EXCERPT); @@ -29,6 +32,7 @@ public void testMatchesSubstringAtEnd() { assertDescription("a string ending with \"EXCERPT\"", stringEndsWith); } + @Test public void testMatchesSubstringAtEndIngoringCase() { final Matcher ignoringCase = endsWithIgnoringCase("EXCERpt"); assertDoesNotMatch(ignoringCase, "eXCErpt" + "END"); diff --git a/hamcrest/src/test/java/org/hamcrest/core/StringMatchingTest.java b/hamcrest/src/test/java/org/hamcrest/core/StringMatchingTest.java new file mode 100644 index 000000000..f93afbc0e --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/core/StringMatchingTest.java @@ -0,0 +1,36 @@ +package org.hamcrest.core; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.core.StringContains.containsString; +import static org.hamcrest.core.StringEndsWith.endsWith; +import static org.hamcrest.core.StringStartsWith.startsWith; +import static org.junit.jupiter.api.Assertions.assertThrows; + +/** + * @author Steve Freeman 2016 http://www.hamcrest.com + */ +public class StringMatchingTest { + + @Test public void + startsWithFailsWithNullSubstring() { + assertThrows(IllegalArgumentException.class, () -> { + startsWith(null); + }); + } + + @Test public void + endWithFailsWithNullSubstring() { + assertThrows(IllegalArgumentException.class, () -> { + endsWith(null); + }); + } + + @Test public void + containsFailsWithNullSubstring() { + assertThrows(IllegalArgumentException.class, () -> { + containsString(null); + }); + } + +} diff --git a/hamcrest/src/test/java/org/hamcrest/core/StringRegularExpressionTest.java b/hamcrest/src/test/java/org/hamcrest/core/StringRegularExpressionTest.java new file mode 100644 index 000000000..bbd130d03 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/core/StringRegularExpressionTest.java @@ -0,0 +1,29 @@ +package org.hamcrest.core; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.core.StringRegularExpression.matchesRegex; + +/** + * @author Steve Freeman 2016 http://www.hamcrest.com + */ +public class StringRegularExpressionTest extends AbstractMatcherTest { + + public final Matcher matcher = matchesRegex("^[0-9]+$"); + + @Override + protected Matcher createMatcher() { return matcher; } + + @Test + public void testMatchingRegex() { + assertMatches(matcher, "12"); + assertDoesNotMatch(matcher, "abc"); + + assertDescription("a string matching the pattern <^[0-9]+$>", matcher); + assertMismatchDescription("the string was \"bcd\"", matcher, "bcd"); + } + +} diff --git a/hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java b/hamcrest/src/test/java/org/hamcrest/core/StringStartsWithTest.java similarity index 92% rename from hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java rename to hamcrest/src/test/java/org/hamcrest/core/StringStartsWithTest.java index f093acb4f..db698ab19 100644 --- a/hamcrest-core/src/test/java/org/hamcrest/core/StringStartsWithTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/StringStartsWithTest.java @@ -1,13 +1,15 @@ package org.hamcrest.core; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; 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 stringStartsWith = startsWith(EXCERPT); @@ -16,6 +18,7 @@ protected Matcher createMatcher() { return stringStartsWith; } + @Test public void testMatchesStringAtStart() { assertMatches(stringStartsWith, EXCERPT + "END"); assertDoesNotMatch(stringStartsWith, "START" + EXCERPT); @@ -29,6 +32,7 @@ public void testMatchesStringAtStart() { assertMismatchDescription("was \"Something else\"", stringStartsWith, "Something else"); } + @Test public void testMatchesStringAtStartIgnoringCase() { final Matcher ignoreCase = startsWithIgnoringCase("EXCerPT"); diff --git a/hamcrest/src/test/java/org/hamcrest/exception/ThrowsExceptionTest.java b/hamcrest/src/test/java/org/hamcrest/exception/ThrowsExceptionTest.java new file mode 100644 index 000000000..3fd3f51fb --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/exception/ThrowsExceptionTest.java @@ -0,0 +1,90 @@ +package org.hamcrest.exception; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.throwsExceptionWithMessage; +import static org.hamcrest.exception.ThrowsException.throwsException; +import static org.hamcrest.test.MatcherAssertions.*; + +public final class ThrowsExceptionTest { + + public static void throwIllegalArgumentException() { + throw new IllegalArgumentException("Boom!"); + } + + public static void throwNullPointerException() { + throw new NullPointerException("Boom!"); + } + + @Test + public void examples() { + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsException()); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsException(RuntimeException.class)); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsException(RuntimeException.class, "Boom!")); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsException(new IllegalArgumentException("Boom!"))); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsException(RuntimeException.class, containsString("Boo"))); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsExceptionWithMessage("Boom!")); + assertThat(ThrowsExceptionTest::throwIllegalArgumentException, throwsExceptionWithMessage(containsString("Boo"))); + } + + @Test + public void evaluatesToTrueIfRunnableThrowsExpectedExceptionWithMatchingMessage() { + assertMatches( + throwsException(IllegalArgumentException.class, "Boom!"), + ThrowsExceptionTest::throwIllegalArgumentException + ); + + assertDescription( + "a runnable throwing an instance of java.lang.IllegalArgumentException with message \"Boom!\"", + throwsException(IllegalArgumentException.class, "Boom!") + ); + + assertMismatchDescription( + "thrown exception message was \"Boom!\"", + throwsException(IllegalArgumentException.class, "Bang!"), + (Runnable) ThrowsExceptionTest::throwIllegalArgumentException + ); + + assertMismatchDescription( + "thrown exception class was java.lang.NullPointerException", + throwsException(IllegalArgumentException.class, "Boom!"), + (Runnable) ThrowsExceptionTest::throwNullPointerException + ); + + assertMismatchDescription( + "the runnable didn't throw", + throwsException(IllegalArgumentException.class, "Boom!"), + (Runnable) () -> { + } + ); + } + + @Test + public void evaluatesToTrueIfRunnableThrowsExceptionExtendingTheExpectedExceptionWithMatchingMessage() { + assertMatches( + throwsException(IllegalArgumentException.class, "Boom!"), + ThrowsExceptionTest::throwIllegalArgumentException + ); + } + + @Test + public void evaluatesToTrueIfRunnableThrowsExceptionWithMatchingMessage() { + assertMatches( + throwsException(IllegalArgumentException.class, containsString("Boo")), + ThrowsExceptionTest::throwIllegalArgumentException + ); + + assertDescription( + "a runnable throwing an instance of java.lang.IllegalArgumentException with message a string containing \"Boo\"", + throwsException(IllegalArgumentException.class, containsString("Boo")) + ); + + assertMismatchDescription( + "thrown exception class was java.lang.NullPointerException", + throwsException(IllegalArgumentException.class, containsString("Boo")), + (Runnable) ThrowsExceptionTest::throwNullPointerException + ); + } +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/io/FileMatchersTest.java b/hamcrest/src/test/java/org/hamcrest/io/FileMatchersTest.java similarity index 75% rename from hamcrest-library/src/test/java/org/hamcrest/io/FileMatchersTest.java rename to hamcrest/src/test/java/org/hamcrest/io/FileMatchersTest.java index b186549d8..0bdd71fb0 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/io/FileMatchersTest.java +++ b/hamcrest/src/test/java/org/hamcrest/io/FileMatchersTest.java @@ -1,11 +1,17 @@ package org.hamcrest.io; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsEqual.equalTo; +import static org.junit.jupiter.api.Assertions.assertTrue; @SuppressWarnings("ResultOfMethodCallIgnored") public class FileMatchersTest extends AbstractMatcherTest { @@ -13,75 +19,79 @@ public class FileMatchersTest extends AbstractMatcherTest { private File directory; private File file; - @Override - protected void setUp() throws Exception { - directory = File.createTempFile("myDir", ""); - directory.delete(); - directory.mkdirs(); - + @BeforeEach + protected void setUp() throws IOException { + directory = Files.createTempDirectory("myDir").toFile(); file = new File(directory, "myFile"); file.createNewFile(); } - + + @Test public void testAnExistingDirectory() { assertMatches("matches existing directory", FileMatchers.anExistingDirectory(), directory); assertDoesNotMatch("doesn't match existing file", FileMatchers.anExistingDirectory(), file); - assertDoesNotMatch("doesn't match missing file", FileMatchers.anExistingDirectory(), new File("foo")); + assertMismatchDescription("'foo' is not a directory", FileMatchers.anExistingDirectory(), new File("foo")); } + @Test public void testAnExistingFileOrDirectory() { assertMatches("matches existing file", FileMatchers.anExistingFileOrDirectory(), file); assertMatches("matches existing directory", FileMatchers.anExistingFileOrDirectory(), directory); - assertDoesNotMatch("doesn't match missing file", FileMatchers.anExistingFileOrDirectory(), new File("foo")); + assertMismatchDescription("'foo' does not exist", FileMatchers.anExistingFileOrDirectory(), new File("foo")); } + @Test public void testAnExistingFile() { assertMatches("matches existing file", FileMatchers.anExistingFile(), file); assertDoesNotMatch("doesn't match existing directory", FileMatchers.anExistingFile(), directory); - assertDoesNotMatch("doesn't match missing file", FileMatchers.anExistingFile(), new File("foo")); + assertMismatchDescription("'foo' is not a file", FileMatchers.anExistingFile(), new File("foo")); } - public void testAReadableFile() { + @Test + public void testAReadableFile() { // Not all OSes will allow setting readability so have to be forgiving here. file.setReadable(true); assertMatches("matches readable file", FileMatchers.aReadableFile(), file); + if (file.setReadable(false)) { assertDoesNotMatch("doesn't match unreadable file", FileMatchers.aReadableFile(), file); } } + @Test public void testAWritableFile() { assertMatches("matches writable file", FileMatchers.aWritableFile(), file); - file.setWritable(false); + + assertTrue(file.setWritable(false), "set writable off " + file); assertDoesNotMatch("doesn't match unwritable file", FileMatchers.aWritableFile(), file); } + @Test public void testAFileWithSizeLong() { assertMatches("matches file size", FileMatchers.aFileWithSize(0L), file); - file.setWritable(false); assertDoesNotMatch("doesn't match incorrect file size", FileMatchers.aFileWithSize(34L), file); } + @Test public void testAFileWithSizeMatcherOfLong() { assertMatches("matches file size", FileMatchers.aFileWithSize(equalTo(0L)), file); - file.setWritable(false); assertDoesNotMatch("doesn't match incorrect file size", FileMatchers.aFileWithSize(equalTo(23L)), file); } + @Test public void testAFileNamed() { assertMatches("matches file name", FileMatchers.aFileNamed(equalTo(file.getName())), file); - file.setWritable(false); assertDoesNotMatch("doesn't match incorrect file name", FileMatchers.aFileNamed(equalTo("foo")), file); } + @Test public void testAFileWithCanonicalPath() throws Exception { assertMatches("matches file canonical path", FileMatchers.aFileWithCanonicalPath(equalTo(file.getCanonicalPath())), file); - file.setWritable(false); assertDoesNotMatch("doesn't match incorrect canonical path", FileMatchers.aFileWithCanonicalPath(equalTo("foo")), file); } + @Test public void testAFileWithAbsolutePath() { assertMatches("matches file absolute path", FileMatchers.aFileWithAbsolutePath(equalTo(file.getAbsolutePath())), file); - file.setWritable(false); assertDoesNotMatch("doesn't match incorrect absolute path", FileMatchers.aFileWithAbsolutePath(equalTo("foo")), file); } diff --git a/hamcrest-library/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java b/hamcrest/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java similarity index 89% rename from hamcrest-library/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java rename to hamcrest/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java index c82e6f4e3..83bed3fe7 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java +++ b/hamcrest/src/test/java/org/hamcrest/number/BigDecimalCloseToTest.java @@ -1,13 +1,17 @@ package org.hamcrest.number; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.number.BigDecimalCloseTo.closeTo; +import static org.junit.jupiter.api.Assertions.assertTrue; public class BigDecimalCloseToTest extends AbstractMatcherTest { + private final Matcher matcher = closeTo(new BigDecimal("1.0"), new BigDecimal("0.5")); @Override @@ -15,7 +19,8 @@ protected Matcher createMatcher() { BigDecimal irrelevant = new BigDecimal("0.01"); return closeTo(irrelevant, irrelevant); } - + + @Test public void testEvaluatesToTrueIfArgumentIsEqualToABigDecimalWithinSomeError() { assertTrue(matcher.matches(new BigDecimal("1.0"))); assertTrue(matcher.matches(new BigDecimal("0.5"))); @@ -26,7 +31,8 @@ public void testEvaluatesToTrueIfArgumentIsEqualToABigDecimalWithinSomeError() { assertDoesNotMatch("number too small", matcher, new BigDecimal("0.0")); assertMismatchDescription("<0.0> differed by <0.5> more than delta <0.5>", matcher, new BigDecimal("0.0")); } - + + @Test public void testEvaluatesToTrueIfArgumentHasDifferentScale() { assertTrue(matcher.matches(new BigDecimal("1.000000"))); assertTrue(matcher.matches(new BigDecimal("0.500000"))); @@ -38,6 +44,7 @@ public void testEvaluatesToTrueIfArgumentHasDifferentScale() { assertMismatchDescription("<0.000000> differed by <0.5> more than delta <0.5>", matcher, new BigDecimal("0.000000")); } + @Test public void test_is_self_describing() { assertDescription("a numeric value within <0.5> of <1.0>", matcher); } diff --git a/hamcrest-library/src/test/java/org/hamcrest/number/IsCloseToTest.java b/hamcrest/src/test/java/org/hamcrest/number/IsCloseToTest.java similarity index 87% rename from hamcrest-library/src/test/java/org/hamcrest/number/IsCloseToTest.java rename to hamcrest/src/test/java/org/hamcrest/number/IsCloseToTest.java index 8b0e244b4..4f90490e8 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/number/IsCloseToTest.java +++ b/hamcrest/src/test/java/org/hamcrest/number/IsCloseToTest.java @@ -1,11 +1,14 @@ package org.hamcrest.number; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.number.IsCloseTo.closeTo; public class IsCloseToTest extends AbstractMatcherTest { + private final Matcher matcher = closeTo(1.0d, 0.5d); @Override @@ -14,6 +17,7 @@ protected Matcher createMatcher() { return closeTo(irrelevant, irrelevant); } + @Test public void test_matchesIfArgumentIsEqualToADoubleValueWithinSomeError() { assertMatches("1.0", matcher, 1.0); assertMatches("0.5d", matcher, 0.5d); @@ -25,6 +29,7 @@ public void test_matchesIfArgumentIsEqualToADoubleValueWithinSomeError() { assertMismatchDescription("<0.1> differed by <0.4> more than delta <0.5>", matcher, 0.1); } + @Test public void test_is_self_describing() { assertDescription("a numeric value within <0.5> of <1.0>", matcher); } diff --git a/hamcrest-library/src/test/java/org/hamcrest/number/IsNanTest.java b/hamcrest/src/test/java/org/hamcrest/number/IsNanTest.java similarity index 91% rename from hamcrest-library/src/test/java/org/hamcrest/number/IsNanTest.java rename to hamcrest/src/test/java/org/hamcrest/number/IsNanTest.java index c9b39568d..5787286fa 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/number/IsNanTest.java +++ b/hamcrest/src/test/java/org/hamcrest/number/IsNanTest.java @@ -1,9 +1,9 @@ package org.hamcrest.number; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.number.IsNaN.notANumber; public final class IsNanTest { @@ -11,7 +11,7 @@ public final class IsNanTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = notANumber(); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -40,4 +40,5 @@ public final class IsNanTest { describesAMismatch() { assertMismatchDescription("was <1.25>", notANumber(), 1.25); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/number/OrderingComparisonTest.java b/hamcrest/src/test/java/org/hamcrest/number/OrderingComparisonTest.java similarity index 89% rename from hamcrest-library/src/test/java/org/hamcrest/number/OrderingComparisonTest.java rename to hamcrest/src/test/java/org/hamcrest/number/OrderingComparisonTest.java index 5953bd0bf..60150c1a1 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/number/OrderingComparisonTest.java +++ b/hamcrest/src/test/java/org/hamcrest/number/OrderingComparisonTest.java @@ -1,11 +1,14 @@ package org.hamcrest.number; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertDescription; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; import static org.hamcrest.core.IsNot.not; import static org.hamcrest.number.OrderingComparison.*; @@ -16,6 +19,7 @@ protected Matcher createMatcher() { return greaterThan(1); } + @Test public void testDescription() { assertDescription("a value greater than <1>", greaterThan(1)); assertDescription("a value equal to or greater than <1>", greaterThanOrEqualTo(1)); @@ -24,6 +28,7 @@ public void testDescription() { assertDescription("a value less than <1>", lessThan(1)); } + @Test public void testMismatchDescriptions() { assertMismatchDescription("<0> was less than <1>", greaterThan(1), 0); assertMismatchDescription("<1> was equal to <1>", greaterThan(1), 1); @@ -31,38 +36,44 @@ public void testMismatchDescriptions() { assertMismatchDescription("<2> was equal to <2>", lessThan(2), 2); } + @Test public void testComparesObjectsForGreaterThan() { assertThat(2, greaterThan(1)); assertThat(0, not(greaterThan(1))); } + @Test public void testComparesObjectsForLessThan() { assertThat(2, lessThan(3)); assertThat(0, lessThan(1)); } - + @Test public void testComparesObjectsForEquality() { assertThat(3, comparesEqualTo(3)); assertThat("aa", comparesEqualTo("aa")); } + @Test public void testAllowsForInclusiveComparisons() { assertThat("less", 1, lessThanOrEqualTo(1)); assertThat("greater", 1, greaterThanOrEqualTo(1)); } + @Test public void testSupportsDifferentTypesOfComparableObjects() { assertThat(1.1, greaterThan(1.0)); assertThat("cc", greaterThan("bb")); } + @Test public void testComparesBigDecimalsWithDifferentScalesCorrectlyForIssue20() { assertThat(new BigDecimal("10.0"), greaterThanOrEqualTo(new BigDecimal("10"))); assertThat(new BigDecimal(10), greaterThanOrEqualTo(new BigDecimal("10.0"))); assertThat(new BigDecimal("2"), comparesEqualTo(new BigDecimal("2.000"))); } - + + @Test public void testComparesCustomTypesWhoseCompareToReturnsValuesGreaterThatOne() { assertThat(new CustomInt(5), lessThan(new CustomInt(10))); } @@ -77,4 +88,5 @@ public int compareTo(CustomInt other) { return value - other.value; } } + } diff --git a/hamcrest/src/test/java/org/hamcrest/object/HasEqualsValuesTest.java b/hamcrest/src/test/java/org/hamcrest/object/HasEqualsValuesTest.java new file mode 100644 index 000000000..9a56394a5 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/object/HasEqualsValuesTest.java @@ -0,0 +1,65 @@ +package org.hamcrest.object; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; + +@SuppressWarnings("WeakerAccess") +public class HasEqualsValuesTest extends AbstractMatcherTest { + + private static final WithPublicFields WITH_PUBLIC_FIELDS = new WithPublicFields('x', 666, "a string"); + private static final HasEqualValues WITH_PUBLIC_FIELDS_MATCHER = new HasEqualValues<>(WITH_PUBLIC_FIELDS); + + @Override + protected Matcher createMatcher() { + return WITH_PUBLIC_FIELDS_MATCHER; + } + + @Test + public void test_describes_itself() { + assertDescription( + "WithPublicFields has values [i: <666>, s: \"a string\", c: \"x\"]", + WITH_PUBLIC_FIELDS_MATCHER); + } + + @Test + public void test_matches_equivalent_object() { + assertMatches(WITH_PUBLIC_FIELDS_MATCHER, new WithPublicFields('x', 666, "a string")); + } + + @Test + public void test_mismatches_on_first_field_inequality() { + assertMismatchDescription( + "'s' was \"different\"", + WITH_PUBLIC_FIELDS_MATCHER, new WithPublicFields('x', 666, "different")); + } + + @Test + public void test_mismatches_on_inherited_field() { + assertMismatchDescription( + "'c' was \"y\"", + WITH_PUBLIC_FIELDS_MATCHER, new WithPublicFields('y', 666, "a string")); + } + + public static class WithPublicFields extends Parent { + public final int i; + public final String s; + + public WithPublicFields(char c, int i, String s) { + super(c); + this.i = i; + this.s = s; + } + } + + public static class Parent { + public final char c; + + public Parent(char c) { + this.c = c; + } + } + +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/object/HasToStringTest.java b/hamcrest/src/test/java/org/hamcrest/object/HasToStringTest.java similarity index 61% rename from hamcrest-library/src/test/java/org/hamcrest/object/HasToStringTest.java rename to hamcrest/src/test/java/org/hamcrest/object/HasToStringTest.java index 5c75ae7d9..be03ef3ab 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/object/HasToStringTest.java +++ b/hamcrest/src/test/java/org/hamcrest/object/HasToStringTest.java @@ -1,13 +1,14 @@ package org.hamcrest.object; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.object.HasToString.hasToString; public final class HasToStringTest { + private static final String TO_STRING_RESULT = "toString result"; private static final Object TEST_OBJECT = new Object() { @Override @@ -19,37 +20,38 @@ public String toString() { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = hasToString(equalTo("irrelevant")); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } - + @Test public void matchesWhenUtilisingANestedMatcher() { - final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); + final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); - assertMatches(matcher, TEST_OBJECT); - assertDoesNotMatch(matcher, new Object()); + assertMatches(matcher, TEST_OBJECT); + assertDoesNotMatch(matcher, new Object()); } @Test public void matchesWhenUsingShortcutForHasToStringEqualTo() { - final Matcher matcher = hasToString(TO_STRING_RESULT); - - assertMatches(matcher, TEST_OBJECT); - assertDoesNotMatch(matcher, new Object()); + final Matcher matcher = hasToString(TO_STRING_RESULT); + + assertMatches(matcher, TEST_OBJECT); + assertDoesNotMatch(matcher, new Object()); } @Test public void describesItself() { - final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); + final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); assertDescription("with toString() \"toString result\"", matcher); } @Test public void describesAMismatch() { - final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); - String expectedMismatchString = "toString() was \"Cheese\""; + final Matcher matcher = hasToString(equalTo(TO_STRING_RESULT)); + String expectedMismatchString = "toString() was \"Cheese\""; assertMismatchDescription(expectedMismatchString, matcher, "Cheese"); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java b/hamcrest/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java similarity index 69% rename from hamcrest-library/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java rename to hamcrest/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java index 8432fdb56..0098363ef 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java +++ b/hamcrest/src/test/java/org/hamcrest/object/IsCompatibleTypeTest.java @@ -1,25 +1,28 @@ package org.hamcrest.object; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertDescription; import static org.hamcrest.object.IsCompatibleType.typeCompatibleWith; public class IsCompatibleTypeTest extends AbstractMatcherTest { - public static class BaseClass { + + static class BaseClass { } - public static class ExtendedClass extends BaseClass { + private static class ExtendedClass extends BaseClass { } - public interface BaseInterface { + interface BaseInterface { } - public interface ExtendedInterface extends BaseInterface { + interface ExtendedInterface extends BaseInterface { } - public static class ClassImplementingBaseInterface implements BaseInterface { + private static class ClassImplementingBaseInterface implements BaseInterface { } @Override @@ -27,32 +30,34 @@ protected Matcher createMatcher() { return typeCompatibleWith(BaseClass.class); } + @Test public void testMatchesSameClass() { assertThat(BaseClass.class, typeCompatibleWith(BaseClass.class)); } + @Test public void testMatchesSameInterface() { assertThat(BaseInterface.class, typeCompatibleWith(BaseInterface.class)); } + @Test public void testMatchesExtendedClass() { assertThat(ExtendedClass.class, typeCompatibleWith(BaseClass.class)); } + @Test public void testMatchesClassImplementingInterface() { assertThat(ClassImplementingBaseInterface.class, typeCompatibleWith(BaseInterface.class)); } + @Test public void testMatchesExtendedInterface() { assertThat(ExtendedInterface.class, typeCompatibleWith(BaseInterface.class)); } -// public void testDoesNotMatchIncompatibleTypes() { -// assertThat(BaseClass.class, not(compatibleType(ExtendedClass.class))); -// assertThat(Integer.class, not(compatibleType(String.class))); -// } - + @Test public void testHasReadableDescription() { assertDescription("type < java.lang.Runnable", typeCompatibleWith(Runnable.class)); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/object/IsEventFromTest.java b/hamcrest/src/test/java/org/hamcrest/object/IsEventFromTest.java similarity index 90% rename from hamcrest-library/src/test/java/org/hamcrest/object/IsEventFromTest.java rename to hamcrest/src/test/java/org/hamcrest/object/IsEventFromTest.java index b3c4a3a5a..0a5f029ce 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/object/IsEventFromTest.java +++ b/hamcrest/src/test/java/org/hamcrest/object/IsEventFromTest.java @@ -1,14 +1,15 @@ package org.hamcrest.object; -import org.hamcrest.AbstractMatcherTest; +import org.hamcrest.test.AbstractMatcherTest; import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; import java.util.EventObject; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; import static org.hamcrest.object.IsEventFrom.eventFrom; - public class IsEventFromTest extends AbstractMatcherTest { @Override @@ -16,6 +17,7 @@ protected Matcher createMatcher() { return eventFrom(null); } + @Test public void testEvaluatesToTrueIfArgumentIsAnEventObjectFiredByASpecifiedSource() { Object o = "Source"; EventObject ev = new EventObject(o); @@ -35,6 +37,7 @@ public DerivedEvent(Object source) { } } + @Test public void testCanTestForSpecificEventClasses() { Object o = new Object(); DerivedEvent goodEv = new DerivedEvent(o); @@ -49,4 +52,5 @@ public void testCanTestForSpecificEventClasses() { assertMismatchDescription("item type was java.util.EventObject", isEventMatcher, wrongType); assertMismatchDescription("item type was java.util.EventObject", isEventMatcher, wrongSourceAndType); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/object/MatchesPatternTest.java b/hamcrest/src/test/java/org/hamcrest/object/MatchesPatternTest.java similarity index 92% rename from hamcrest-library/src/test/java/org/hamcrest/object/MatchesPatternTest.java rename to hamcrest/src/test/java/org/hamcrest/object/MatchesPatternTest.java index 3e2d9114e..14cd63b86 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/object/MatchesPatternTest.java +++ b/hamcrest/src/test/java/org/hamcrest/object/MatchesPatternTest.java @@ -2,14 +2,15 @@ import org.hamcrest.Matcher; import org.hamcrest.text.MatchesPattern; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.regex.Pattern; -import static org.hamcrest.AbstractMatcherTest.*; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.test.MatcherAssertions.*; public class MatchesPatternTest { + @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = new MatchesPattern(Pattern.compile(".")); @@ -56,4 +57,5 @@ public void factoryMethodAllowsCreationWithString() { Matcher m = MatchesPattern.matchesPattern("a[bc](d|e)"); assertDescription("a string matching the pattern 'a[bc](d|e)'", m ); } + } diff --git a/hamcrest/src/test/java/org/hamcrest/optional/OptionalMatchersTest.java b/hamcrest/src/test/java/org/hamcrest/optional/OptionalMatchersTest.java new file mode 100644 index 000000000..3af6309c9 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/optional/OptionalMatchersTest.java @@ -0,0 +1,103 @@ +package org.hamcrest.optional; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.optional.OptionalEmpty.emptyOptional; +import static org.hamcrest.optional.OptionalWithValue.optionalWithValue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Optional; + +import org.junit.jupiter.api.Test; + +public class OptionalMatchersTest { + + @Test + public void checkEmptyOptional() { + assertThat(Optional.empty(), is(emptyOptional())); + assertThat(Optional.of(1), not(emptyOptional())); + } + + @Test + public void checkEmptyOptionalFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.of(1), emptyOptional()); + }); + assertEquals("\n" + + "Expected: empty\n" + + " but: is Optional[1]", failure.getMessage()); + } + + @Test + public void checkEmptyOptionalIsFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.of(1), is(emptyOptional())); + }); + assertEquals("\n" + + "Expected: is empty\n" + + " but: is Optional[1]", failure.getMessage()); + } + + @Test + public void checkEmptyOptionalIsNotFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.empty(), is(not(emptyOptional()))); + }); + assertEquals("\n" + + "Expected: is not empty\n" + + " but: was ", failure.getMessage()); + } + + @Test + public void checkWithValue() { + assertThat(Optional.empty(), not(optionalWithValue())); + assertThat(Optional.of(1), is(optionalWithValue())); + } + + @Test + public void checkWithMatchingValue() { + assertThat(Optional.empty(), not(optionalWithValue(equalTo(1)))); + assertThat(Optional.of(1), is(optionalWithValue(equalTo(1)))); + assertThat(Optional.of(1), not(optionalWithValue(equalTo(1L)))); + } + + @Test + public void checkWithLiteralValue() { + assertThat(Optional.empty(), not(optionalWithValue(1))); + assertThat(Optional.of(1), is(optionalWithValue(1))); + assertThat(Optional.of(1), not(optionalWithValue(1L))); + } + + @Test + public void checkWithValueFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.empty(), is(optionalWithValue())); + }); + assertEquals("\n" + + "Expected: is present and matches any\n" + + " but: is Optional.empty", failure.getMessage()); + } + + @Test + public void checkWithMatchingValueFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.empty(), is(optionalWithValue(equalTo(1)))); + }); + assertEquals("\n" + + "Expected: is present and matches <1>\n" + + " but: is Optional.empty", failure.getMessage()); + } + + @Test + public void checkWithLiteralValueFailure() { + AssertionError failure = assertThrows(AssertionError.class, () -> { + assertThat(Optional.of("text"), is(optionalWithValue("Hello, world"))); + }); + assertEquals("\n" + + "Expected: is present and matches \"Hello, world\"\n" + + " but: is Optional[text]", failure.getMessage()); + } +} diff --git a/hamcrest/src/test/java/org/hamcrest/test/AbstractMatcherTest.java b/hamcrest/src/test/java/org/hamcrest/test/AbstractMatcherTest.java new file mode 100644 index 000000000..4e25cc79a --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/test/AbstractMatcherTest.java @@ -0,0 +1,23 @@ +package org.hamcrest.test; + +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.assertNullSafe; + +public abstract class AbstractMatcherTest { + /** + * Create an instance of the Matcher so some generic safety-net tests can be run on it. + */ + protected abstract Matcher createMatcher(); + + @Test + public void testIsNullSafe() { + assertNullSafe(createMatcher()); + } + + @Test + public void testCopesWithUnknownTypes() { + createMatcher().matches(new UnknownType()); + } +} diff --git a/hamcrest/src/test/java/org/hamcrest/test/MatcherAssertions.java b/hamcrest/src/test/java/org/hamcrest/test/MatcherAssertions.java new file mode 100644 index 000000000..fc974d18f --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/test/MatcherAssertions.java @@ -0,0 +1,65 @@ +package org.hamcrest.test; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.StringDescription; + +import static org.junit.jupiter.api.Assertions.*; + +public interface MatcherAssertions { + + static void assertMatches(Matcher matcher, T arg) { + assertMatches("Expected match, but mismatched", matcher, arg); + } + + static void assertMatches(String message, Matcher matcher, Object arg) { + if (!matcher.matches(arg)) { + fail(message + " because: '" + mismatchDescription(matcher, arg) + "'"); + } + } + + static void assertDoesNotMatch(Matcher c, T arg) { + assertDoesNotMatch("Unexpected match", c, arg); + } + + static void assertDoesNotMatch(String message, Matcher c, T arg) { + assertFalse(c.matches(arg), message); + } + + static void assertDescription(String expected, Matcher matcher) { + Description description = new StringDescription(); + description.appendDescriptionOf(matcher); + assertEquals(expected, description.toString().trim(), "Expected description"); + } + + static void assertMismatchDescription(String expected, Matcher matcher, Object arg) { + assertFalse(matcher.matches(arg), "Precondition: Matcher should not match item."); + assertEquals(expected, mismatchDescription(matcher, arg), "Expected mismatch description"); + } + + static void assertNullSafe(Matcher matcher) { + try { + matcher.matches(null); + } catch (Exception e) { + fail("Matcher was not null safe"); + } + } + + static void assertUnknownTypeSafe(Matcher matcher) { + try { + matcher.matches(new UnknownType()); + } catch (Exception e) { + fail("Matcher was not unknown type safe, because: " + e); + } + } + + static String mismatchDescription(Matcher matcher, Object arg) { + Description description = new StringDescription(); + matcher.describeMismatch(arg, description); + return description.toString().trim(); + } +} + +@SuppressWarnings("WeakerAccess") +class UnknownType { +} diff --git a/hamcrest/src/test/java/org/hamcrest/text/CharSequenceLengthTest.java b/hamcrest/src/test/java/org/hamcrest/text/CharSequenceLengthTest.java new file mode 100644 index 000000000..c838dd317 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/text/CharSequenceLengthTest.java @@ -0,0 +1,42 @@ +package org.hamcrest.text; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.assertMatches; +import static org.hamcrest.test.MatcherAssertions.assertMismatchDescription; +import static org.hamcrest.number.OrderingComparison.lessThan; +import static org.hamcrest.text.CharSequenceLength.hasLength; + +/** + * @author Marco Leichsenring + * @author Steve Freeman + */ +public class CharSequenceLengthTest extends AbstractMatcherTest { + + @Override + protected Matcher createMatcher() { + return hasLength(4); + } + + @Test + public void test_matchesExactLengthOf_CharSequence() { + final Matcher matcher = hasLength(4); + assertMatches(matcher, "aaaa"); + assertMatches(matcher, "a b "); + + assertMismatchDescription("length was <6>", matcher, "aaaaaa"); + } + + @Test + public void test_matchesRelativeLengthOf_CharSequence() { + final Matcher matcher = hasLength(lessThan(4)); + assertMatches(matcher, "aaa"); + assertMatches(matcher, "a b"); + + assertMismatchDescription("length <4> was equal to <4>", matcher, "aaaa"); + assertMismatchDescription("length <5> was greater than <4>", matcher, "aaaaa"); + } + +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/text/IsBlankStringTest.java b/hamcrest/src/test/java/org/hamcrest/text/IsBlankStringTest.java similarity index 94% rename from hamcrest-library/src/test/java/org/hamcrest/text/IsBlankStringTest.java rename to hamcrest/src/test/java/org/hamcrest/text/IsBlankStringTest.java index c5f35f1cc..198e6d5db 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/text/IsBlankStringTest.java +++ b/hamcrest/src/test/java/org/hamcrest/text/IsBlankStringTest.java @@ -1,9 +1,9 @@ package org.hamcrest.text; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.text.IsBlankString.blankOrNullString; import static org.hamcrest.text.IsBlankString.blankString; @@ -12,7 +12,7 @@ public final class IsBlankStringTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = blankString(); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -52,4 +52,5 @@ public final class IsBlankStringTest { assertMismatchDescription("was \"a\"", blankString(), "a"); assertMismatchDescription("was \"a\"", blankOrNullString(), "a"); } + } diff --git a/hamcrest-library/src/test/java/org/hamcrest/text/IsEmptyStringTest.java b/hamcrest/src/test/java/org/hamcrest/text/IsEmptyStringTest.java similarity index 94% rename from hamcrest-library/src/test/java/org/hamcrest/text/IsEmptyStringTest.java rename to hamcrest/src/test/java/org/hamcrest/text/IsEmptyStringTest.java index 62e30535b..56b3abac0 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/text/IsEmptyStringTest.java +++ b/hamcrest/src/test/java/org/hamcrest/text/IsEmptyStringTest.java @@ -1,9 +1,9 @@ package org.hamcrest.text; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.text.IsEmptyString.emptyOrNullString; import static org.hamcrest.text.IsEmptyString.emptyString; @@ -12,7 +12,7 @@ public final class IsEmptyStringTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = emptyString(); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -52,4 +52,5 @@ public final class IsEmptyStringTest { assertMismatchDescription("was \"a\"", emptyString(), "a"); assertMismatchDescription("was \"a\"", emptyOrNullString(), "a"); } + } diff --git a/hamcrest/src/test/java/org/hamcrest/text/IsEqualCompressingWhiteSpaceTest.java b/hamcrest/src/test/java/org/hamcrest/text/IsEqualCompressingWhiteSpaceTest.java new file mode 100644 index 000000000..02f1e1e79 --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/text/IsEqualCompressingWhiteSpaceTest.java @@ -0,0 +1,58 @@ +package org.hamcrest.text; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.text.IsEqualCompressingWhiteSpace.equalToCompressingWhiteSpace; + +public class IsEqualCompressingWhiteSpaceTest extends AbstractMatcherTest { + + private final Matcher matcher = equalToCompressingWhiteSpace(" Hello World how\n are we? "); + + @Override + protected Matcher createMatcher() { + return matcher; + } + + @Test + public void testPassesIfWordsAreSameButWhitespaceDiffers() { + assertMatches(matcher, "Hello World how are we?"); + assertMatches(matcher, " Hello World how are \n\n\twe?"); + } + + @Test + public void testFailsIfTextOtherThanWhitespaceDiffers() { + assertDoesNotMatch(matcher, "Hello PLANET how are we?"); + assertDoesNotMatch(matcher, "Hello World how are we"); + } + + @Test + public void testFailsIfWhitespaceIsAddedOrRemovedInMidWord() { + assertDoesNotMatch(matcher, "HelloWorld how are we?"); + assertDoesNotMatch(matcher, "Hello Wo rld how are we?"); + } + + @Test + public void test_has_a_readable_mismatch() { + assertMismatchDescription("was \"Hello World how are we \"", matcher, "Hello World how are we "); + } + + @Test + public void testFailsIfMatchingAgainstNull() { + assertDoesNotMatch(matcher, null); + } + + @Test + public void testHasAReadableDescription() { + assertDescription("a string equal to \" Hello World how\\n are we? \" compressing white space", + matcher); + } + + @Test + public void testPassesIfWhitespacesContainsNoBreakSpace() { + assertMatches(matcher, "Hello" + ((char)160) + "World how are we?"); + } + +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java b/hamcrest/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java similarity index 51% rename from hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java rename to hamcrest/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java index 4800f4335..02dfd9a99 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java +++ b/hamcrest/src/test/java/org/hamcrest/text/IsEqualIgnoringCaseTest.java @@ -1,9 +1,10 @@ package org.hamcrest.text; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase; public final class IsEqualIgnoringCaseTest { @@ -11,7 +12,7 @@ public final class IsEqualIgnoringCaseTest { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = equalToIgnoringCase("irrelevant"); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -19,44 +20,46 @@ public final class IsEqualIgnoringCaseTest { @Test public void ignoresCaseOfCharsInString() { final Matcher matcher = equalToIgnoringCase("heLLo"); - + assertMatches(matcher, "HELLO"); assertMatches(matcher, "hello"); assertMatches(matcher, "HelLo"); - assertDoesNotMatch(matcher, "bye"); + assertDoesNotMatch(matcher, "bye"); } - @Test public void + @Test public void mismatchesIfAdditionalWhitespaceIsPresent() { - final Matcher matcher = equalToIgnoringCase("heLLo"); - - assertDoesNotMatch(matcher, "hello "); - assertDoesNotMatch(matcher, " hello"); + final Matcher matcher = equalToIgnoringCase("heLLo"); + + assertDoesNotMatch(matcher, "hello "); + assertDoesNotMatch(matcher, " hello"); } - @Test public void + @Test public void mismatchesNull() { - final Matcher matcher = equalToIgnoringCase("heLLo"); - - assertDoesNotMatch(matcher, null); + final Matcher matcher = equalToIgnoringCase("heLLo"); + + assertDoesNotMatch(matcher, null); } - @Test(expected=IllegalArgumentException.class) public void + @Test public void canOnlyBeConstructedAboutANonNullString() { - equalToIgnoringCase(null); + Assertions.assertThrows(IllegalArgumentException.class, () -> { + equalToIgnoringCase(null); + }); } - @Test public void describesItself() { - final Matcher matcher = equalToIgnoringCase("heLLo"); - assertDescription("equalToIgnoringCase(\"heLLo\")", matcher); + final Matcher matcher = equalToIgnoringCase("heLLo"); + assertDescription("a string equal to \"heLLo\" ignoring case", matcher); } @Test public void describesAMismatch() { - final Matcher matcher = equalToIgnoringCase("heLLo"); - String expectedMismatchString = "was \"Cheese\""; + final Matcher matcher = equalToIgnoringCase("heLLo"); + String expectedMismatchString = "was \"Cheese\""; assertMismatchDescription(expectedMismatchString, matcher, "Cheese"); } + } diff --git a/hamcrest/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java b/hamcrest/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java new file mode 100644 index 000000000..8fcae26eb --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/text/StringContainsInOrderTest.java @@ -0,0 +1,38 @@ +package org.hamcrest.text; + +import org.hamcrest.test.AbstractMatcherTest; +import org.hamcrest.Matcher; +import org.junit.jupiter.api.Test; + +import static java.util.Arrays.asList; +import static org.hamcrest.test.MatcherAssertions.*; +import static org.hamcrest.text.StringContainsInOrder.stringContainsInOrder; + +public class StringContainsInOrderTest extends AbstractMatcherTest { + + final StringContainsInOrder matcher = new StringContainsInOrder(asList("a", "b", "c", "c")); + + @Override + protected Matcher createMatcher() { + return matcher; + } + + @Test + public void testMatchesOnlyIfStringContainsGivenSubstringsInTheSameOrder() { + assertMatches("substrings in order", matcher, "abcc"); + assertMatches("substrings separated", matcher, "1a2b3c4c5"); + + assertDoesNotMatch("can detect repeated strings for matching", stringContainsInOrder("abc", "abc"), "---abc---"); + assertDoesNotMatch("substrings in order missing a repeated pattern", matcher, "abc"); + assertDoesNotMatch("substrings out of order", matcher, "cab"); + assertDoesNotMatch("no substrings in string", matcher, "xyz"); + assertDoesNotMatch("substring missing", matcher, "ac"); + assertDoesNotMatch("empty string", matcher, ""); + } + + @Test + public void testHasAReadableDescription() { + assertDescription("a string containing \"a\", \"b\", \"c\", \"c\" in order", matcher); + } + +} diff --git a/hamcrest-library/src/test/java/org/hamcrest/xml/HasXPathTest.java b/hamcrest/src/test/java/org/hamcrest/xml/HasXPathTest.java similarity index 96% rename from hamcrest-library/src/test/java/org/hamcrest/xml/HasXPathTest.java rename to hamcrest/src/test/java/org/hamcrest/xml/HasXPathTest.java index a66689dcc..c8f8b8878 100644 --- a/hamcrest-library/src/test/java/org/hamcrest/xml/HasXPathTest.java +++ b/hamcrest/src/test/java/org/hamcrest/xml/HasXPathTest.java @@ -1,7 +1,7 @@ package org.hamcrest.xml; import org.hamcrest.Matcher; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.w3c.dom.Document; import org.w3c.dom.Node; @@ -12,12 +12,12 @@ import java.util.HashSet; import java.util.Iterator; -import static org.hamcrest.AbstractMatcherTest.*; +import static org.hamcrest.test.MatcherAssertions.*; import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsNot.not; import static org.hamcrest.core.StringContains.containsString; import static org.hamcrest.xml.HasXPath.hasXPath; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.fail; /** * @author Joe Walnes @@ -48,7 +48,7 @@ public String getPrefix(String namespaceURI) { @Override public Iterator getPrefixes(String namespaceURI) { - HashSet prefixes = new HashSet(); + HashSet prefixes = new HashSet<>(); String prefix = getPrefix(namespaceURI); if (prefix != null) { prefixes.add(prefix); @@ -60,7 +60,7 @@ public Iterator getPrefixes(String namespaceURI) { @Test public void copesWithNullsAndUnknownTypes() { Matcher matcher = hasXPath("//irrelevant"); - + assertNullSafe(matcher); assertUnknownTypeSafe(matcher); } @@ -118,7 +118,7 @@ public Iterator getPrefixes(String namespaceURI) { describesItself() { assertDescription("an XML document with XPath /some/path \"Cheddar\"", hasXPath("/some/path", equalTo("Cheddar"))); - + assertDescription("an XML document with XPath /some/path", hasXPath("/some/path")); } @@ -144,4 +144,5 @@ private static Document parse(String xml) { throw new IllegalStateException(e); } } + } diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 000000000..d4b009797 --- /dev/null +++ b/settings.gradle @@ -0,0 +1,14 @@ +plugins { + // Apply the foojay-resolver plugin to allow automatic download of JDKs + id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0' +} + +include 'hamcrest', + 'hamcrest-core', + 'hamcrest-library' + +rootProject.name = 'JavaHamcrest' + +// Change the file name of the child project build file to match the directory name +// This avoids having multiple `build.gradle` files, making them easier to distinguish +rootProject.children.each { childProject -> childProject.buildFileName = "${childProject.name}.gradle" }