java类org.hamcrest.collection.IsIterableContainingInAnyOrder的实例源码

@Test
public void testTraverseGraph() throws CouldNotReceiveResultException, ColumnNameMismatchException {
  // Setup
  List<PositionListIndex> pliList = fixture.getPLIList();
  LinkedList<String> columnNames = new LinkedList<>();
  Integer i;
  for (i = 0; i < pliList.size(); i++) {
    columnNames.add(i.toString());
  }
  ImmutableList<String> immutableColumnNames = ImmutableList.copyOf(columnNames);

  UccGraphTraverser graph = new UccGraphTraverser();
  graph.init(fixture.getPLIList(), mock(UniqueColumnCombinationResultReceiver.class), "relation",
             immutableColumnNames);
  Collection<ColumnCombinationBitset>
      expectedUniqueColumnCombinations =
      fixture.getExpectedBitset();

  //Execute functionality
  graph.traverseGraph();

  //Check result
  assertThat(graph.getMinimalPositiveColumnCombinations(), IsIterableContainingInAnyOrder
      .containsInAnyOrder(expectedUniqueColumnCombinations.toArray(
          new ColumnCombinationBitset[expectedUniqueColumnCombinations.size()])));
}

@Test
public void testCalculateConditions() throws Exception {
  //Setup
  PositionListIndex uniquePLI = fixture.getUniquePLIForConditionTest();
  PositionListIndex conditionPLI = fixture.getConditionPLIForConditionTest();
  List<LongArrayList> expectedConditions = fixture.getExpectedConditions();
  //Execute functionality
  List<LongArrayList> unsatisfiedClusters = new LinkedList<>();
  AndConditionTraverser traverser = new AndConditionTraverser(new Dcucc());

  List<LongArrayList>
      actualConditions =
      traverser
          .calculateConditions(uniquePLI, conditionPLI, fixture.getFrequency(),
                               unsatisfiedClusters);
  //Check result
  assertThat(actualConditions,
             IsIterableContainingInAnyOrder.containsInAnyOrder(
                 expectedConditions.toArray()
             )
  );
  assertEquals(unsatisfiedClusters.get(0), fixture.getExpectedUnsatisfiedClusters().get(0));
}

@Test
public void getGroups() throws Exception {
    PowerMockito.mockStatic(AzureADGraphClient.class);
    Mockito.when(AzureADGraphClient.getUserMembershipsV1(Constants.BEARER_TOKEN))
            .thenReturn(Constants.USERGROUPS_JSON);

    final UserPrincipal principal = new UserPrincipal();

    final List<UserGroup> groups = principal.getGroups(Constants.BEARER_TOKEN);
    final List<UserGroup> targetedGroups = new ArrayList<UserGroup>();
    targetedGroups.add(new UserGroup("12345678-7baf-48ce-96f4-a2d60c26391e", "group1"));
    targetedGroups.add(new UserGroup("12345678-e757-4474-b9c4-3f00a9ac17a0", "group2"));
    targetedGroups.add(new UserGroup("12345678-86a4-4237-aeb0-60bad29c1de0", "group3"));

    Assert.assertThat(groups, IsIterableContainingInAnyOrder.containsInAnyOrder(groups.toArray()));
}

@Test
public void downGradeTypeTest() {
    TypesModel typesModel = new TypesModel(new HashSet<>(
            Arrays.asList(
                    ModelClassBase.class,
                    ModelClassWithTypeParameter.class,
                    ModelClassWithoutTypeParameter.class
            )), null, null);

    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(NonModelClassWithoutTypeParameter.class),
            IsIterableContainingInAnyOrder.containsInAnyOrder(ModelClassWithoutTypeParameter.class));
    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(NonModelClassWithTypeParameter.class, Float.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(ModelClassWithTypeParameter.class, Float.class, Date.class)));
    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(NonModelClassWithoutTypeParameterExtendingModelClassWithTypeParameter.class),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(ModelClassWithTypeParameter.class, BigInteger.class, Date.class)));
    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(NonModelClassWithTypeParameterExtendingNonModelClass.class),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(ModelClassWithTypeParameter.class, Float.class, Date.class)));

}

