@Test
public void shouldDescribeMismatchOfInvalidJson() {
Matcher<Object> matcher = isJson(withPathEvaluatedTo(true));
Description description = new StringDescription();
matcher.describeMismatch("invalid-json", description);
assertThat(description.toString(), containsString("\"invalid-json\""));
}
@Test
public void shouldDescribeMismatchOfValidJson() {
Matcher<Object> matcher = isJson(withPathEvaluatedTo(true));
Description description = new StringDescription();
matcher.describeMismatch(BOOKS_JSON_STRING, description);
assertThat(description.toString(), containsString(TestingMatchers.MISMATCHED_TEXT));
}
@Test
public void should_obtain_instanciated_matcher_from_matcher() {
Matcher<Object> matcher =
((BeanFieldMatcher) BeanMatchers.the("firstName", is("Bill"))).getMatcher();
Person person = new Person("Bill", "Oddie");
assertThat(matcher.matches(person)).isTrue();
}
@Override
protected void describeMismatchSafely(T[] item, Description mismatchDescription) {
Matches<T> matches = new Matches<>();
Iterator<Matcher<T>> elementIterator = elements.iterator();
Iterator<? extends T> itemIterator = asList(item).iterator();
while (elementIterator.hasNext() && itemIterator.hasNext()) {
Matcher<T> matcher = elementIterator.next();
T element = itemIterator.next();
if (!matcher.matches(element)) {
matches.mismatch(matcher, element);
} else {
matches.match();
}
}
if (elementIterator.hasNext()) {
int count = count(elementIterator);
matches.mismatch("missing " + count + " elements");
}
if (itemIterator.hasNext()) {
List<T> items = collect(itemIterator);
matches.mismatch("found " + items.size() + " elements surplus " + toDescriptionSet(items));
}
if (matches.containsMismatches()) {
mismatchDescription.appendText("mismatching elements ").appendDescriptionOf(matches);
}
}
@Override
public boolean matches(Object item) {
for (Matcher m : matchers) {
if (!m.matches(item)) return false;
}
return true;
}
@Override
public void describeTo(Description description) {
description.appendText("a Complex number having ");
reMatcher.describeTo(description);
description.appendText(" as real part and ");
imMatcher.describeTo(description);
description.appendText(" as imaginary part");
}
@Test
public void shouldBeDescriptive() {
Matcher<Object> matcher = isJson(withPathEvaluatedTo(true));
Description description = new StringDescription();
matcher.describeTo(description);
assertThat(description.toString(), startsWith("is json"));
assertThat(description.toString(), containsString(TestingMatchers.MATCH_TRUE_TEXT));
}
private Matcher<T> bestMatcher() {
for (Matcher<T> matcher : elements) {
if (matcher.getClass() != IsNull.class) {
return matcher;
}
}
return equalTo(null);
}
@Theory
@SuppressWarnings({"unchecked", "rawtypes"})
public void differentMatchersHaveDifferentDescriptions(
Matcher matcher1, Matcher matcher2, Object value) {
assumeThat(value, matcher1);
assumeThat(value, not(matcher2));
assertThat(matcher1.toString(), not(matcher2.toString()));
}
@Override
public void describeMismatch(Object item, Description description) {
if (!containsAll.matches(item)) {
containsAll.describeMismatch(item, description);
}
if (!containsOnly.matches(item)) {
containsOnly.describeMismatch(item, description);
}
}
/**
* Returns a current wizard page
*
* @return current wizard page
* @deprecated use getCurrentWizardPage() instead
*/
public WizardPage getWizardPage() {
for (WizardPage wizardPage : wizardPageMap.keySet()) {
Matcher<WizardDialog> matcher = wizardPageMap.get(wizardPage);
if (matcher.matches(this)) {
return wizardPage;
}
}
log.warn("No wizard page found in page index '" + currentPage + "'");
return null;
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
public <T> JsonAsserter assertThat(String path, Matcher<T> matcher, String message) {
T obj = JsonPath.<T>read(jsonObject, path);
if (!matcher.matches(obj)) {
throw new AssertionError(
String.format(
"JSON Assert Error: %s\nExpected:\n%s\nActual:\n%s",
message, matcher.toString(), obj));
}
return this;
}
public void processItems(Iterable<? extends F> iterable) {
for (F item : iterable) {
if (nextMatchIx < matchers.size()) {
Matcher<? super F> matcher = matchers.get(nextMatchIx);
if (matcher.matches(item)) {
lastMatchedItem = item;
nextMatchIx++;
}
}
}
}
public void testEvaluatesToTrueIfArgumentIsEqualToADoubleValueWithinSomeError() {
Matcher<Double> p = closeTo(1.0, 0.5);
assertTrue(p.matches(1.0));
assertTrue(p.matches(0.5d));
assertTrue(p.matches(1.5d));
assertDoesNotMatch("too large", p, 2.0);
assertMismatchDescription("<2.0> differed by <0.5>", p, 2.0);
assertDoesNotMatch("number too small", p, 0.0);
assertMismatchDescription("<0.0> differed by <0.5>", p, 0.0);
}
@Test
public void assertThatSmallGraphIsDescribable() {
Graph graph1 = makeSmallGraph("A");
Matcher<? super Graph> matcher = deeplyEqualTo(graph1);
StringDescription description = new StringDescription();
matcher.describeTo(description);
assertThat(
description.toString(),
allOf(
startsWith("{" + System.getProperty("line.separator") + " nodes ["),
containsString("value is <"),
containsString("neighbors ["),
containsString("&Node<A-1>")));
}
@Override
public boolean matches(Object item) {
try {
if (item == null) {
return matchingError("Guice injector is null");
}
if (!Injector.class.isAssignableFrom(item.getClass())) {
return matchingError("Object " + item + " is not a Guice Injector");
}
T instance = ((Injector) item).getInstance(typeKey);
if (instance == null) {
return matchingError("Instance " + typeKey + " is null");
}
Class<?> instanceClass = instance.getClass();
if (!expectedType.isAssignableFrom(instanceClass)) {
return matchingError(
"Instance "
+ typeKey
+ " type mismatch: expected "
+ expectedType
+ " but was "
+ ""
+ instanceClass);
}
if (!instanceMatcher.matches(instance)) {
matcherDescription = new StringDescription();
matcherDescription.appendText(
"Instance " + typeKey + " does not match " + "expectations: ");
instanceMatcher.describeMismatch(item, matcherDescription);
return false;
} else {
return true;
}
} catch (ConfigurationException | ProvisionException ex) {
return matchingError(
"Cannot get instance of "
+ typeKey
+ " from Guice Injector\n"
+ ex.getMessage()
+ "\n\n"
+ "Error stack trace: \n"
+ "-------------------\n"
+ getStackTrace(ex));
}
}
private boolean tryExtractPropertyValueFrom(Object bean) {
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression(propertyName);
beanPropertyValue = exp.getValue(bean);
return valueMatcher.matches(beanPropertyValue);
}
/**
* Allows matching arguments with hamcrest matchers.
*
* <p>See examples in javadoc for {@link MockitoHamcrest} class
*
* @param matcher decides whether argument matches
* @return <code>null</code> or default value for primitive (0, false, etc.)
* @since 2.0
*/
public static <T> T argThat(Matcher<T> matcher) {
return (T)
MOCKING_PROGRESS
.getArgumentMatcherStorage()
.reportMatcher(new HamcrestArgumentMatcher(matcher))
.returnFor(MatcherGenericTypeExtractor.genericTypeOfMatcher(matcher.getClass()));
}
/**
* Waits for specified time period for a shell matching specified matcher.
*
* @param matcher matcher to match shell
* @param timePeriod time period to wait for
* @return shell matching specified matcher
*/
public Shell getShell(final Matcher<String> matcher, TimePeriod timePeriod) {
if (!timePeriod.equals(TimePeriod.NONE)) {
new WaitUntil(new ShellMatchingMatcherIsAvailable(matcher), timePeriod, false);
}
Shell[] shells =
Display.syncExec(
new ResultRunnable<Shell[]>() {
@Override
public Shell[] run() {
return Display.getDisplay().getShells();
}
});
for (final Shell s : shells) {
if (matcher.matches(s)) {
Shell visibleShell =
Display.syncExec(
new ResultRunnable<Shell>() {
@Override
public Shell run() {
if (!s.isDisposed() && s.isVisible()) {
return s;
}
return null;
}
});
if (visibleShell != null) {
return visibleShell;
}
}
}
return null;
}
@Override
protected boolean matchesSafely(T[] item) {
if (item.length != elements.size()) {
return false;
}
Iterator<Matcher<T>> elementIterator = elements.iterator();
Iterator<? extends T> itemIterator = Arrays.asList(item).iterator();
while (elementIterator.hasNext() && itemIterator.hasNext()) {
Matcher<T> matcher = elementIterator.next();
T element = itemIterator.next();
if (!matcher.matches(element)) {
return false;
}
}
return true;
}
@Override
protected boolean matchesSafely(File item) {
if (directoryMatcher.matches(item)) {
return fileMatcher.matches(files(item));
} else {
mismatch = directoryMatcher;
return false;
}
}
static void fail(@Nullable Object actualValue, Matcher<?> matcher) {
Description description =
new StringDescription()
.appendText("\nExpected: ")
.appendDescriptionOf(matcher)
.appendText("\n but: ");
matcher.describeMismatch(actualValue, description);
AssertionError assertionError = new AssertionError(description.toString());
assertionError.setStackTrace(ObjectChecker.trimStackTrace(assertionError.getStackTrace()));
throw assertionError;
}
private static <T extends AccessibilityCheckResult> void modifyResultType(
List<T> results, Matcher<? super T> matcher, AccessibilityCheckResultType newType) {
if (results == null || matcher == null) {
return;
}
for (T result : results) {
if (matcher.matches(result)) {
result.setType(newType);
}
}
}
/**
* Create Workbench ToolItem matching given toolTip matcher
*
* @param matcher
*/
public WorkbenchToolItem(Matcher<String> toolTipMatcher) {
ToolBarLookup tl = new ToolBarLookup();
ToolBar[] workbenchToolBars = tl.getWorkbenchToolBars();
ToolItem ti = null;
for (ToolBar t : workbenchToolBars) {
ti = tl.getToolItem(t, toolTipMatcher);
if (ti != null) break;
}
Thrower.objectIsNull(ti, "ToolItem matching " + toolTipMatcher.toString() + " cannot be found");
toolItem = ti;
}
@Override
public boolean test() {
items = table.getItems();
for (TableItem item : items) {
if (!item.getSWTWidget().isDisposed() && matcher.matches(item.getText())) {
item.select();
return true;
}
}
return false;
}
@Override
protected boolean matches(Object item, Description mismatchDescription) {
FileSink fs = (FileSink) item;
try {
String contents = fs.getContents();
mismatchDescription.appendValue(contents);
return matcher.matches(contents);
} catch (IOException e) {
mismatchDescription.appendText("failed with an IOException: " + e.getMessage());
return false;
}
}
final String createErrorMessage(final Throwable thrown) {
final StringBuilder msg = new StringBuilder(128);
if (hasNullMessage(thrown)) msg.append(beforeNullActual);
else msg.append(beforeActual).append(getActualMessage(thrown)).append(afterActual);
msg.append(beforeExpected);
final Matcher expectedMatcher = getExpectedMatcher();
if (expectedMatcher != null) {
final int insertAt = msg.length();
final String shouldStartWith = expectedMatcherPrefix;
final boolean[] startsThat = {false};
expectedMatcher.describeTo(
new BaseDescription() {
private int i, upTo = shouldStartWith.length();
@Override
protected void append(char c) {
if (i < upTo && (i == 0 || startsThat[0]))
startsThat[0] = c == shouldStartWith.charAt(i);
++i;
msg.append(c);
}
@Override
public String toString() {
return msg.toString();
}
});
if (!startsThat[0]) msg.insert(insertAt, shouldStartWith);
} else msg.append(getExpectedMessage());
msg.append(afterExpected);
return msg.toString();
}
private static MenuItem show(final Menu menu, final Matcher<?> matcher) {
if (menu != null) {
menu.notifyListeners(SWT.Show, new Event());
MenuItem[] items = menu.getItems();
for (final MenuItem menuItem : items) {
if (matcher.matches(menuItem)) {
return menuItem;
}
}
menu.notifyListeners(SWT.Hide, new Event());
}
return null;
}
private void assertValues(
final MimeRulesSource mimeRulesSource,
final String path,
final Matcher<? super String> matcher) {
MimeRule nexusMimeType = mimeRulesSource.getRuleForName(path);
if (matcher.getClass().equals(nullValue().getClass())) {
assertThat(nexusMimeType, nullValue());
return;
}
assertThat(nexusMimeType, notNullValue());
assertThat(nexusMimeType.getMimetypes(), hasSize(1));
assertThat(nexusMimeType.getMimetypes().get(0), matcher);
}
@Override
public String description() {
StringBuffer message = new StringBuffer();
message.append("an item matching ").append(matcher.toString()).append(" in\n");
for (TableItem item : items) {
String text = null;
if (!item.getSWTWidget().isDisposed()) {
text = item.getText();
}
message.append("\t").append(text).append("\n");
}
return message.toString();
}