ext.test4j.hamcrest.collection.IsIterableContainingInAnyOrder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of test4j.nodep Show documentation
There is a newer version: 2.5.0
package ext.test4j.hamcrest.collection;

import ext.test4j.hamcrest.Description;
import ext.test4j.hamcrest.Factory;
import ext.test4j.hamcrest.Matcher;
import ext.test4j.hamcrest.TypeSafeDiagnosingMatcher;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import static ext.test4j.hamcrest.core.IsEqual.equalTo;

public class IsIterableContainingInAnyOrder extends TypeSafeDiagnosingMatcher> {
	private final Collection> matchers;

	public IsIterableContainingInAnyOrder(Collection> matchers) {
		this.matchers = matchers;
	}

	@Override
	protected boolean matchesSafely(Iterable items, Description mismatchDescription) {
		Matching matching = new Matching(matchers, mismatchDescription);
		for (T item : items) {
			if (!matching.matches(item)) {
				return false;
			}
		}

		return matching.isFinished(items);
	}

	public void describeTo(Description description) {
		description.appendText("iterable over ").appendList("[", ", ", "]", matchers).appendText(" in any order");
	}

	private static class Matching {
		private final Collection> matchers;
		private final Description mismatchDescription;

		public Matching(Collection> matchers, Description mismatchDescription) {
			this.matchers = new ArrayList>(matchers);
			this.mismatchDescription = mismatchDescription;
		}

		public boolean matches(S item) {
			return isNotSurplus(item) && isMatched(item);
		}

		public boolean isFinished(Iterable items) {
			if (matchers.isEmpty()) {
				return true;
			}
			mismatchDescription.appendText("No item matches: ").appendList("", ", ", "", matchers).appendText(" in ")
					.appendValueList("[", ", ", "]", items);
			return false;
		}

		private boolean isNotSurplus(S item) {
			if (matchers.isEmpty()) {
				mismatchDescription.appendText("Not matched: ").appendValue(item);
				return false;
			}
			return true;
		}

		private boolean isMatched(S item) {
			for (Matcher matcher : matchers) {
				if (matcher.matches(item)) {
					matchers.remove(matcher);
					return true;
				}
			}
			mismatchDescription.appendText("Not matched: ").appendValue(item);
			return false;
		}

	}

	@SuppressWarnings("unchecked")
	@Factory
	public static  Matcher> containsInAnyOrder(final Matcher item) {
		return containsInAnyOrder(new ArrayList>(Arrays.asList(item)));
	}

	@Factory
	public static  Matcher> containsInAnyOrder(Matcher... matchers) {
		return containsInAnyOrder(Arrays.asList(matchers));
	}

	@Factory
	public static  Matcher> containsInAnyOrder(T... items) {
		List> matchers = new ArrayList>();
		for (T item : items) {
			matchers.add(equalTo(item));
		}

		return new IsIterableContainingInAnyOrder(matchers);
	}

	@Factory
	public static  Matcher> containsInAnyOrder(Collection> matchers) {
		return new IsIterableContainingInAnyOrder(matchers);
	}
}