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());
}
}
