Java Factory类代码示例

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
@Deprecated
/**
 * Please avoid using as the hamcrest way of reporting error wraps a multi-line
 * text into a single line and makes hard to understand the problem.
 * Instead, please try to use the spock/groovy assert and {@link #containsLine(String, String)}
 */
public static Matcher<String> containsLine(final String line) {
    return new BaseMatcher<String>() {
        public boolean matches(Object o) {
            return containsLine(equalTo(line)).matches(o);
        }

        public void describeTo(Description description) {
            description.appendText("a String that contains line ").appendValue(line);
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
/**
 * Matches the set of entries against the given set of values. The full combinatorial of values passed in is expected in the output set.
 *
 * @param rows
 *          Rows to check for.
 * @param colFs
 *          Column families to check for.
 * @param colQs
 *          Column qualifiers to check for.
 * @param colVs
 *          Column visibilities to check for.
 * @param values
 *          Values to check for.
 * @return Hamcrest matcher.
 */
@Factory
@SuppressWarnings("unchecked")
public static Matcher<Iterable<Entry<Key,Value>>> hasData(Collection<String> rows, Collection<String> colFs, Collection<String> colQs,
    Collection<String> colVs, Collection<String> values) {
  int size = rows.size() * colFs.size() * colQs.size() * colVs.size() * values.size();
  ArrayList<Matcher<? super Iterable<Entry<Key,Value>>>> matchers = new ArrayList<>(size + 1);

  matchers.add(IsIterableWithSize.iterableWithSize(size));

  for (String row : rows) {
    for (String colF : colFs) {
      for (String colQ : colQs) {
        for (String colV : colVs) {
          for (String value : values) {
            matchers.add(hasItems(equalToRow(row, colF, colQ, colV, value)));
          }
        }
      }
    }
  }

  return allOf(matchers);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
/**
 * @param v The expected vertex.
 * @return A matcher that compares an actual vertex with the expected
 * vertex. Two vertices are considered equal if all their fields are equal.
 */
@Factory
public static Matcher equalsVertex(Vertex v) {
    return new TypeSafeMatcher<Vertex>() {
        @Override
        protected boolean matchesSafely(Vertex w) {
            return v.label.equals(w.label)
                && Double.doubleToLongBits(v.radius) == Double.doubleToLongBits(w.radius)
                && v.fillColor.equals(w.fillColor)
                && v.strokeWidth == w.strokeWidth
                && v.textHeight == w.textHeight
                && v.strokeColor.equals(w.strokeColor)
                && v.coordinates.equals(w.coordinates);
        }

        @Override
        public void describeTo(Description d) {
            d.appendText("Vertex equality");
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static <T> Matcher<Node> cellWithValue(final Matcher<T> contentsMatcher) {
    return new TypeSafeMatcher<Node>(Cell.class) {
        @Override
        protected boolean matchesSafely(Node item) {
            return contentsMatcher.matches(((Cell) item).getItem());
        }

        @Override
        public void describeTo(Description description) {
            description.appendText(Cell.class.getSimpleName())
                    .appendText(" ")
                    .appendText("with value")
                    .appendDescriptionOf(contentsMatcher);
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
private static DiagnosingMatcher<Object> translateTo(HttpStatus status) {
    return new DiagnosingMatcher<Object>() {
        private static final String EXCEPTION = "EXCEPTION";

        @Override
        public void describeTo(final Description description) {
            description.appendText("does not translate to ").appendText(status.toString());
        }

        @SuppressWarnings("unchecked")
        protected boolean matches(final Object item, final Description mismatch) {

            if (item instanceof Class) {
                if (((Class) item).getClass().isInstance(Throwable.class)) {
                    Class<? extends Throwable> type = (Class<? extends Throwable>) item;
                    try {
                        Throwable exception = type.getConstructor(String.class).newInstance(EXCEPTION);
                        Mono.just(exception).transform(ThrowableTranslator::translate).subscribe(translator -> {
                            assertThat(translator.getMessage(), is(EXCEPTION));
                            assertThat(translator.getHttpStatus(), is(status));
                        });
                    } catch (InstantiationException | IllegalAccessException |
                            InvocationTargetException | NoSuchMethodException cause) {
                        throw new AssertionError("This exception class has not constructor with a String", cause);
                    }
                    return true;
                }
            }
            mismatch.appendText(item.toString());
            return false;
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Matcher<Predicate> absentBackReferences(int noOfPredicateArguments)
{
    Matcher[] matchers = new Matcher[noOfPredicateArguments];
    Arrays.fill(matchers, isAbsent());
    return new ArgumentBackReferences(Absent.<TransactionContext>absent(), matchers);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static RingBufferEventMatcher ringBufferWithEvents(final Object... values)
{
    Matcher<?>[] valueMatchers = new Matcher[values.length];
    for (int i = 0; i < values.length; i++)
    {
        final Object value = values[i];
        valueMatchers[i] = is(value);
    }
    return new RingBufferEventMatcher(valueMatchers);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Matcher<BattleModel> monsterIsAlive() {
    return new FeatureMatcher<BattleModel, Boolean>( is( true ), "monster alive", "monster alive" ) {
        @Override
        protected Boolean featureValueOf(BattleModel actual) {
            return actual.monsterAlive();
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Matcher<HtmlElement> hasAttributes(String... nameValues) {
    if (nameValues.length % 2 != 0) throw new RuntimeException("The last attr was missing a value");

    List<Attribute> expectedAttrs = new ArrayList<Attribute>();
    for (int i = 0; i < nameValues.length; i += 2) {
        expectedAttrs.add(new Attribute(nameValues[i], nameValues[i + 1]));
    }

    return new HasAttribute(expectedAttrs);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
/**
 * A reimplementation of hamcrest's isA() but without the broken generics.
 */
@Factory
public static Matcher<Object> isA(final Class<?> type) {
    return new BaseMatcher<Object>() {
        public boolean matches(Object item) {
            return type.isInstance(item);
        }

        public void describeTo(Description description) {
            description.appendText("instanceof ").appendValue(type);
        }
    };
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Collection<Matcher<? super Asset>> assetsWithIds(Asset... assets) {
    ArrayList<Matcher<? super Asset>> matchers = new ArrayList<>();
    for (Asset asset : assets) {
        matchers.add(hasId(asset));
    }
    return matchers;
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static <T> Matcher<T> reflectionEquals(T equalsTo) {
    return new ReflectionEqualsMatcher<T>(equalsTo);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Matcher<AspectRatio> closeTo(AspectRatio ratio) {
    return new AspectRatioIsCloseTo(ratio);
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
@Factory
public static Matcher<AspectRatio> closeToOrInverse(AspectRatio ratio) {
    return either(closeTo(ratio)).or(closeTo(ratio.inverse()));
}
 

import org.hamcrest.Factory; //导入依赖的package包/类
/**
 * Gets a hamcrest matcher that tests whether two Ini objects are equal.
 *
 * @param expectedValue
 *          The expected value to core against.
 * @return Method safe matcher that will core field equality.
 */
@Factory
public static TypeSafeMatcher<Ini> equalTo(final Ini expectedValue) {
  return new TypeSafeMatcher<Ini>() {
    @Override
    protected boolean matchesSafely(Ini actualValue) {
      if (expectedValue.size() != actualValue.size()) {
        return false;
      }

      for (Section expectedSection : expectedValue.values()) {
        Section actualSection = actualValue.get(expectedSection.getName());
        if (actualSection == null) {
          return false;
        }

        if (expectedSection.size() != actualSection.size()) {
          return false;
        }

        for (Entry<String,String> expectedEntry : expectedSection.entrySet()) {
          if (!actualSection.containsKey(expectedEntry.getKey())) {
            return false;
          }

          String actual = actualSection.get(expectedEntry.getKey());
          String expected = expectedEntry.getValue();
          if ((actual == null && expected != null) || (actual != null && !actual.equals(expected))) {
            return false;
          }

        }
      }

      return true;
    }

    @Override
    public void describeTo(Description description) {
      description.appendValue(expectedValue);
    }
  };
}