public void testMaliciousGetIcons() { Iterable<WWIcon> icons = createExampleIterable(); IconLayer layer = new IconLayer(); layer.addIcons(icons); Iterable<WWIcon> layerIcons = layer.getIcons(); // Test that the returned list cannot be modified. try { if (layerIcons instanceof java.util.Collection) { java.util.Collection<WWIcon> collection = (java.util.Collection<WWIcon>) layerIcons; collection.clear(); } else { java.util.Iterator<WWIcon> iter = layerIcons.iterator(); while (iter.hasNext()) { iter.next(); iter.remove(); } } } catch (UnsupportedOperationException e) { e.printStackTrace(); } // Test that the layer contents do not change, even if the returned list can be modified. assertEquals("", icons, layerIcons); }
private Queue<SearchNode> GetSolution(Board initial) { Queue<SearchNode> queue = new Queue<SearchNode>(); MinPQ<SearchNode> pq = new MinPQ<SearchNode>(); SearchNode node = new SearchNode(); node.brd = initial; node.moves = 0; // node.priority = initial.manhattan(); node.prev = null; pq.insert(node); SearchNode curNode = null; while (!pq.isEmpty()) { curNode = pq.delMin(); if (curNode.brd.isGoal()) break; Iterable<Board> qe = curNode.brd.neighbors(); Iterator it = qe.iterator(); while (it.hasNext()) { node.brd = (Board) it.next(); node.moves = curNode.moves + 1; node.prev = curNode; // node.priority = node.brd.manhattan(); queue.enqueue(node); } } if (queue.isEmpty()) return null; else { do { queue.enqueue(curNode); curNode = curNode.prev; } while (curNode != null); return queue; } }
@Test public void testResolve() throws ResolverException { roleDesc .getKeyDescriptors() .add(buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey())); Iterable<EncryptionParameters> paramsIter = resolver.resolve(criteriaSet); Assert.assertNotNull(paramsIter); Iterator<EncryptionParameters> iterator = paramsIter.iterator(); Assert.assertNotNull(iterator); Assert.assertTrue(iterator.hasNext()); EncryptionParameters params = iterator.next(); Assert.assertNotNull(params); Assert.assertEquals( params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey()); Assert.assertEquals(params.getKeyTransportEncryptionAlgorithm(), defaultRSAKeyTransportAlgo); Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator()); Assert.assertNull(params.getDataEncryptionCredential()); Assert.assertEquals(params.getDataEncryptionAlgorithm(), defaultAES128DataAlgo); Assert.assertNull(params.getDataKeyInfoGenerator()); Assert.assertFalse(iterator.hasNext()); }
@Override public List<Activity> getRecommendations(Long myUserId) { Long closestUserId = getClosestUser(createDistancesVector(myUserId)); Iterable<UserRating> myRatings = userRatingRepository.findByUserId(myUserId); Iterable<UserRating> ratings = userRatingRepository.findByUserId(closestUserId); Iterator<UserRating> ratingsIterator = ratings.iterator(); List<Activity> recommendations = new ArrayList<Activity>(); while (ratingsIterator.hasNext()) { Iterator<UserRating> myRatingsIterator = myRatings.iterator(); UserRating rating = ratingsIterator.next(); boolean activityFound = false; if (rating.getRating() >= 3) { while (myRatingsIterator.hasNext()) { UserRating myRating = myRatingsIterator.next(); if (rating.getActivity().getId() == myRating.getActivity().getId()) { activityFound = true; break; } } if (!activityFound) { recommendations.add(rating.getActivity()); } } } return recommendations; }
@Override public List<Vertex> findApplications(ApplicationQueryBuilder query) { // Iterable<Vertex> vertices = // orientDb.startNoTransaction().getVerticesOfClass("Application"); // select *, out('Uses').id as "uses" from (traverse out('Uses') from #11:0) // select *, out('Uses').id as "uses" from (traverse out('Uses') from (select from // Application where id = 'My Application') where $depth <= 1) // String query = "select *, out('Uses').id as \"uses\" from Application"; String startNodeQuery = "Application"; if (query.startNode != null) { startNodeQuery = String.format( "(traverse %s('Uses') from (select from Application where id = \"%s\") %s)", query.getDirection(), query.startNode, query.getHopsQuery()); } String q = String.format("select %s from %s", query.filterFields(), startNodeQuery); logger.debug("Executing App search query: " + q); OSQLSynchQuery<OrientVertex> qr = new OSQLSynchQuery<>(q); return orientDb.withGraphNoTx( (OrientGraphNoTx db) -> { List<Vertex> result = new ArrayList<>(); Iterable<OrientVertex> vertices = db.command(qr).execute(Collections.emptyMap()); vertices.forEach(result::add); return result; }); }
private void markAsFragment(final Multimap<TerminalRule, AbstractRule> calledFrom) { Set<TerminalRule> _keySet = calledFrom.keySet(); final Function1<TerminalRule, Boolean> _function = (TerminalRule it) -> { boolean _isFragment = it.isFragment(); return Boolean.valueOf((!_isFragment)); }; Iterable<TerminalRule> _filter = IterableExtensions.<TerminalRule>filter(_keySet, _function); final Function1<TerminalRule, Boolean> _function_1 = (TerminalRule it) -> { Collection<AbstractRule> _get = calledFrom.get(it); return Boolean.valueOf(this.allAreTerminalRules(_get)); }; Iterable<TerminalRule> _filter_1 = IterableExtensions.<TerminalRule>filter(_filter, _function_1); final Function1<TerminalRule, Boolean> _function_2 = (TerminalRule it) -> { EObject _eContainer = it.eContainer(); EList<AbstractRule> _hiddenTokens = ((Grammar) _eContainer).getHiddenTokens(); boolean _contains = _hiddenTokens.contains(it); return Boolean.valueOf((!_contains)); }; Iterable<TerminalRule> _filter_2 = IterableExtensions.<TerminalRule>filter(_filter_1, _function_2); final Consumer<TerminalRule> _function_3 = (TerminalRule it) -> { it.setFragment(true); }; _filter_2.forEach(_function_3); }
@Test public void limitedExecute() { final List<Runnable> jobs = Lists.newArrayList(); final AsyncCompleter completion = new AsyncCompleter.Builder( new Executor() { public void execute(final Runnable command) { jobs.add(command); } }) .handleExceptions(Policies.THROW) .limitParallelExecutionTo(1); final Iterable<Integer> queued = completion.invokeAll(ImmutableList.of(callable(1), callable(2), callable(3))); final Iterator<Integer> iterator = queued.iterator(); assertEquals(1, jobs.size()); // can't test that hasNext() will block, but it should jobs.get(0).run(); assertEquals(2, jobs.size()); // can test that next() will not block anymore assertEquals(1, iterator.next().intValue()); jobs.get(1).run(); assertEquals(3, jobs.size()); assertEquals(2, iterator.next().intValue()); jobs.get(2).run(); assertEquals(3, jobs.size()); assertEquals(3, iterator.next().intValue()); assertFalse(iterator.hasNext()); }
public void testSemanticallyCorrectIterables() { Graph graph = graphTest.generateGraph(); for (int i = 0; i < 15; i++) { graph.addEdge(null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "knows")); } if (graph.getFeatures().supportsVertexIteration) { Iterable<Vertex> vertices = graph.getVertices(); assertEquals(count(vertices), 30); assertEquals(count(vertices), 30); Iterator<Vertex> itty = vertices.iterator(); int counter = 0; while (itty.hasNext()) { assertTrue(itty.hasNext()); itty.next(); counter++; } assertEquals(counter, 30); } if (graph.getFeatures().supportsEdgeIteration) { Iterable<Edge> edges = graph.getEdges(); assertEquals(count(edges), 15); assertEquals(count(edges), 15); Iterator<Edge> itty = edges.iterator(); int counter = 0; while (itty.hasNext()) { assertTrue(itty.hasNext()); itty.next(); counter++; } assertEquals(counter, 15); } graph.shutdown(); }
@Test public void testMavenizeRuleProvider() throws IOException, InstantiationException, IllegalAccessException { try (GraphContext graphContext = factory.create(WindupTestUtilMethods.getTempDirectoryForGraph())) { final String inputDir = "../../test-files/jee-example-app-1.0.0.ear"; // rules-java/api final Class<MavenizeRuleProvider> ruleToRunUpTo = MavenizeRuleProvider.class; final Path outputDir = executeWindupAgainstAppUntilRule(inputDir, graphContext, ruleToRunUpTo); Iterable<IdentifiedArchiveModel> identifiedArchives = graphContext.service(IdentifiedArchiveModel.class).findAll(); Assume.assumeTrue(identifiedArchives.iterator().hasNext()); // Were the pom.xml's created? final Path baseMavenDir = outputDir.resolve("mavenized/jee-example-app"); Path resultRootPomPath = baseMavenDir.resolve("pom.xml"); Assert.assertTrue("Exists: " + resultRootPomPath, resultRootPomPath.toFile().exists()); checkPomExistence(baseMavenDir, "jee-example-app-bom", true); checkPomExistence(baseMavenDir, "jee-example-services-jar", true); checkPomExistence(baseMavenDir, "jee-example-services", false); checkPomExistence(baseMavenDir, "log4j", false); checkPomExistence(baseMavenDir, "log4j-jar", false); checkPomExistence(baseMavenDir, "unparsable-jar", false); // TODO: Load the POM tree with Maven? // ProjectBuilder pb = new DefaultProjectBuilder(); // pb.build(new ArrayList<File>(){{add(outputDir.toFile());}}, true, new // DefaultProjectBuildingRequest()); } }
@Override protected void executeTest() throws Exception { ODatabaseDocumentTx db = new ODatabaseDocumentTx("plocal:target/server0/databases/" + getDatabaseName()); db.open("admin", "admin"); try { db.command(new OCommandSQL("INSERT into Item (name) values ('foo')")).execute(); Iterable<ODocument> result = db.command(new OCommandSQL("select set(name) as names from Item")).execute(); Assert.assertEquals(Collections.singleton("foo"), result.iterator().next().field("names")); result = db.command(new OCommandSQL("select list(name) as names from Item")).execute(); Assert.assertEquals( Collections.singletonList("foo"), result.iterator().next().field("names")); db.command(new OCommandSQL("INSERT into Item (map) values ({'a':'b'}) return @this")) .execute(); result = db.command(new OCommandSQL("select map(map) as names from Item")).execute(); Assert.assertEquals( Collections.singletonMap("a", "b"), result.iterator().next().field("names")); } finally { db.close(); } }
/** * Asserts that two iterables return iterators with the same elements in the same order. If they * do not, an AssertionError, with the given message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(Iterable<?> actual, Iterable<?> expected, String message) { if (actual == expected) { return; } if (actual == null || expected == null) { log.error(message(message, expected, actual)); if (message == null) { message = "Iterables not equal:"; } if (haultonfailure) fail(message); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } Iterator<?> actIt = actual.iterator(); Iterator<?> expIt = expected.iterator(); assertEquals(actIt, expIt, message); }
public static void main(String[] args) { List<String> lines = null; try { lines = Files.readLines(new File("D:\\version.txt"), Charset.forName("UTF-8")); } catch (IOException e) { e.printStackTrace(); } Map<String, String> versionMap = Maps.newHashMap(); for (String line : lines) { if (StringUtils.isBlank(line)) continue; Iterable<String> entryFields = Splitter.on(':').trimResults().limit(2).split(line); if (entryFields == null) continue; Iterator<String> i = entryFields.iterator(); if (i.hasNext()) { String key = null; String value = null; key = i.next(); if (i.hasNext()) { value = i.next(); } versionMap.put(key, value); } } System.out.println(versionMap.get("Name")); System.out.println(versionMap.get("Version")); }
@Test public void shouldAllowHasNextToBeCalledMultipleTimesWithoutProgressingTheIterator() { // Given Iterable<String> iterable = iterableWith("one", "two", "three", "four", "five"); Predicate<String> predicate = new Predicate<String>() { public boolean evaluate(String item) { return item.contains("o"); } }; // When FilteredIterator<String> iterator = new FilteredIterator<String>(iterable.iterator(), predicate); // Then assertThat(iterator.hasNext(), is(true)); assertThat(iterator.hasNext(), is(true)); assertThat(iterator.next(), is("one")); assertThat(iterator.hasNext(), is(true)); assertThat(iterator.next(), is("two")); assertThat(iterator.hasNext(), is(true)); assertThat(iterator.hasNext(), is(true)); assertThat(iterator.hasNext(), is(true)); assertThat(iterator.next(), is("four")); assertThat(iterator.hasNext(), is(false)); assertThat(iterator.hasNext(), is(false)); }
@Test public void shouldBeAbleToImplementAnonymousGraphQuery() throws Exception { // given GraphDatabaseService db = Db.impermanentDb(); Transaction tx = db.beginTx(); Node firstNode = db.createNode(); Node secondNode = db.createNode(); firstNode.createRelationshipTo(secondNode, withName("CONNECTED_TO")); tx.success(); tx.finish(); GraphQuery query = new GraphQuery() { @Override public Iterable<Node> execute(Node startNode) { return startNode.traverse( Traverser.Order.DEPTH_FIRST, StopEvaluator.DEPTH_ONE, ReturnableEvaluator.ALL_BUT_START_NODE, withName("CONNECTED_TO"), Direction.OUTGOING); } }; // when Iterable<Node> result = query.execute(firstNode); // then Iterator<Node> iterator = result.iterator(); assertEquals(secondNode, iterator.next()); assertFalse(iterator.hasNext()); }
@Override public void execute(Template tmpl, Template.Context ctx, Writer out) { Object value = tmpl.getValue(ctx, _name, _line); if (value == null) { executeSegs(tmpl, ctx, out); // TODO: configurable behavior on missing values } if (value instanceof Iterable<?>) { Iterable<?> iable = (Iterable<?>) value; if (!iable.iterator().hasNext()) { executeSegs(tmpl, ctx, out); } } else if (value instanceof Boolean) { if (!(Boolean) value) { executeSegs(tmpl, ctx, out); } } else if (value instanceof String) { if (((String) value).length() == 0) { executeSegs(tmpl, ctx, out); } } else if (value.getClass().isArray()) { if (Array.getLength(value) == 0) { executeSegs(tmpl, ctx, out); } } else if (value instanceof Iterator<?>) { Iterator<?> iter = (Iterator<?>) value; if (!iter.hasNext()) { executeSegs(tmpl, ctx, out); } } }
@Test public void testAuthenticate() { Iterable<String> iterable = admin.getAllowedSchemes(); assertEquals(NONE_SCHEME, iterable.iterator().next()); AuthenticationRequest request = AuthenticationRequestBuilder.newBuilder() // .scheme(NONE_SCHEME) // .userName(USERNAME) // .password(PASSWORD) // .build(); AuthenticatedUser actual = admin.authenticate(request); assertNotNull(actual); assertEquals(USERNAME, actual.getName()); assertEquals(USERNAME, actual.getUserName()); assertEquals(USERNAME, actual.getDisplayName()); assertEquals("", actual.getEmailAddress()); assertEquals(false, actual.getRoles().iterator().hasNext()); assertEquals(true, actual.isActive()); assertEquals(true, actual.isAuthenticated()); }
private static String buildRequest(String flowToken, String message, String tags) { final String tagsToBeSent; if (tags != null) { final Iterable<String> parsedTags = SPACE_SPLITTER.split(tags); final Iterable<String> transformedTags = Iterables.transform( parsedTags, new Function<String, String>() { @Override public String apply(String s) { return s.startsWith("#") ? String.format("\"%s\"", s) : String.format("\"#%s\"", s); } }); if (transformedTags.iterator().hasNext()) { tagsToBeSent = String.format("\"tags\": [%s],", COMMA_JOINER.join(transformedTags)); } else { tagsToBeSent = ""; } } else { tagsToBeSent = ""; } return String.format( "{\"flow_token\": \"%s\", \"event\": \"message\", %s \"content\": \"%s\"}", flowToken, tagsToBeSent, message); }
protected boolean loadConfigurationFromProvider() throws IOException { // TODO use a OSGi service for this. Iterable<URL> provider = Environment.getDefault().getConfigurationProvider(); if (provider == null) { return false; } Iterator<URL> it = provider.iterator(); ArrayList<URL> props = new ArrayList<>(); ArrayList<URL> xmls = new ArrayList<>(); while (it.hasNext()) { URL url = it.next(); String path = url.getPath(); if (path.endsWith("-config.xml")) { xmls.add(url); } else if (path.endsWith(".properties")) { props.add(url); } } Comparator<URL> comp = new Comparator<URL>() { @Override public int compare(URL o1, URL o2) { return o1.getPath().compareTo(o2.getPath()); } }; Collections.sort(xmls, comp); for (URL url : props) { loadProperties(url); } for (URL url : xmls) { context.deploy(url); } return true; }
/** * Get the {@link Port} by its fixed IP * * @param fixedIP the fixed IP of the port to be retrieved * @return the {@link Port} if found, null otherwise */ private Port getPortByFixedIP(final String fixedIP) { if (!isValidIP(fixedIP)) { return null; } Iterable<Port> port = Iterables.filter( portApi.list().concat().toList(), new Predicate<Port>() { @Override public boolean apply(Port input) { for (IP ip : input.getFixedIps()) { if (ip.getIpAddress() != null && ip.getIpAddress().equals(fixedIP)) { return true; } } return false; } }); // a fixed/private IP can be associated with at most one port if (port.iterator().hasNext()) { return port.iterator().next(); } return null; }
@Test public void shouldLazilyExecuteSuppliedFunctionOnEachElement() { // Given Iterable<Target> targets = iterableWith(mock(Target.class), mock(Target.class), mock(Target.class)); // When Iterable<Target> preparedTargets = Lazily.each( targets, new Action<Target>() { @Override public void on(Target input) { input.doSomething(); } }); // Then Iterator<Target> preparedTargetsIterator = preparedTargets.iterator(); for (Target target : targets) { verify(target, never()).doSomething(); preparedTargetsIterator.next(); verify(target, times(1)).doSomething(); } }
private static void assertDeepChildrenEquals(SNode expectedNode, SNode actualNode) { Set<String> roles = new HashSet<String>(); for (SNode child : expectedNode.getChildren()) { roles.add(child.getRoleInParent()); } for (SNode child : actualNode.getChildren()) { roles.add(child.getRoleInParent()); } for (String role : roles) { Iterable<? extends SNode> expectedChildren = expectedNode.getChildren(role); Iterable<? extends SNode> actualChildren = actualNode.getChildren(role); int esize = IterableUtil.asCollection(expectedChildren).size(); int asize = IterableUtil.asCollection(actualChildren).size(); assertEquals( getErrorString("child count in role " + role, expectedNode, actualNode), esize, asize); Iterator<? extends SNode> actualIterator = actualChildren.iterator(); for (SNode expectedChild : expectedChildren) { SNode actualChild = actualIterator.next(); assertEquals( getErrorString("children in role " + role, expectedNode, actualNode), expectedChild.getNodeId(), actualChild.getNodeId()); assertDeepNodeEquals(expectedChild, actualChild); } } }
private void updateComboBoxContent() { ignoreUiUpdates = true; Object selected = this.getSelectedItem(); this.removeAllItems(); this.addItem(NONE); this.addItem(ONE_PROFILE_FOR_EVERYTHING); MappingManager.getInstance().generateDefaultMappings().forEach(this::addItem); List<MappingSet> all = MappingManager.getInstance().getAll(); if (all.size() > 0) { this.addItem(PREDEFINED_MAPPINGS); all.forEach(this::addItem); } if (VisicutModel.getInstance().getSelectedPart() != null) { Iterable<String> props = VisicutModel.getInstance() .getSelectedPart() .getGraphicObjects() .getInterestingAttributes(); if (props.iterator().hasNext()) { this.addItem(BY_PROPERTY); int count = 0; for (String att : props) { if (++count > 4) { break; } this.addItem(new MapByPropertyEntry(att)); } } } this.addItem(CUSTOM); this.setSelectedItem(selected); ignoreUiUpdates = false; }
protected void updateXYSerieses() throws MicroarrayException { Iterable<Float> xValues = data.queryFeatures(xVar.getExpression()).asFloats(); Iterable<Float> yValues = data.queryFeatures(yVar.getExpression()).asFloats(); XYSeries series = new XYSeries(""); XYSeries selectionSeries = new XYSeries(""); Iterator<Float> xIterator = xValues != null ? xValues.iterator() : null; int i = 0; for (Float y : yValues) { if (selectedIndexes.contains(i)) { if (xIterator != null) { selectionSeries.add(xIterator.next(), y); } else { selectionSeries.add(i, y); } } else { if (xIterator != null) { series.add(xIterator.next(), y); } else { series.add(i, y); } } i++; } XYSeriesCollection dataset = new XYSeriesCollection(); dataset.addSeries(series); dataset.addSeries(selectionSeries); plot.setDataset(dataset); }
/* * Use the binary git repo and/or the remote service to figure out * the new commits made since the last pull on source repository. */ public void findNewCommits() throws GitException { // get the history from binary repository Git bingit = Git.wrap(binaryRepository); RevWalk binwalk = new RevWalk(binaryRepository); Iterable<RevCommit> logs; try { logs = bingit.log().call(); Iterator<RevCommit> i = logs.iterator(); while (i.hasNext()) { RevCommit commit = binwalk.parseCommit(i.next()); System.out.println(commit.getFullMessage()); } } catch (NoHeadException e) { // TODO Auto-generated catch block throw new GitException(e); } catch (GitAPIException e) { throw new GitException(e); } catch (MissingObjectException e) { throw new GitException(e); } catch (IncorrectObjectTypeException e) { throw new GitException(e); } catch (IOException e) { throw new GitException(e); } }
public void testSkip_structurallyModifiedSkipAll() throws Exception { Collection<String> set = newLinkedHashSet(asList("a", "b", "c")); Iterable<String> tail = skip(set, 2); set.remove("a"); set.remove("b"); assertFalse(tail.iterator().hasNext()); }
private void doCompact( LazyDocumentLoader documentLoader, LazyCompactor compactor, SolrQueryResponse rsp, String tsId, String q) throws IOException, SyntaxError { Query query = depProvider.parser(q).getQuery(); Iterable<Document> docs = documentLoader.load(query, SORT); Iterable<CompactionResult> compactionResults = compactor.compact(docs); List<Document> docsToDelete = new LinkedList<>(); List<SolrInputDocument> docsToAdd = new LinkedList<>(); compactionResults.forEach( it -> { docsToDelete.addAll(it.getInputDocuments()); docsToAdd.addAll(it.getOutputDocuments()); }); depProvider.solrUpdateService().add(docsToAdd); depProvider.solrUpdateService().delete(docsToDelete); rsp.add("timeseries " + tsId + " oldNumDocs:", docsToDelete.size()); rsp.add("timeseries " + tsId + " newNumDocs:", docsToAdd.size()); }
@Override public double[] createDistancesVector(Long myUserId) { int totalNoUsers = countAllUsers().intValue() + 1; double[] distances = new double[totalNoUsers]; Iterable<User> users = userRepository.findAll(); Iterator<User> iterator = users.iterator(); double[] myRatings = createActivityVector(myUserId); while (iterator.hasNext()) { User u = iterator.next(); Long userId = u.getId(); if (userId != myUserId) { double[] userRatings = createActivityVector(userId); if (RecommendationUtils.intersect(myRatings, userRatings)) { distances[userId.intValue()] = RecommendationUtils.cosineSimilarity(myRatings, userRatings); } else { distances[userId.intValue()] = Double.MIN_VALUE; } } else { distances[userId.intValue()] = Double.MIN_VALUE; } } return distances; }
public void doGenerate( final Resource input, final IFileSystemAccess fsa, final Executable2ResultMapping spec2ResultMapping) { this.initResultMapping(spec2ResultMapping); EList<EObject> _contents = input.getContents(); Iterable<XtendFile> _filter = Iterables.<XtendFile>filter(_contents, XtendFile.class); final Consumer<XtendFile> _function = new Consumer<XtendFile>() { public void accept(final XtendFile it) { EList<XtendTypeDeclaration> _xtendTypes = it.getXtendTypes(); Iterable<XtendClass> _filter = Iterables.<XtendClass>filter(_xtendTypes, XtendClass.class); final Consumer<XtendClass> _function = new Consumer<XtendClass>() { public void accept(final XtendClass it) { HtmlFile _createHtmlFile = AbstractDocGenerator.this.createHtmlFile(it); AbstractDocGenerator.this._htmlFileBuilder.generate(it, fsa, _createHtmlFile); } }; _filter.forEach(_function); } }; _filter.forEach(_function); }
public int contextMatchCheck() { final Iterable<String> contextLines = myContext.getPreviousLinesIterable(); // we ignore spaces.. at least at start/end, since some version controls could ignore their // changes when doing annotate final Iterator<String> iterator = contextLines.iterator(); if (iterator.hasNext()) { String contextLine = iterator.next().trim(); while (myChangedLinesIterator.hasNext()) { final Pair<Integer, String> pair = myChangedLinesIterator.next(); if (pair.getSecond().trim().equals(contextLine)) { if (!iterator.hasNext()) break; contextLine = iterator.next().trim(); } } if (iterator.hasNext()) { return -1; } } if (!myChangedLinesIterator.hasNext()) return -1; final String targetLine = myContext.getTargetString().trim(); while (myChangedLinesIterator.hasNext()) { final Pair<Integer, String> pair = myChangedLinesIterator.next(); if (pair.getSecond().trim().equals(targetLine)) { return pair.getFirst(); } } return -1; }
@Test(timeout = 1000) public void testSameSourceMultipleIterators() { TestScheduler scheduler = new TestScheduler(); NbpBlockingObservable<Long> source = NbpObservable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlocking(); Iterable<Long> iter = source.latest(); for (int j = 0; j < 3; j++) { Iterator<Long> it = iter.iterator(); // only 9 because take(10) will immediately call onCompleted when receiving the 10th item // which onCompleted will overwrite the previous value for (int i = 0; i < 9; i++) { scheduler.advanceTimeBy(1, TimeUnit.SECONDS); Assert.assertEquals(true, it.hasNext()); Assert.assertEquals(Long.valueOf(i), it.next()); } scheduler.advanceTimeBy(1, TimeUnit.SECONDS); Assert.assertEquals(false, it.hasNext()); } }