public void test_constructor_IterableType_two() {
ExternalIdSearch test =
ExternalIdSearch.of(ExternalIdSearchType.EXACT, Arrays.asList(_id11, _id12));
assertEquals(2, test.size());
assertEquals(Sets.newHashSet(_id11, _id12), test.getExternalIds());
assertEquals(ExternalIdSearchType.EXACT, test.getSearchType());
}
public void test_equals_different() {
ExternalIdSearch a = ExternalIdSearch.of();
ExternalIdSearch b = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, a.equals(a));
assertEquals(false, a.equals(b));
assertEquals(false, b.equals(a));
assertEquals(true, b.equals(b));
assertEquals(false, b.equals("Rubbish"));
assertEquals(false, b.equals(null));
}
public void test_matches1_ALL() {
ExternalIdSearch test1 = ExternalIdSearch.of(ExternalIdSearchType.ALL, _id11);
assertEquals(true, test1.matches(_id11));
assertEquals(false, test1.matches(_id12));
assertEquals(false, test1.alwaysMatches());
ExternalIdSearch test2 = ExternalIdSearch.of(ExternalIdSearchType.ALL, _id11, _id21);
assertEquals(false, test2.matches(_id11));
assertEquals(false, test2.matches(_id12));
assertEquals(false, test2.matches(_id21));
assertEquals(false, test2.alwaysMatches());
}
public void test_withExternalIdsAdded_iterable() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(1, base.size());
ExternalIdSearch test =
base.withExternalIdsAdded(Arrays.asList(ExternalId.of("A", "C"), ExternalId.of("D", "E")));
assertEquals(1, base.size());
assertEquals(3, test.size());
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "B")));
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "C")));
assertTrue(test.getExternalIds().contains(ExternalId.of("D", "E")));
}
public void test_withExternalIdRemoved_noMatch() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(1, base.size());
ExternalIdSearch test = base.withExternalIdRemoved(ExternalId.of("A", "C"));
assertEquals(1, base.size());
assertEquals(1, test.size());
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "B")));
}
// -------------------------------------------------------------------------
public void test_withExternalIdRemoved_match() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(1, base.size());
ExternalIdSearch test = base.withExternalIdRemoved(ExternalId.of("A", "B"));
assertEquals(1, base.size());
assertEquals(0, test.size());
}
public void test_matches_NONE() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.NONE, _id11, _id12);
assertEquals(false, test.matches(ImmutableSet.of(_id11, _id12)));
assertEquals(false, test.matches(ImmutableSet.of(_id11, _id12, _id21)));
assertEquals(false, test.matches(ImmutableSet.of(_id11)));
assertEquals(false, test.matches(ImmutableSet.of(_id12)));
assertEquals(true, test.matches(ImmutableSet.of(_id21)));
assertEquals(true, test.matches(ImmutableSet.of()));
}
// -------------------------------------------------------------------------
public void test_containsAny() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, test.containsAny(ImmutableSet.of(_id11, _id12)));
assertEquals(true, test.containsAny(ImmutableSet.of(_id11)));
assertEquals(true, test.containsAny(ImmutableSet.of(_id12)));
assertEquals(false, test.containsAny(ImmutableSet.of(_id21)));
assertEquals(false, test.containsAny(ImmutableSet.of()));
}
public void test_equals_same_nonEmpty() {
ExternalIdSearch a1 = ExternalIdSearch.of(_id11, _id12);
ExternalIdSearch a2 = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, a1.equals(a1));
assertEquals(true, a1.equals(a2));
assertEquals(true, a2.equals(a1));
assertEquals(true, a2.equals(a2));
}
// -------------------------------------------------------------------------
public void coverage() {
coverImmutableBean(ExternalIdSearch.of(_id11, _id12));
}
public void test_toString_nonEmpty() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertTrue(test.toString().contains(_id11.toString()));
assertTrue(test.toString().contains(_id12.toString()));
}
public void test_toString_empty() {
ExternalIdSearch test = ExternalIdSearch.of();
assertTrue(test.toString().contains("[]"));
}
public void test_hashCode() {
ExternalIdSearch a = ExternalIdSearch.of(_id11, _id12);
ExternalIdSearch b = ExternalIdSearch.of(_id11, _id12);
assertEquals(a.hashCode(), b.hashCode());
}
public void test_withExternalIdRemoved_null() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertThrows(() -> base.withExternalIdRemoved(null), IllegalArgumentException.class);
}
public void test_canMatch_NONE() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.NONE);
assertEquals(true, test.canMatch());
test = test.withExternalIdAdded(_id11);
assertEquals(true, test.canMatch());
}
// -------------------------------------------------------------------------
public void test_withSearchType() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(ExternalIdSearchType.ANY, base.getSearchType());
ExternalIdSearch test = base.withSearchType(ExternalIdSearchType.EXACT);
assertEquals(ExternalIdSearchType.EXACT, test.getSearchType());
}
public void test_constructor_ExternalId() {
ExternalIdSearch test = ExternalIdSearch.of(_id11);
assertEquals(1, test.size());
assertEquals(Sets.newHashSet(_id11), test.getExternalIds());
assertEquals(ExternalIdSearchType.ANY, test.getSearchType());
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_varargs_null() {
ExternalId[] args = null;
ExternalIdSearch.of(args);
}
// -------------------------------------------------------------------------
public void test_constructor_Iterable_empty() {
ExternalIdSearch test = ExternalIdSearch.of(new ArrayList<ExternalId>());
assertEquals(0, test.size());
}
// -------------------------------------------------------------------------
public void test_constructor_varargs_noExternalIds() {
ExternalId[] args = new ExternalId[0];
ExternalIdSearch test = ExternalIdSearch.of(args);
assertEquals(0, test.size());
}
public void test_withSearchType_same() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalIdSearchType.ALL, ExternalId.of("A", "B"));
assertSame(base, base.withSearchType(ExternalIdSearchType.ALL));
}
// -------------------------------------------------------------------------
public void test_constructor_noargs() {
ExternalIdSearch test = ExternalIdSearch.of();
assertEquals(0, test.size());
}
public void test_withSearchType_null() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertThrows(() -> test.withSearchType(null), IllegalArgumentException.class);
}
// -------------------------------------------------------------------------
public void test_size() {
assertEquals(0, ExternalIdSearch.of().size());
assertEquals(1, ExternalIdSearch.of(_id11).size());
assertEquals(2, ExternalIdSearch.of(_id11, _id12).size());
}
public void test_constructor_varargs_twoExternalIds() {
ExternalId[] args = new ExternalId[] {_id11, _id12};
ExternalIdSearch test = ExternalIdSearch.of(args);
assertEquals(2, test.size());
assertEquals(Sets.newHashSet(_id11, _id12), test.getExternalIds());
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_containsAny_null() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
test.containsAny(null);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_varargs_noNulls() {
ExternalId[] args = new ExternalId[] {_id11, null, _id12};
ExternalIdSearch.of(args);
}
// -------------------------------------------------------------------------
public void test_contains() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, test.contains(_id11));
assertEquals(true, test.contains(_id11));
assertEquals(false, test.contains(_id21));
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_Iterable_null() {
ExternalIdSearch.of((Iterable<ExternalId>) null);
}
public void test_contains_null() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(false, test.contains(null));
}
