/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.id;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.testng.annotations.Test;
import com.google.common.collect.Sets;
import com.opengamma.util.test.TestGroup;
/**
* Test {@link ExternalIdSearch}.
*/
@Test(groups = TestGroup.UNIT)
public class ExternalIdSearchTest {
private final ExternalId _id11 = ExternalId.of("D1", "V1");
private final ExternalId _id21 = ExternalId.of("D2", "V1");
private final ExternalId _id12 = ExternalId.of("D1", "V2");
//-------------------------------------------------------------------------
public void test_constructor_noargs() {
ExternalIdSearch test = ExternalIdSearch.of();
assertEquals(0, test.size());
}
//-------------------------------------------------------------------------
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_ExternalId_null() {
ExternalIdSearch.of((ExternalId) null);
}
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());
}
//-------------------------------------------------------------------------
public void test_constructor_varargs_noExternalIds() {
ExternalId[] args = new ExternalId[0];
ExternalIdSearch test = ExternalIdSearch.of(args);
assertEquals(0, test.size());
}
public void test_constructor_varargs_oneExternalId() {
ExternalId[] args = new ExternalId[] {_id11};
ExternalIdSearch test = ExternalIdSearch.of(args);
assertEquals(1, test.size());
assertEquals(Sets.newHashSet(_id11), test.getExternalIds());
}
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_constructor_varargs_null() {
ExternalId[] args = null;
ExternalIdSearch.of(args);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_varargs_noNulls() {
ExternalId[] args = new ExternalId[] {_id11, null, _id12};
ExternalIdSearch.of(args);
}
//-------------------------------------------------------------------------
public void test_constructor_Iterable_empty() {
ExternalIdSearch test = ExternalIdSearch.of(new ArrayList<ExternalId>());
assertEquals(0, test.size());
}
public void test_constructor_Iterable_two() {
ExternalIdSearch test = ExternalIdSearch.of(Arrays.asList(_id11, _id12));
assertEquals(2, test.size());
assertEquals(Sets.newHashSet(_id11, _id12), test.getExternalIds());
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_Iterable_null() {
ExternalIdSearch.of((Iterable<ExternalId>) null);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_Iterable_noNulls() {
ExternalIdSearch.of(Arrays.asList(_id11, null, _id12));
}
//-------------------------------------------------------------------------
public void test_constructor_IterableType_empty() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.EXACT, new ArrayList<ExternalId>());
assertEquals(0, test.size());
assertEquals(ExternalIdSearchType.EXACT, test.getSearchType());
}
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());
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_IterableType_null() {
ExternalIdSearch.of(ExternalIdSearchType.EXACT, (Iterable<ExternalId>) null);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_IterableType_noNulls() {
ExternalIdSearch.of(ExternalIdSearchType.EXACT, Arrays.asList(_id11, null, _id12));
}
//-------------------------------------------------------------------------
public void test_singleExternalIdDifferentConstructors() {
assertTrue(ExternalIdSearch.of(_id11).equals(ExternalIdSearch.of(Collections.singleton(_id11))));
}
public void test_singleVersusMultipleExternalId() {
assertFalse(ExternalIdSearch.of(_id11).equals(ExternalIdSearch.of(_id11, _id12)));
assertFalse(ExternalIdSearch.of(_id11, _id12).equals(ExternalIdSearch.of(_id11)));
}
//-------------------------------------------------------------------------
public void test_withExternalIdAdded() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(1, base.size());
ExternalIdSearch test = base.withExternalIdAdded(ExternalId.of("A", "C"));
assertEquals(1, base.size());
assertEquals(2, test.size());
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "B")));
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "C")));
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_withExternalIdAdded_null() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalId.of("A", "B"));
test.withExternalIdAdded(null);
}
//-------------------------------------------------------------------------
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_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_null() {
ExternalIdSearch base = ExternalIdSearch.of(ExternalId.of("A", "B"));
assertEquals(1, base.size());
ExternalIdSearch test = base.withExternalIdRemoved(null);
assertEquals(1, base.size());
assertEquals(1, test.size());
assertTrue(test.getExternalIds().contains(ExternalId.of("A", "B")));
}
//-------------------------------------------------------------------------
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());
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_withSearchType_null() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalId.of("A", "B"));
test.withSearchType(null);
}
//-------------------------------------------------------------------------
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_iterator() {
Set<ExternalId> expected = new HashSet<ExternalId>();
expected.add(_id11);
expected.add(_id12);
Iterable<ExternalId> base = ExternalIdSearch.of(_id11, _id12);
Iterator<ExternalId> test = base.iterator();
assertEquals(true, test.hasNext());
assertEquals(true, expected.remove(test.next()));
assertEquals(true, test.hasNext());
assertEquals(true, expected.remove(test.next()));
assertEquals(false, test.hasNext());
assertEquals(0, expected.size());
}
//-------------------------------------------------------------------------
public void test_matches1_EXACT() {
ExternalIdSearch test1 = ExternalIdSearch.of(ExternalIdSearchType.EXACT, _id11);
assertEquals(true, test1.matches(_id11));
assertEquals(false, test1.matches(_id21));
ExternalIdSearch test2 = ExternalIdSearch.of(ExternalIdSearchType.EXACT, _id11, _id21);
assertEquals(false, test2.matches(_id11));
assertEquals(false, test2.matches(_id12));
assertEquals(false, test2.matches(_id21));
}
public void test_matches1_ALL() {
ExternalIdSearch test1 = ExternalIdSearch.of(ExternalIdSearchType.ALL, _id11);
assertEquals(true, test1.matches(_id11));
assertEquals(false, test1.matches(_id12));
ExternalIdSearch test2 = ExternalIdSearch.of(ExternalIdSearchType.ALL, _id11, _id21);
assertEquals(false, test2.matches(_id11));
assertEquals(false, test2.matches(_id12));
assertEquals(false, test2.matches(_id21));
}
public void test_matches1_ANY() {
ExternalIdSearch test1 = ExternalIdSearch.of(ExternalIdSearchType.ANY, _id11);
assertEquals(true, test1.matches(_id11));
assertEquals(false, test1.matches(_id12));
ExternalIdSearch test2 = ExternalIdSearch.of(ExternalIdSearchType.ANY, _id11, _id21);
assertEquals(true, test2.matches(_id11));
assertEquals(false, test2.matches(_id12));
assertEquals(true, test2.matches(_id21));
}
public void test_matches1_NONE() {
ExternalIdSearch test1 = ExternalIdSearch.of(ExternalIdSearchType.NONE, _id11);
assertEquals(false, test1.matches(_id11));
assertEquals(true, test1.matches(_id12));
ExternalIdSearch test2 = ExternalIdSearch.of(ExternalIdSearchType.NONE, _id11, _id21);
assertEquals(false, test2.matches(_id11));
assertEquals(true, test2.matches(_id12));
assertEquals(false, test2.matches(_id21));
}
//-------------------------------------------------------------------------
public void test_matches_EXACT() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.EXACT, _id11, _id12);
assertEquals(true, test.matches(ExternalIdSearch.of(_id11, _id12)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id11, _id12, _id21)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id11)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id12)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id21)));
assertEquals(false, test.matches(ExternalIdSearch.of()));
}
public void test_matches_ALL() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.ALL, _id11, _id12);
assertEquals(true, test.matches(ExternalIdSearch.of(_id11, _id12)));
assertEquals(true, test.matches(ExternalIdSearch.of(_id11, _id12, _id21)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id11)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id12)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id21)));
assertEquals(false, test.matches(ExternalIdSearch.of()));
}
public void test_matches_ANY() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.ANY, _id11, _id12);
assertEquals(true, test.matches(ExternalIdSearch.of(_id11, _id12)));
assertEquals(true, test.matches(ExternalIdSearch.of(_id11, _id12, _id21)));
assertEquals(true, test.matches(ExternalIdSearch.of(_id11)));
assertEquals(true, test.matches(ExternalIdSearch.of(_id12)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id21)));
assertEquals(false, test.matches(ExternalIdSearch.of()));
}
public void test_matches_NONE() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.NONE, _id11, _id12);
assertEquals(false, test.matches(ExternalIdSearch.of(_id11, _id12)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id11, _id12, _id21)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id11)));
assertEquals(false, test.matches(ExternalIdSearch.of(_id12)));
assertEquals(true, test.matches(ExternalIdSearch.of(_id21)));
assertEquals(true, test.matches(ExternalIdSearch.of()));
}
//-------------------------------------------------------------------------
public void test_containsAll1() {
ExternalIdSearch test = ExternalIdSearch.of(_id11);
assertEquals(false, test.containsAll(ExternalIdSearch.of(_id11, _id12)));
assertEquals(true, test.containsAll(ExternalIdSearch.of(_id11)));
assertEquals(false, test.containsAll(ExternalIdSearch.of(_id12)));
assertEquals(false, test.containsAll(ExternalIdSearch.of(_id21)));
assertEquals(true, test.containsAll(ExternalIdSearch.of()));
}
public void test_containsAll2() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, test.containsAll(ExternalIdSearch.of(_id11, _id12)));
assertEquals(true, test.containsAll(ExternalIdSearch.of(_id11)));
assertEquals(true, test.containsAll(ExternalIdSearch.of(_id12)));
assertEquals(false, test.containsAll(ExternalIdSearch.of(_id21)));
assertEquals(true, test.containsAll(ExternalIdSearch.of()));
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_containsAll_null() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
test.containsAll(null);
}
//-------------------------------------------------------------------------
public void test_containsAny() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(true, test.containsAny(ExternalIdSearch.of(_id11, _id12)));
assertEquals(true, test.containsAny(ExternalIdSearch.of(_id11)));
assertEquals(true, test.containsAny(ExternalIdSearch.of(_id12)));
assertEquals(false, test.containsAny(ExternalIdSearch.of(_id21)));
assertEquals(false, test.containsAny(ExternalIdSearch.of()));
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_containsAny_null() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
test.containsAny(null);
}
//-------------------------------------------------------------------------
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));
}
public void test_contains_null() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertEquals(false, test.contains(null));
}
//-------------------------------------------------------------------------
public void test_canMatch_EXACT() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.EXACT);
assertEquals(false, ExternalIdSearch.canMatch(test));
test = test.withExternalIdAdded(_id11);
assertEquals(true, ExternalIdSearch.canMatch(test));
}
public void test_canMatch_ALL() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.ALL);
assertEquals(false, ExternalIdSearch.canMatch(test));
test = test.withExternalIdAdded(_id11);
assertEquals(true, ExternalIdSearch.canMatch(test));
}
public void test_canMatch_ANY() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.ANY);
assertEquals(false, ExternalIdSearch.canMatch(test));
test = test.withExternalIdAdded(_id11);
assertEquals(true, ExternalIdSearch.canMatch(test));
}
public void test_canMatch_NONE() {
ExternalIdSearch test = ExternalIdSearch.of(ExternalIdSearchType.NONE);
assertEquals(true, ExternalIdSearch.canMatch(test));
test = test.withExternalIdAdded(_id11);
assertEquals(true, ExternalIdSearch.canMatch(test));
}
public void test_canMatch_null() {
assertEquals(true, ExternalIdSearch.canMatch(null));
}
//-------------------------------------------------------------------------
public void test_equals_same_empty() {
ExternalIdSearch a1 = ExternalIdSearch.of();
ExternalIdSearch a2 = ExternalIdSearch.of();
assertEquals(true, a1.equals(a1));
assertEquals(true, a1.equals(a2));
assertEquals(true, a2.equals(a1));
assertEquals(true, a2.equals(a2));
}
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 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_hashCode() {
ExternalIdSearch a = ExternalIdSearch.of(_id11, _id12);
ExternalIdSearch b = ExternalIdSearch.of(_id11, _id12);
assertEquals(a.hashCode(), b.hashCode());
}
public void test_toString_empty() {
ExternalIdSearch test = ExternalIdSearch.of();
assertTrue(test.toString().contains("[]"));
}
public void test_toString_nonEmpty() {
ExternalIdSearch test = ExternalIdSearch.of(_id11, _id12);
assertTrue(test.toString().contains(_id11.toString()));
assertTrue(test.toString().contains(_id12.toString()));
}
}