@Test
public void getClassHierarchyNodeForType() throws Exception {
    TypesModel.ClassHierarchyNode classHierarchyNodeForType = typesModel.getClassHierarchyNodeForType(A.class);
    assertNotNull(classHierarchyNodeForType);
    assertTrue(classHierarchyNodeForType.isPolymorphic());
    assertEquals(classHierarchyNodeForType.getAllConcreteChildren().size(), 6); // all

    classHierarchyNodeForType = typesModel.getClassHierarchyNodeForType(AB.class);
    assertNotNull(classHierarchyNodeForType);
    assertFalse(classHierarchyNodeForType.isPolymorphic());
    assertEquals(classHierarchyNodeForType.getAllConcreteChildren().size(), 1); // AB

    classHierarchyNodeForType = typesModel.getClassHierarchyNodeForType(AA.class);
    assertNotNull(classHierarchyNodeForType);
    assertTrue(classHierarchyNodeForType.isPolymorphic());
    assertEquals(classHierarchyNodeForType.getAllConcreteChildren().size(), 4); // AA, AAA, AAB, AAAA

    classHierarchyNodeForType = typesModel.getClassHierarchyNodeForType(X.class);
    assertNotNull(classHierarchyNodeForType);
    assertTrue(classHierarchyNodeForType.isPolymorphic());
    assertThat(classHierarchyNodeForType.getAllConcreteChildren(),
            IsIterableContainingInAnyOrder.containsInAnyOrder(A.class, AA.class, AB.class, AAA.class, AAB.class, AAAA.class, AAX.class, AX.class, ABX.class));


}

@Test
public void getAssignableTypesWithinClassHierarchy() throws Exception {
    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(A.class, Integer.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(A.class, Integer.class)));

    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(XY.class, Float.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(A.class, Float.class)));

    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(XY.class, Integer.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(A.class, Integer.class),
                    AAX.class));

    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(XY.class, BigInteger.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(A.class, BigInteger.class),
                    TypeUtils.parameterize(AA.class, BigInteger.class),
                    AAB.class,
                    AAA.class,
                    ABX.class,
                    AAAA.class));

}

/**
 * Tests that the conjunct future returns upon completion the collection of all future values
 */
@Test
public void testConjunctFutureValue() throws ExecutionException, InterruptedException {
    java.util.concurrent.CompletableFuture<Integer> future1 = java.util.concurrent.CompletableFuture.completedFuture(1);
    java.util.concurrent.CompletableFuture<Long> future2 = java.util.concurrent.CompletableFuture.completedFuture(2L);
    java.util.concurrent.CompletableFuture<Double> future3 = new java.util.concurrent.CompletableFuture<>();

    ConjunctFuture<Collection<Number>> result = FutureUtils.combineAll(Arrays.asList(future1, future2, future3));

    assertFalse(result.isDone());

    future3.complete(.1);

    assertTrue(result.isDone());

    assertThat(result.get(), IsIterableContainingInAnyOrder.<Number>containsInAnyOrder(1, 2L, .1));
}

