示例#1
0
 @Override
 public void describeMismatch(Object item, Description description) {
   if (!containsAll.matches(item)) {
     containsAll.describeMismatch(item, description);
   }
   if (!containsOnly.matches(item)) {
     containsOnly.describeMismatch(item, description);
   }
 }
示例#2
0
  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);
  }
示例#3
0
  private boolean tryExtractPropertyValueFrom(Object bean) {
    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression(propertyName);
    beanPropertyValue = exp.getValue(bean);

    return valueMatcher.matches(beanPropertyValue);
  }
示例#4
0
 @Override
 public boolean matches(Object item) {
   for (Matcher m : matchers) {
     if (!m.matches(item)) return false;
   }
   return true;
 }
示例#5
0
  @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);
    }
  }
 @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();
 }
示例#7
0
  /**
   * 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(File item) {
   if (directoryMatcher.matches(item)) {
     return fileMatcher.matches(files(item));
   } else {
     mismatch = directoryMatcher;
     return false;
   }
 }
示例#9
0
 /**
  * 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;
 }
示例#10
0
 /** {@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;
 }
 @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;
 }
 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);
     }
   }
 }
 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++;
       }
     }
   }
 }
示例#14
0
 @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;
   }
 }
 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;
 }
示例#16
0
  @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));
    }
  }
示例#17
0
  @Override
  protected boolean matchesSafely(HtmlFragment html) {
    if (!html.exists()) return false;

    index = 1;
    for (HtmlElement e : html.elements()) {
      if (matcher.matches(e)) {
        matched = matcher;
        return false;
      }
      index++;
    }
    return true;
  }
示例#18
0
  @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;
  }
示例#19
0
 public List<String> linesThat(Matcher<? super String> matcher) {
   try {
     BufferedReader reader = new BufferedReader(new FileReader(this));
     try {
       List<String> lines = new ArrayList<String>();
       String line;
       while ((line = reader.readLine()) != null) {
         if (matcher.matches(line)) {
           lines.add(line);
         }
       }
       return lines;
     } finally {
       reader.close();
     }
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
示例#20
0
  @Override
  public boolean matchesSafely(JsonNode node) {

    if (!node.isArray()) {
      return false;
    }

    Iterator<JsonNode> nodeIterator = node.getElements();
    int nodeCount = 0;

    while (nodeIterator.hasNext()) {

      JsonNode currentNode = nodeIterator.next();

      if (nodeCount == position) {
        return matcher.matches(currentNode.getTextValue());
      }

      nodeCount++;
    }

    return false;
  }
示例#21
0
 @Override
 protected boolean matchesSafely(File item) {
   return nameMatcher.matches(item.getName());
 }
 /** {@inheritDoc} */
 @Override
 public boolean matchesSafely(Message<?> item) {
   return matcher.matches(item.getHeaders());
 }
 /* (non-Javadoc)
  * @see org.jboss.reddeer.core.matcher.AbstractWidgetWithTextMatcher#matches(java.lang.String)
  */
 @Override
 protected boolean matches(String text) {
   return matcher.matches(text);
 }
 @Override
 public boolean isSatisfiedBy(Item<E> item) {
   return matcher.matches(item.get());
 }
示例#25
0
 @Override
 public boolean matchesSafely(WebElement item) {
   return textMatcher.matches(item.getText());
 }
 /* (non-Javadoc)
  * @see org.jboss.reddeer.core.matcher.AbstractWidgetWithTextMatcher#matches(java.lang.String)
  */
 @Override
 protected boolean matches(String extractedText) {
   String textToMatch = extractedText.replaceAll("&", "").split("\t")[0];
   return matcher.matches(textToMatch);
 }
 public boolean matches(Object item) {
   return fMatcher.matches(item);
 }
示例#28
0
 public boolean matches(Object o) {
   return matcher.matches(o);
 }
 @Override
 protected boolean matchesSafely(WrapsElement element) {
   return matcher.matches(element.getWrappedElement());
 }
示例#30
0
 @Override
 public boolean matches(Object o) {
   return containsAll.matches(o) && containsOnly.matches(o);
 }