@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()); }
/** * 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")); }
@Test public void testTransformToSidListWithNulls() { joint1.addChild(new VJoint("joint5")); assertThat(VJointUtils.transformToSidList(joint1.getParts()), IsIterableContainingInAnyOrder.containsInAnyOrder("joint1", "joint2", "joint3", "joint4","joint5")); }
@Test public void testSCC() { // n1->n2->n1 // n2->n3->n4 Node n1 = new Node(); Node n2 = new Node(); Node n3 = new Node(); Node n4 = new Node(); Edge e1 = constructEdge(n1, n2); Edge e2 = constructEdge(n2, n1); Edge e3 = constructEdge(n2, n3); Edge e4 = constructEdge(n3, n4); nodes.add(n1); nodes.add(n2); nodes.add(n3); nodes.add(n4); edges.add(e1); edges.add(e2); edges.add(e3); edges.add(e4); MotionGraph mg = new MotionGraph.Builder(edges, nodes).getInstance(); SCCDAG dag = GraphUtils.getStronglyConnectedComponents(mg); // resulting DAG: // [n1n2](3)->[n3](2)->[n4](1) assertEquals(dag.getInnerNodeMap().get(n1), dag.getInnerNodeMap().get(n2)); assertThat(dag.getInnerNodeMap().get(n3), lessThan(dag.getInnerNodeMap().get(n2))); assertThat(dag.getInnerNodeMap().get(n4), lessThan(dag.getInnerNodeMap().get(n3))); assertEquals(3, dag.getNodes().size()); assertThat(dag.getEdges(), IsIterableContainingInAnyOrder.containsInAnyOrder(new SCCDAGEdge(3, 2), new SCCDAGEdge(2, 1))); }
@Test public void testSCC2() { // n1->n2->n1 // n3->n4 Node n1 = new Node(); Node n2 = new Node(); Node n3 = new Node(); Node n4 = new Node(); Edge e1 = constructEdge(n1, n2); Edge e2 = constructEdge(n2, n1); Edge e4 = constructEdge(n3, n4); nodes.add(n1); nodes.add(n2); nodes.add(n3); nodes.add(n4); edges.add(e1); edges.add(e2); edges.add(e4); MotionGraph mg = new MotionGraph.Builder(edges, nodes).getInstance(); SCCDAG dag = GraphUtils.getStronglyConnectedComponents(mg); // resulting DAG (example): // [n1n2](3) [n3](2)->[n4](1) assertEquals(3, dag.getNodes().size()); assertEquals(dag.getInnerNodeMap().get(n1), dag.getInnerNodeMap().get(n2)); assertThat(dag.getInnerNodeMap().get(n4), lessThan(dag.getInnerNodeMap().get(n3))); assertThat( dag.getEdges(), IsIterableContainingInAnyOrder.containsInAnyOrder(new SCCDAGEdge(dag.getInnerNodeMap().get(n3), dag.getInnerNodeMap().get( n4)))); }
@Test public void testSCC3() { Node a = new Node(); Node b = new Node(); Node c = new Node(); Node d = new Node(); Node e = new Node(); Node f = new Node(); Node g = new Node(); Node h = new Node(); Edge ab = constructEdge(a, b); Edge bc = constructEdge(b, c); Edge cd = constructEdge(c, d); Edge db = constructEdge(d, b); Edge be = constructEdge(b, e); Edge ed = constructEdge(e, d); Edge af = constructEdge(a, f); Edge fe = constructEdge(f, e); Edge eg = constructEdge(e, g); Edge fg = constructEdge(f, g); Edge gf = constructEdge(g, f); Edge hg = constructEdge(h, g); nodes = ImmutableList.of(a, b, c, d, e, f, g, h); edges = ImmutableList.of(ab, bc, cd, db, be, ed, af, fe, eg, fg, gf, hg); MotionGraph mg = new MotionGraph.Builder(edges, nodes).getInstance(); SCCDAG dag = GraphUtils.getStronglyConnectedComponents(mg); assertEquals(3, dag.getNodes().size()); assertEquals(dag.getInnerNodeMap().get(b), dag.getInnerNodeMap().get(c)); assertEquals(dag.getInnerNodeMap().get(b), dag.getInnerNodeMap().get(d)); assertEquals(dag.getInnerNodeMap().get(b), dag.getInnerNodeMap().get(e)); assertEquals(dag.getInnerNodeMap().get(b), dag.getInnerNodeMap().get(f)); assertEquals(dag.getInnerNodeMap().get(b), dag.getInnerNodeMap().get(g)); assertThat(dag.getInnerNodeMap().get(a), greaterThan(dag.getInnerNodeMap().get(b))); assertThat(dag.getInnerNodeMap().get(h), greaterThan(dag.getInnerNodeMap().get(b))); System.out.println(dag.getEdges()); assertThat(dag.getEdges(), IsIterableContainingInAnyOrder.containsInAnyOrder(new SCCDAGEdge(dag.getInnerNodeMap().get(a), dag .getInnerNodeMap().get(b)), new SCCDAGEdge(dag.getInnerNodeMap().get(h), dag.getInnerNodeMap().get(b)))); }
/** * Tests whether {@link Table#Table(Iterable)} sets the columns when given * an {@link Iterable} so that {@link Table#getColumns()} returns an * {@link Iterable} that contains the same elements. */ @Test public void constructor_givenValidColumns_setsColumns() { Table table = new Table(Arrays.asList(columns)); assertThat(table.getColumns(), IsIterableContainingInAnyOrder .<Column> containsInAnyOrder(columns)); }
/** * @throws IllegalAccessException * @throws NoSuchFieldException * @throws NoSuchMethodException * @throws InvocationTargetException * @throws InstantiationException * */ @SuppressWarnings({ "unchecked" }) @Test public void findAll_shouldFindAll() throws NoSuchFieldException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException { final Integer id1 = 17; final Integer id2 = 42; List<E> persistedObjectList = new ArrayList<E>(); E obj1 = implToTest; E obj2 = (E) BeanUtils.cloneBean(obj1); IdHelper.setIdOnPersistentObject(obj1, id1); IdHelper.setIdOnPersistentObject(obj2, id2); persistedObjectList.add((E) obj1); persistedObjectList.add((E) obj2); // mock dao behaviour doReturn(persistedObjectList).when(dao).findAll(); // actually test List<E> resultList = crudService.findAll(); assertNotNull(resultList); assertEquals(2, resultList.size()); Matcher<E> m1 = hasProperty("id", is(id1)); Matcher<E> m2 = hasProperty("id", is(id2)); assertThat(resultList, IsIterableContainingInAnyOrder.<E> containsInAnyOrder(m1, m2)); // be sure that dao method has been executed exactly once verify(dao, times(1)).findAll(); }
@SuppressWarnings("unchecked") @Test public void labelsAreTranslated() { Label label = Label.label("label"); when(node.getLabels()).thenReturn(newHashSet(label)); TinkerGraphUtil tgu = new TinkerGraphUtil(curieUtil); Vertex v = tgu.addNode(node); assertThat((Iterable<String>)v.getProperty("types"), IsIterableContainingInAnyOrder.containsInAnyOrder("label")); }
private static Matcher<Iterable<? extends String>> isIterableContainingInAnyOrder(final List<Matcher<? super String>> optionTextMatcherList) { return new IsIterableContainingInAnyOrder<String>(optionTextMatcherList) { @Override public void describeTo(Description description) { description.appendList("[", ", ", "]", optionTextMatcherList).appendText(" in any order"); } }; }
private void testBase(String[] ARGS, String[] expectedResult) throws Exception { // Run the pipeline. AnnotateVariants.main(ARGS); // Download the pipeline results. List<String> results = helper.downloadOutputs(outputPrefix, expectedResult.length); // Check the pipeline results. assertEquals(expectedResult.length, results.size()); assertThat(results, IsIterableContainingInAnyOrder.containsInAnyOrder(expectedResult)); }
@Test public void testSiteParsing() throws Exception { DoFnTester<String, Contig> sitesToContigsFn = DoFnTester.of(new SitesToShards.SitesToContigsFn()); String [] input = { "chrX,2000001,3000000", "chrX 2000002 3000000", // tab "chrX 2000003 3000000", // space "chrX:2000004:3000000", // colon " chrX 2000005 3000000 ", // more white space "chrX,2000006,3000000,foo,bar", // additional fields "17,2000000,3000000", "M,2000000,3000000", "chr9_gl000199_random,2000000,3000000", "GL.123,2000000,3000000", "track name=pairedReads description=\"Clone Paired Reads\" useScore=1", // BED header }; Assert.assertThat(sitesToContigsFn.processBundle(input), IsIterableContainingInAnyOrder.containsInAnyOrder( new Contig("chrX", 2000001, 3000000), new Contig("chrX", 2000002, 3000000), new Contig("chrX", 2000003, 3000000), new Contig("chrX", 2000004, 3000000), new Contig("chrX", 2000005, 3000000), new Contig("chrX", 2000006, 3000000), new Contig("17", 2000000, 3000000), new Contig("M", 2000000, 3000000), new Contig("chr9_gl000199_random", 2000000, 3000000), new Contig("GL.123", 2000000, 3000000) )); }