@Test
public void testUpdateCommits() throws IOException
{
    when(repositoryPullRequestDao.findRequestByRemoteId(eq(repository), anyLong())).thenReturn(null);

    RepositoryCommitMapping commitMapping = mock(RepositoryCommitMapping.class);
    when(commitMapping.getNode()).thenReturn("original");
    when(pullRequestMapping.getCommits()).thenReturn(new RepositoryCommitMapping[] { commitMapping });
    target.setCommits(new RepositoryCommitMapping[] { commitMapping });

    RepositoryCommit repositoryCommit = mockCommit("aaa");
    when(gitHubPullRequestService.getCommits(any(IRepositoryIdProvider.class), anyInt())).thenReturn(Arrays.asList(repositoryCommit));

    testedClass.processPullRequest(repository, pullRequest);
    verify(repositoryPullRequestDao).saveCommit(eq(repository), saveCommitCaptor.capture());
    assertEquals(saveCommitCaptor.getValue().get(RepositoryCommitMapping.NODE), "aaa");

    verify(repositoryPullRequestDao).unlinkCommits(eq(repository), eq(target), argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
    verify(repositoryPullRequestDao).removeCommits(argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
    verify(notificationService, times(1)).broadcast(anyObject());
}

@Test
public void testUpdateCommitRetargeted() throws IOException
{
    final PullRequestMarker destination = mockRef("destinationBranch2");
    when(pullRequest.getBase()).thenReturn(destination);

    RepositoryCommitMapping commitMapping = mock(RepositoryCommitMapping.class);
    when(commitMapping.getNode()).thenReturn("original");
    when(pullRequestMapping.getCommits()).thenReturn(new RepositoryCommitMapping[] { commitMapping });
    target.setCommits(new RepositoryCommitMapping[] { commitMapping });

    RepositoryCommit repositoryCommit = mockCommit("aaa");
    when(gitHubPullRequestService.getCommits(any(IRepositoryIdProvider.class), anyInt())).thenReturn(Arrays.asList(repositoryCommit));

    testedClass.processPullRequest(repository, pullRequest);
    verify(repositoryPullRequestDao).saveCommit(eq(repository), saveCommitCaptor.capture());
    assertEquals(saveCommitCaptor.getValue().get(RepositoryCommitMapping.NODE), "aaa");

    verify(repositoryPullRequestDao).unlinkCommits(eq(repository), eq(target), argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
    verify(repositoryPullRequestDao).removeCommits(argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
}

@Test
public void testUpdateCommitStatusChanged() throws IOException
{
    when(pullRequest.getState()).thenReturn("closed");

    RepositoryCommitMapping commitMapping = mock(RepositoryCommitMapping.class);
    when(commitMapping.getNode()).thenReturn("original");
    when(pullRequestMapping.getCommits()).thenReturn(new RepositoryCommitMapping[] { commitMapping });
    target.setCommits(new RepositoryCommitMapping[] { commitMapping });

    RepositoryCommit repositoryCommit = mockCommit("aaa");
    when(gitHubPullRequestService.getCommits(any(IRepositoryIdProvider.class), anyInt())).thenReturn(Arrays.asList(repositoryCommit));

    testedClass.processPullRequest(repository, pullRequest);
    verify(repositoryPullRequestDao).saveCommit(eq(repository), saveCommitCaptor.capture());
    assertEquals(saveCommitCaptor.getValue().get(RepositoryCommitMapping.NODE), "aaa");

    verify(repositoryPullRequestDao).unlinkCommits(eq(repository), eq(target), argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
    verify(repositoryPullRequestDao).removeCommits(argThat(IsIterableContainingInAnyOrder.containsInAnyOrder(commitMapping)));
}

@Test
public void should_return_common_and_specific_parameters() {
    // when
    final List<Parameter> actionParams = action.getParameters(Locale.US);

    // then
    assertThat(actionParams, hasSize(8));

    final List<String> paramNames = actionParams.stream().map(Parameter::getName).collect(toList());
    assertThat(paramNames, IsIterableContainingInAnyOrder.containsInAnyOrder(COLUMN_ID.getKey(), //
            ActionsUtils.CREATE_NEW_COLUMN, //
            ROW_ID.getKey(), //
            SCOPE.getKey(), //
            FILTER.getKey(), //
            CELL_VALUE_PARAMETER, //
            REPLACE_VALUE_PARAMETER, //
            REPLACE_ENTIRE_CELL_PARAMETER));
}

@Test
public void test_parameters() {
    // when
    final List<Parameter> actionParams = action.getParameters(Locale.US);

    // then
    assertThat(actionParams, hasSize(7));

    final List<String> paramNames = actionParams.stream().map(Parameter::getName).collect(toList());
    assertThat(paramNames, IsIterableContainingInAnyOrder.containsInAnyOrder( //
            ActionsUtils.CREATE_NEW_COLUMN,
            COLUMN_ID.getKey(), //
            SCOPE.getKey(), //
            ROW_ID.getKey(), //
            ORIGINAL_VALUE_PARAMETER, //
            FILTER.getKey(), //
            NEW_VALUE_PARAMETER) //
    );
}

@Test
public void testPun() {
  Node i = getNode("http://example.org/i");
  Node j = getNode("http://example.org/j");
  Node k = getNode("http://example.org/k");

  RelationshipType p = RelationshipType.withName("http://example.org/p");
  Relationship relationship = getOnlyElement(GraphUtil.getRelationships(i, j, p));
  assertThat("OPE edge should start with the subject.", relationship.getStartNode(), is(i));
  assertThat("OPE edge should end with the target.", relationship.getEndNode(), is(j));
  relationship = getOnlyElement(GraphUtil.getRelationships(i, k, OwlRelationships.RDFS_SUBCLASS_OF));
  assertThat("Subclass edge should start with i.", relationship.getStartNode(), is(i));
  assertThat("Subclass edge should end with k.", relationship.getEndNode(), is(k));
  assertThat("i is both a class an a named individual" , i.getLabels(), 
      is(IsIterableContainingInAnyOrder.containsInAnyOrder(OwlLabels.OWL_CLASS, OwlLabels.OWL_NAMED_INDIVIDUAL)));
}

/**
 * Filter by class type
 */
@Test
public void filter_elements_by_type () {

    List<Object> randomObjects = Lists.newArrayList();
    randomObjects.add(new Integer(15));
    randomObjects.add(new Double(12));
    randomObjects.add("hello");
    randomObjects.add(Lists.newArrayList());
    randomObjects.add(Maps.newConcurrentMap());
    randomObjects.add("world");

    Iterable<String> strings = Iterables.filter(randomObjects, String.class);

    assertThat(strings, IsIterableContainingInAnyOrder.
            <String>containsInAnyOrder("hello", "world"));
}

@Test
public void testGetUngroundedLoops2()
{
    BehaviourBlock bb = new BehaviourBlock();
    bb.readXML("<bml "+TestUtil.getDefNS()+"id=\"bml1\"><gesture id=\"g1\" start=\"g2:start\" lexeme=\"BEAT\"/>"
            + "<gesture id=\"g2\" lexeme=\"BEAT\" end=\"g3:end\"/>" + 
            "<gesture id=\"g3\" stroke=\"g1:stroke\" lexeme=\"BEAT\"/></bml>");
    parser.addBehaviourBlock(bb);
    List<List<Behaviour>> list = parser.getUngroundedLoops("bml1", "g1");
    assertEquals(1, list.size());
    assertThat(list.get(0),
            IsIterableContainingInAnyOrder.containsInAnyOrder(parser.getBehaviour("bml1", "g2"), parser.getBehaviour("bml1", "g3")));

    list = parser.getUngroundedLoops("bml1", "g2");
    assertEquals(1, list.size());
    assertThat(list.get(0),
            IsIterableContainingInAnyOrder.containsInAnyOrder(parser.getBehaviour("bml1", "g1"), parser.getBehaviour("bml1", "g3")));

    list = parser.getUngroundedLoops("bml1", "g3");
    assertEquals(1, list.size());
    assertThat(list.get(0),
            IsIterableContainingInAnyOrder.containsInAnyOrder(parser.getBehaviour("bml1", "g1"), parser.getBehaviour("bml1", "g2")));
}

@Test
public void testGetNoUngroundedLoopsWhenGrounded2()
{
    BehaviourBlock bb = new BehaviourBlock();
    bb.readXML("<bml "+TestUtil.getDefNS()+"id=\"bml1\"><gesture id=\"g1\" start=\"g2:start\" lexeme=\"BEAT\"/>"
            + "<gesture stroke=\"1\" id=\"g2\" lexeme=\"BEAT\" end=\"g3:end\"/>"
            + "<gesture id=\"g3\" stroke=\"g1:stroke\" lexeme=\"BEAT\"/></bml>");
    parser.addBehaviourBlock(bb);
    List<List<Behaviour>> list = parser.getUngroundedLoops("bml1", "g1");
    assertEquals(0, list.size());

    list = parser.getUngroundedLoops("bml1", "g2");
    assertEquals(1, list.size());
    assertThat(list.get(0),
            IsIterableContainingInAnyOrder.containsInAnyOrder(parser.getBehaviour("bml1", "g1"), parser.getBehaviour("bml1", "g3")));

    list = parser.getUngroundedLoops("bml1", "g3");
    assertEquals(0, list.size());
}

/**
 * Filter by class type
 */
@Test
public void filter_elements_by_type () {

    List<Object> randomObjects = Lists.newArrayList();
    randomObjects.add(new Integer(15));
    randomObjects.add(new Double(12));
    randomObjects.add("hello");
    randomObjects.add(Lists.newArrayList());
    randomObjects.add(Maps.newConcurrentMap());
    randomObjects.add("world");

    Iterable<String> strings = Iterables.filter(randomObjects, String.class);

    assertThat(strings, IsIterableContainingInAnyOrder.
            <String>containsInAnyOrder("hello", "world"));
}

/**
 * Unique Graph tests
 */
@Test
public void testAddSimpleInsert() {
  //Setup
  PruningGraph graph = new PruningGraph(5, 10, true);

  ColumnCombinationBitset actualColumnCombinationAC = fixture.columnCombinationAC;
  ColumnCombinationBitset actualColumnCombinationBC = fixture.columnCombinationBC;

  ColumnCombinationBitset expectedKeyA = fixture.columnCombinationA;
  ColumnCombinationBitset expectedKeyB = fixture.columnCombinationB;
  ColumnCombinationBitset expectedKeyC = fixture.columnCombinationC;

  List<ColumnCombinationBitset> expectedList = new LinkedList<>();
  expectedList.add(actualColumnCombinationAC);
  expectedList.add(actualColumnCombinationBC);

  //Execute functionality
  graph.add(actualColumnCombinationAC);
  graph.add(actualColumnCombinationBC);

  //Check results
  assertTrue(graph.columnCombinationMap.containsKey(expectedKeyA));
  assertEquals(actualColumnCombinationAC, graph.columnCombinationMap.get(expectedKeyA).get(0));

  assertTrue(graph.columnCombinationMap.containsKey(expectedKeyB));
  assertEquals(actualColumnCombinationBC, graph.columnCombinationMap.get(expectedKeyB).get(0));

  assertTrue(graph.columnCombinationMap.containsKey(expectedKeyC));
  assertThat(graph.columnCombinationMap.get(expectedKeyC), IsIterableContainingInAnyOrder
      .containsInAnyOrder(
          expectedList.toArray(new ColumnCombinationBitset[expectedList.size()])));

}

/**
 * Unique Graph tests
 */
@Test
public void testAddSimpleInsert() {
    //Setup
    PruningGraph graph = new PruningGraph(5, 10, true);

    ColumnCombinationBitset actualColumnCombinationAC = fixture.columnCombinationAC;
    ColumnCombinationBitset actualColumnCombinationBC = fixture.columnCombinationBC;

    ColumnCombinationBitset expectedKeyA = fixture.columnCombinationA;
    ColumnCombinationBitset expectedKeyB = fixture.columnCombinationB;
    ColumnCombinationBitset expectedKeyC = fixture.columnCombinationC;

    List<ColumnCombinationBitset> expectedList = new LinkedList<>();
    expectedList.add(actualColumnCombinationAC);
    expectedList.add(actualColumnCombinationBC);

    //Execute functionality
    graph.add(actualColumnCombinationAC);
    graph.add(actualColumnCombinationBC);

    //Check results
    assertTrue(graph.columnCombinationMap.containsKey(expectedKeyA));
    assertEquals(actualColumnCombinationAC, graph.columnCombinationMap.get(expectedKeyA).get(0));

    assertTrue(graph.columnCombinationMap.containsKey(expectedKeyB));
    assertEquals(actualColumnCombinationBC, graph.columnCombinationMap.get(expectedKeyB).get(0));

    assertTrue(graph.columnCombinationMap.containsKey(expectedKeyC));
    assertThat(graph.columnCombinationMap.get(expectedKeyC), IsIterableContainingInAnyOrder.containsInAnyOrder(expectedList.toArray(new ColumnCombinationBitset[expectedList.size()])));

}

private void checkPojo(Pojo expected, Pojo actual) {
    assertThat("results[" + expected.id + "]", actual, SamePropertyValuesAs.samePropertyValuesAs(expected));
    assertThat("results[" + expected.id + "].id", actual.id, CoreMatchers.equalTo(expected.id));
    assertThat("results[" + expected.id + "].title", actual.title, CoreMatchers.equalTo(expected.title));
    assertThat("results[" + expected.id + "].content", actual.content, CoreMatchers.equalTo(expected.content));
    assertThat("results[" + expected.id + "].category", actual.category, IsIterableContainingInAnyOrder.containsInAnyOrder(expected.category.toArray()));
}

private void assertTimeSeries(TimeSeries expectedTimeSeries1,
                              TimeSeries expectedTimeSeries2,
                              List<TimeSeries> actualTimeSeries) {

  assertThat(actualTimeSeries, IsIterableContainingInAnyOrder.containsInAnyOrder(
      expectedTimeSeries1, expectedTimeSeries2));
}

@Test
public void classParserTest() {
    TypesModel typesModel = new TypesModel(new HashSet<>(Arrays.asList(Outer.class)), null, null);
    assertTrue(typesModel.allClasses.size() == 3);
    assertThat(typesModel.allClasses, IsIterableContainingInAnyOrder.containsInAnyOrder(
            Outer.class, Outer.Inner.class, Outer.Inner.InnerInner.class
    ));
}

@Test
public void getAssignableTypesWithinClassHierarchyCraz() throws Exception {
    AInterface<Integer> aInterface = new AList<Integer, Map<Integer, Long>>();

    assertThat(typesModel.getAssignableTypesWithinClassHierarchy(TypeUtils.parameterize(AInterface.class, Integer.class)),
            IsIterableContainingInAnyOrder.containsInAnyOrder(
                    TypeUtils.parameterize(AList.class, Integer.class,
                            TypeUtils.parameterize(Map.class, Integer.class, Long.class))
            ));

}

@Test
public void getDeclaredAndInheritedMethodsTest() throws Exception {
    List<MethodTypePair> declaredAndInheritedMethods = ReflectionHelper.getDeclaredAndInheritedMethods(TestPojo.class);
    assertEquals(3, declaredAndInheritedMethods.size());
    assertThat(declaredAndInheritedMethods, IsIterableContainingInAnyOrder.containsInAnyOrder(
            new MethodTypeBaseMatcher(TestPojo.class.getDeclaredMethod("getAttributesOfType", Object.class)),
            new MethodTypeBaseMatcher(TestPojo.class.getDeclaredMethod("init")),
            new MethodTypeBaseMatcher(TestPojo.class.getDeclaredMethod("preSave"))));
}

public static <T> Matcher<Iterable<? extends T>> inAnyOrder(Iterable<T> items) {
    final Collection<Matcher<? super T>> matchers = new ArrayList<>();
    for (final Object item : items) {
        matchers.add(IsEqual.equalTo(item));
    }
    return IsIterableContainingInAnyOrder.containsInAnyOrder(matchers);
}

@Test
public void getClassesOfTypeTest()
{
    class A{};
    class B extends A{};
    class C extends B{};
    class D extends A{};
    C c = new C();
    B b = new B();        
    A[] list = {new A(), c, b, new D()};
    assertThat(ArrayUtils.getClassesOfType(list,B.class), IsIterableContainingInAnyOrder.containsInAnyOrder(c,b));
}

@Test
public void getClassesOfTypeTest()
{
    class A{};
    class B extends A{};
    class C extends B{};
    class D extends A{};
    C c = new C();
    B b = new B();        
    List<A> list = ImmutableList.of(new A(), c, b, new D());
    assertThat(CollectionUtils.getClassesOfType(list,B.class), IsIterableContainingInAnyOrder.containsInAnyOrder(c,b));
}

@Test
public void testIntersect()
{
    List<VJoint> vj1 = Lists.newArrayList(new VJoint("h1-j1", "j1"), new VJoint("h1-j2", "j2"), new VJoint("h1-j3", "j3"), new VJoint(
            "h1-j4", "j4"));
    List<VJoint> vj2 = Lists.newArrayList(new VJoint("h1-j2", "j2"), new VJoint("h1-j4", "j4"), new VJoint("h1-j5", "j5"), new VJoint(
            "h1-j9", "j9"));
    Collection<VJoint> vj = VJointUtils.intersection(vj1, vj2);
    assertEquals(2, vj.size());
    assertThat(VJointUtils.transformToSidSet(vj), IsIterableContainingInAnyOrder.containsInAnyOrder("j2", "j4"));
}

@Test
public void testGatherJointSids()
{
    Set<String> gathered = VJointUtils.gatherJointSids(
            ImmutableSet.of("unknown1", "joint1", "joint2", "unknown2").toArray(new String[4]), joint1);
    assertThat(gathered, IsIterableContainingInAnyOrder.containsInAnyOrder("joint1", "joint2"));
}

@Test
public void testTransformToSidSetWithNulls()
{
    joint1.addChild(new VJoint("joint5"));
    assertThat(VJointUtils.transformToSidSet(joint1.getParts()),
            IsIterableContainingInAnyOrder.containsInAnyOrder("joint1", "joint2", "joint3", "joint4","joint5"));
}