net.amygdalum.testrecorder.runtime.ContainsInOrderMatcher Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of testrecorder-runtime Show documentation
The newest version!
package net.amygdalum.testrecorder.runtime;

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNull.nullValue;

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

import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.core.IsNull;

public class ContainsInOrderMatcher extends AbstractIterableMatcher> {

	private Class type;
	private List> elements;

	public ContainsInOrderMatcher(Class type) {
		this.type = type;
		this.elements = new ArrayList<>();
	}

	public ContainsInOrderMatcher element(T element) {
		return element(match(element));
	}

	public ContainsInOrderMatcher element(Matcher element) {
		elements.add(element);
		return this;
	}

	private Matcher match(T element) {
		if (element == null) {
			return nullValue(type);
		} else {
			return equalTo(element);
		}
	}

	@Override
	public void describeTo(Description description) {
		description.appendText("containing in sequence ").appendValueList("[", ", ", "]", elements);
	}

	@Override
	protected void describeMismatchSafely(Collection item, Description mismatchDescription) {
		Matches matches = new Matches<>();

		Iterator> elementIterator = elements.iterator();
		Iterator itemIterator = item.iterator();
		while (elementIterator.hasNext() && itemIterator.hasNext()) {
			Matcher matcher = elementIterator.next();
			T element = itemIterator.next();
			if (!matcher.matches(element)) {
				matches.mismatch(matcher, element);
			} else {
				matches.match();
			}
		}
		if (elementIterator.hasNext()) {
			List> matchers = remainder(elementIterator);
			matches.mismatch("missing " + matchers.size() + " elements " + toExpectedSet(matchers));
		}
		if (itemIterator.hasNext()) {
			List items = remainder(itemIterator);
			matches.mismatch("found " + items.size() + " elements surplus " + toFoundSet(items));
		}

		if (matches.containsMismatches()) {
			mismatchDescription.appendText("mismatching elements ").appendDescriptionOf(matches);
		}
	}

	@Override
	protected Matcher bestMatcher() {
		for (Matcher matcher : elements) {
			if (matcher.getClass() != IsNull.class) {
				return matcher;
			}
		}
		return equalTo(null);
	}

	@Override
	protected boolean matchesSafely(Collection item) {
		Iterator> elementIterator = elements.iterator();
		Iterator itemIterator = item.iterator();
		while (elementIterator.hasNext() && itemIterator.hasNext()) {
			Matcher matcher = elementIterator.next();
			T element = itemIterator.next();
			if (!matcher.matches(element)) {
				return false;
			}
		}
		return !elementIterator.hasNext()
			&& !itemIterator.hasNext();
	}

	@SuppressWarnings("unchecked")
	@SafeVarargs
	public static  ContainsInOrderMatcher containsInOrder(Class key, Object... elements) {
		ContainsInOrderMatcher set = new ContainsInOrderMatcher<>(key);
		for (Object element : elements) {
			if (element instanceof Matcher) {
				set.element((Matcher) element);
			} else {
				set.element(key.cast(element));
			}
		}
		return set;
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	@SafeVarargs
	public static ContainsInOrderMatcher containsInOrder(Object... elements) {
		ContainsInOrderMatcher set = new ContainsInOrderMatcher(Object.class);
		for (Object element : elements) {
			if (element instanceof Matcher) {
				set.element((Matcher) element);
			} else {
				set.element(element);
			}
		}
		return set;
	}
}