Java Objects类代码示例

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/**
 * Verifies that the actual {@link com.google.common.collect.Range} does not contain the given values.<br>
 * <p>
 * Example :
 *
 * <pre><code class='java'> Range&lt;Integer&gt; range = Range.closed(10, 12);
 *
 * assertThat(range).doesNotContain(13);</code></pre>
 *
 * @param values the values to look for in actual {@link com.google.common.collect.Range}.
 * @return this {@link OptionalAssert} for assertions chaining.
 * @throws AssertionError if the actual {@link com.google.common.collect.Range} is {@code null}.
 * @throws AssertionError if the actual {@link com.google.common.collect.Range} contains the given values.
 */
public RangeAssert<T> doesNotContain(@SuppressWarnings("unchecked") final T... values) {
  Objects.instance().assertNotNull(info, actual);

  final List<T> valuesFound = newArrayList();
  for (final T value : values) {
    if (actual.contains(value)) {
      valuesFound.add(value);
    }
  }
  if (!valuesFound.isEmpty()) {
    throw failures.failure(info, shouldNotContain(actual, values, valuesFound));
  }

  return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
@Override
public SparseArrayAssert<E> isEqualTo(Object expected) {
    Objects.instance().assertHasSameClassAs(info, actual, expected);
    final SparseArray<E> expectedSparseArray = (SparseArray<E>) expected;
    assertThat(actual).is(new Condition<SparseArray<E>>() {
        @Override
        public boolean matches(SparseArray<E> eSparseArray) {
            return isEqualTo(eSparseArray, expectedSparseArray);
        }
    });
    return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
@CheckReturnValue
public SELF usingComparator(Comparator<? super ACTUAL> customComparator) {
  // using a specific strategy to compare actual with other objects.
  this.objects = new Objects(new ComparatorBasedComparisonStrategy(customComparator));
  return myself;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
@CheckReturnValue
public SELF usingDefaultComparator() {
  // fall back to default strategy to compare actual with other objects.
  this.objects = Objects.instance();
  return myself;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
@Before
public void setUp() {
  dates = mock(Dates.class);
  objects = mock(Objects.class);
  assertions = new DateAssert(new Date());
  assertions.dates = dates;
  assertions.objects = objects;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
@Override
protected void inject_internal_objects() {
  super.inject_internal_objects();
  classes = mock(Classes.class);
  objects = mock(Objects.class);
  assertions = new ClassAssert(AnnotatedClass.class);
  assertions.objects = objects;
  assertions.classes = classes;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/**
 * Not a really relevant assertion, the goal is to show how to write a new assertion with a specific error message
 * that honors the description set by the assertion user.
 */
public ConcreteAssert checkNull() {
  // set a specific error message
  WritableAssertionInfo info = getWritableAssertionInfo();
  info.overridingErrorMessage("specific error message");
  Objects.instance().assertNull(info, actual);
  // return the current assertion for method chaining
  return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
public RelationshipAssert doesNotEndWithNode(Node node) {
  Objects.instance().assertNotNull(info, actual);

  Node actualEndNode = actual.getEndNode();

  checkActualRelationshipNode(actualEndNode, "The actual end node should not be null");
  checkArgumentNode(node, "The end node to look for should not be null");

  if (actualEndNode.equals(node)) {
    throw Failures.instance().failure(info, shouldNotEndWithNode(actual, node));
  }
  return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/**
 * Verifies that the actual value is a map, and returns a map assertion, to allow
 * chaining of map-specific assertions from this call.
 * @return a map assertion object
 */
@SuppressWarnings("unchecked")
public AbstractMapAssert<?, ?, Object, Object> asMap() {
	Objects.instance().assertIsInstanceOf(this.info, this.actual, Map.class);
	return Assertions.assertThat((Map<Object, Object>) this.actual);
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
public JsAssert isEqualTo(String js) {
    Objects.instance().assertEqual(info, trimEachLines(actual), trimEachLines(js));
    return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
private void assertNotNull(final AssertionInfo info, final FDate actual) {
    Objects.instance().assertNotNull(info, actual);
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
protected <T> T asInstanceOf(final Class<T> clazz) {
    Objects.instance().assertIsInstanceOf(this.info, this.actual, clazz);
    return clazz.cast(actual);
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/**
 * Verifies that the actual {@link org.neo4j.graphdb.Relationship} has the given type name<br/>
 * <p>
 * Example:
 * 
 * <pre>
 * GraphDatabaseService graph = new TestGraphDatabaseFactory().newImpermanentDatabase();
 * // [...] creation of homerNode, doughnutNode
 * RelationshipType loveType = DynamicRelationshipType.withName(&quot;LOVES&quot;);
 * Relationship love = homerNode.createRelationshipTo(doughnutNode, loveType);
 * 
 * assertThat(love).hasType(&quot;LOVES&quot;);
 * </pre>
 * 
 * If the <code>relationshipTypeName</code> is {@code null}, an {@link IllegalArgumentException} is thrown.
 * <p>
 * 
 * @param relationshipTypeName a {@link org.neo4j.graphdb.Relationship} type name
 * @return this {@link RelationshipAssert} for assertions chaining
 * 
 * @throws IllegalArgumentException if <code>relationshipTypeName</code> is {@code null}.
 * @throws AssertionError if the actual {@link org.neo4j.graphdb.Relationship} does not have the given type name
 */
public RelationshipAssert hasType(String relationshipTypeName) {
  Objects.instance().assertNotNull(info, actual);

  RelationshipType actualType = actual.getType();
  checkTypeNameIsNotNull(actualType);

  if (relationshipTypeName == null) {
    throw new IllegalArgumentException("The relationship type to look for should not be null");
  }

  if (!actualType.name().equals(relationshipTypeName)) {
    throw Failures.instance().failure(info, shouldHaveRelationshipType(actual, relationshipTypeName));
  }
  return this;
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
private static void assertNotNull(AssertionInfo info, Instant actual) {
  Objects.instance().assertNotNull(info, actual);
}
 

import org.assertj.core.internal.Objects; //导入依赖的package包/类
/**
 * Verifies that the actual {@link Table} contains the given columns.
 *
 * <p>
 * Example :
 *
 * <pre><code class='java'> Table<Integer, Integer, String> actual = HashBasedTable.create();
 *
 * actual.put(1, 3, "Millard Fillmore");
 * actual.put(1, 4, "Franklin Pierce");
 * actual.put(2, 5, "Grover Cleveland");
 *
 * assertThat(actual).containsColumns(3, 4);</code></pre>
 *
 * @param columns The columns to look for in the actual {@link Table}
 * @return this {@link TableAssert} for assertion chaining.
 * @throws IllegalArgumentException if no param columns have been set.
 * @throws AssertionError           if the actual {@link Table} is {@code null}.
 * @throws AssertionError           if the actual {@link Table} does not contain the given columns.
 */
public TableAssert<R, C, V> containsColumns(@SuppressWarnings("unchecked") C... columns) {
  Objects.instance().assertNotNull(info, actual);
  checkArgument(columns != null, "The columns to look for should not be null.");
  checkArgument(columns.length > 0, "The columns to look for should not be empty.");

  Set<C> columnsNotFound = Sets.newHashSet();
  for (C column : columns) {
    if (!actual.containsColumn(column)) {
      columnsNotFound.add(column);
    }
  }

  if (!columnsNotFound.isEmpty()) {
    throw failures.failure(info, tableShouldContainColumns(actual, columns, columnsNotFound));
  }

  return myself;
}