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);
}
/**
* 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 testCRUDEntityRepository() {
// clean up the existing student data
repository.deleteAll("student", null);
// create new student entity
Map<String, Object> student = buildTestStudentEntity();
// test save
Entity saved = repository.create("student", student);
String id = saved.getEntityId();
assertTrue(!id.equals(""));
// test findAll
NeutralQuery neutralQuery = new NeutralQuery();
neutralQuery.setOffset(0);
neutralQuery.setLimit(20);
Iterable<Entity> entities = repository.findAll("student", neutralQuery);
assertNotNull(entities);
Entity found = entities.iterator().next();
assertEquals(found.getBody().get("birthDate"), student.get("birthDate"));
assertEquals((found.getBody()).get("firstName"), "Jane");
assertEquals((found.getBody()).get("lastName"), "Doe");
// test find by id
Entity foundOne = repository.findById("student", saved.getEntityId());
assertNotNull(foundOne);
assertEquals(foundOne.getBody().get("birthDate"), student.get("birthDate"));
assertEquals((found.getBody()).get("firstName"), "Jane");
// test update
found.getBody().put("firstName", "Mandy");
assertTrue(repository.update("student", found, false));
entities = repository.findAll("student", neutralQuery);
assertNotNull(entities);
Entity updated = entities.iterator().next();
assertEquals(updated.getBody().get("firstName"), "Mandy");
// test delete by id
Map<String, Object> student2Body = buildTestStudentEntity();
Entity student2 = repository.create("student", student2Body);
entities = repository.findAll("student", neutralQuery);
assertNotNull(entities.iterator().next());
repository.delete("student", student2.getEntityId());
Entity zombieStudent = repository.findById("student", student2.getEntityId());
assertNull(zombieStudent);
assertFalse(repository.delete("student", student2.getEntityId()));
// test deleteAll by entity type
repository.deleteAll("student", null);
entities = repository.findAll("student", neutralQuery);
assertFalse(entities.iterator().hasNext());
}
protected R scan(
Iterable<? extends AnnotatedTypeMirror> types, Iterable<? extends AnnotatedTypeMirror> p) {
if (types == null) return null;
R r = null;
boolean first = true;
Iterator<? extends AnnotatedTypeMirror> tIter = types.iterator(), pIter = p.iterator();
while (tIter.hasNext() && pIter.hasNext()) {
r = (first ? scan(tIter.next(), pIter.next()) : scanAndReduce(tIter.next(), pIter.next(), r));
first = false;
}
return r;
}
/**
* {@inheritDoc}
*
* @param positions Control points that orient the graphic. Must provide at least three points.
*/
public void setPositions(Iterable<? extends Position> positions) {
if (positions == null) {
String message = Logging.getMessage("nullValue.PositionsListIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
try {
Iterator<? extends Position> iterator = positions.iterator();
this.position1 = iterator.next();
this.position2 = iterator.next();
this.position3 = iterator.next();
} catch (NoSuchElementException e) {
String message = Logging.getMessage("generic.InsufficientPositions");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
this.paths = null; // Need to recompute path for the new control points
this.arrowHead1 = null;
this.arrowHead2 = null;
if (this.symbol != null) {
this.symbol.setPosition(this.position1);
}
}
private ConsumerConfig getConsumerConfig(DestinationConfiguration destination) {
destination.getUrl();
String queue;
String zkHost = properties.get("broker.zk.servers");
String zkRoot = properties.get("broker.zk.root");
ZkHosts zkHosts = new ZkHosts(zkHost, zkRoot);
if (!destination.isGrouped()) {
queue =
destination.getSite()
+ "."
+ destination.getSensor()
+ "."
+ destination.getSensorId()
+ "."
+ destination.getProperty("topic");
} else {
queue =
destination.getSite()
+ "."
+ destination.getSensor()
+ "."
+ destination.getProperty("topic");
}
ConsumerConfig consumerConfig = new ConsumerConfig(zkHosts, queue, "/iot/broker", queue);
Iterable<String> iterable = Splitter.on(",").split(zkHost);
Iterator<String> it = iterable.iterator();
consumerConfig.zkServers = new ArrayList<String>();
while (it.hasNext()) {
consumerConfig.zkServers.add(it.next());
}
return consumerConfig;
}
@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());
}
}
/**
* Generate the positions required to draw the line.
*
* @param dc Current draw context.
* @param positions Positions that define the polygon boundary.
*/
@Override
protected void generateIntermediatePositions(
DrawContext dc, Iterable<? extends Position> positions) {
Globe globe = dc.getGlobe();
boolean useDefaultWaveLength = false;
double waveLength = this.getWaveLength();
if (waveLength == 0) {
waveLength = this.computeDefaultWavelength(positions, globe);
useDefaultWaveLength = true;
}
// Generate lines that parallel the control line.
List<Position> leftPositions = new ArrayList<Position>();
List<Position> rightPositions = new ArrayList<Position>();
this.generateParallelLines(
positions.iterator(), leftPositions, rightPositions, waveLength / 2.0, globe);
if (useDefaultWaveLength) waveLength = this.computeDefaultWavelength(leftPositions, globe);
double radius = (waveLength) / 2.0;
// Generate wavy line to the left of the control line.
PositionIterator iterator = new PositionIterator(leftPositions, waveLength, globe);
this.computedPositions =
this.generateWavePositions(iterator, radius / globe.getRadius(), false);
this.path.setPositions(this.computedPositions);
if (useDefaultWaveLength) waveLength = this.computeDefaultWavelength(rightPositions, globe);
radius = (waveLength) / 2.0;
// Generate wavy line to the right of the control line.
iterator = new PositionIterator(rightPositions, waveLength, globe);
this.path2.setPositions(this.generateWavePositions(iterator, radius / globe.getRadius(), true));
}
@Override
public boolean hasNext() {
// Note: this was difficult for Cole's feeble mind to think about
if (aInstances.hasNext()) {
currA = aInstances.next();
return true;
} else if (bInstances.hasNext()) {
currB = bInstances.next();
aInstances = aSeed.iterator();
return hasNext();
}
// While there are more keys in b
while (bKeys.hasNext()) {
// fetch the next key | field value from which to retrieve a's and b's
Object currKey = bKeys.next();
// try and fetch an a from a's index
aSeed = relation.getFromIndex(_predicate.streamA.getIndex(), currKey);
if (aSeed != null) {
// if we found an a, fetch b's instances at this point
bInstances = _predicate.streamB.getIndex().get(currKey).iterator();
// advance the iterator. The if statement at the top should catch now.
return hasNext();
}
}
return false;
}
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);
}
}
}
/**
* {@inheritDoc}
*
* @param positions Control points. This graphic uses only two control point, which determine the
* midpoints of two opposite sides of the quad. See Fire Support Area (2.X.4.3.2.1.2) on pg.
* 652 of MIL-STD-2525C for an example of how these points are interpreted.
*/
public void setPositions(Iterable<? extends Position> positions) {
if (positions == null) {
String message = Logging.getMessage("nullValue.PositionsListIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
Iterator<? extends Position> iterator = positions.iterator();
try {
Position pos1 = iterator.next();
Position pos2 = iterator.next();
LatLon center = LatLon.interpolateGreatCircle(0.5, pos1, pos2);
this.quad.setCenter(center);
Angle heading = LatLon.greatCircleAzimuth(pos2, pos1);
this.quad.setHeading(heading.subtract(Angle.POS90));
this.positions = positions;
this.shapeInvalid = true; // Need to recompute quad size
} catch (NoSuchElementException e) {
String message = Logging.getMessage("generic.InsufficientPositions");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
}
@Override
public void reduce(Text key, Iterable<HMapStIW> values, Context context)
throws IOException, InterruptedException {
Iterator<HMapStIW> iter = values.iterator();
HMapStIW map = new HMapStIW();
while (iter.hasNext()) {
map.plus(iter.next());
}
HMapStFW writeMap = new HMapStFW();
double pmi = 0.0;
for (MapKI.Entry<String> entry : map.entrySet()) {
String k = entry.getKey();
if (map.get(k) >= 10) {
if (wordCounts.containsKey(key.toString()) && wordCounts.containsKey(k)) {
int px = wordCounts.get(key.toString());
int py = wordCounts.get(k);
pmi = Math.log10(((double) (map.get(k)) / (px * py)) * wordCounts.get("numLines*"));
writeMap.put(k, (float) pmi);
}
}
}
if (writeMap.size() > 0) {
context.write(key, writeMap);
}
}
public static Sector boundingSector(Iterable<? extends LatLon> locations) {
if (locations == null) {
throw new IllegalArgumentException("Positions List Is Null");
}
if (!locations.iterator().hasNext()) {
return EMPTY_SECTOR; // TODO: should be returning null
}
double minLat = Angle.POS90.getDegrees();
double minLon = Angle.POS180.getDegrees();
double maxLat = Angle.NEG90.getDegrees();
double maxLon = Angle.NEG180.getDegrees();
for (LatLon p : locations) {
double lat = p.getLatitude().getDegrees();
if (lat < minLat) {
minLat = lat;
}
if (lat > maxLat) {
maxLat = lat;
}
double lon = p.getLongitude().getDegrees();
if (lon < minLon) {
minLon = lon;
}
if (lon > maxLon) {
maxLon = lon;
}
}
return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
}
@Test(timeout = 1000)
public void testFasterSource() {
NbpPublishSubject<Integer> source = NbpPublishSubject.create();
NbpBlockingObservable<Integer> blocker = source.toBlocking();
Iterable<Integer> iter = blocker.latest();
Iterator<Integer> it = iter.iterator();
source.onNext(1);
Assert.assertEquals(Integer.valueOf(1), it.next());
source.onNext(2);
source.onNext(3);
Assert.assertEquals(Integer.valueOf(3), it.next());
source.onNext(4);
source.onNext(5);
source.onNext(6);
Assert.assertEquals(Integer.valueOf(6), it.next());
source.onNext(7);
source.onComplete();
Assert.assertEquals(false, it.hasNext());
}
@Override
public void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException {
Hashtable<String, Integer> wordCounts = new Hashtable<String, Integer>();
ArrayList docName = new ArrayList<String>();
LinkedList wordName = new LinkedList<String>();
while (values.iterator().hasNext()) {
String[] items = values.iterator().next().toString().split("@");
if (!wordName.contains(items[0])) {
wordName.add(items[0]);
}
String[] keys = items[1].split(":|,");
for (int i = 0; i < keys.length; i += 2) {
if (!docName.contains(keys[i])) {
docName.add(keys[i]);
wordCounts.put(keys[i], 0);
}
int tmp = wordCounts.get(keys[i]);
tmp += Integer.parseInt(keys[i + 1]);
wordCounts.put(keys[i], tmp);
}
}
for (int i = 0; i < docName.size() - 1; ++i) {
for (int j = i + 1; j < docName.size(); ++j) {
if (wordCounts.get(docName.get(i)) < wordCounts.get(docName.get(j))) {
String stmp = docName.get(i).toString();
docName.set(i, docName.get(j).toString());
docName.set(j, stmp);
}
}
}
String retKey = wordName.get(0).toString();
for (int i = 1; i < wordName.size(); ++i) {
retKey += "," + wordName.get(i);
}
String retValue =
""; // ="\n" + docName.get(0).toString() + ":" +
// wordCounts.get(docName.get(0).toString());
for (int i = 0; i < docName.size(); ++i) {
retValue +=
"\n" + docName.get(i).toString() + ": " + wordCounts.get(docName.get(i).toString());
}
context.write(new Text(retKey), new Text(retValue));
}
@NotNull
public static <T> HashSet<T> newHashSet(@NotNull Iterable<? extends T> elements) {
if (elements instanceof Collection) {
@SuppressWarnings("unchecked")
Collection<? extends T> collection = (Collection<? extends T>) elements;
return new com.intellij.util.containers.HashSet<T>(collection);
}
return newHashSet(elements.iterator());
}
@Override
default <U> Tree<Tuple2<T, U>> zip(Iterable<U> that) {
Objects.requireNonNull(that, "that is null");
if (isEmpty()) {
return Empty.instance();
} else {
return Zip.apply((Node<T>) this, that.iterator());
}
}
// Calls the Combiner object on each element to combine
// it with a running result, which is finally returned:
public static <T> T reduce(Iterable<T> seq, Combiner<T> combiner) {
Iterator<T> it = seq.iterator();
if (it.hasNext()) {
T result = it.next();
while (it.hasNext()) result = combiner.combine(result, it.next());
return result;
}
// If seq is the empty list:
return null; // Or throw exception
}
public static Sector[] splitBoundingSectors(Iterable<? extends LatLon> locations) {
if (locations == null) {
throw new IllegalArgumentException("Location In List Is Null");
}
if (!locations.iterator().hasNext()) {
return null;
}
double minLat = Angle.POS90.getDegrees();
double minLon = Angle.POS180.getDegrees();
double maxLat = Angle.NEG90.getDegrees();
double maxLon = Angle.NEG180.getDegrees();
LatLon lastLocation = null;
for (LatLon ll : locations) {
double lat = ll.getLatitude().getDegrees();
if (lat < minLat) {
minLat = lat;
}
if (lat > maxLat) {
maxLat = lat;
}
double lon = ll.getLongitude().getDegrees();
if (lon >= 0 && lon < minLon) {
minLon = lon;
}
if (lon <= 0 && lon > maxLon) {
maxLon = lon;
}
if (lastLocation != null) {
double lastLon = lastLocation.getLongitude().getDegrees();
if (Math.signum(lon) != Math.signum(lastLon)) {
if (Math.abs(lon - lastLon) < 180) {
// Crossing the zero longitude line too
maxLon = 0;
minLon = 0;
}
}
}
lastLocation = ll;
}
if (minLat == maxLat && minLon == maxLon) {
return null;
}
return new Sector[] {
Sector.fromDegrees(minLat, maxLat, minLon, 180), // Sector on eastern hemisphere.
Sector.fromDegrees(minLat, maxLat, -180, maxLon) // Sector on western hemisphere.
};
}
/**
* Get the {@link FloatingIP} by its Floating IP Address
*
* @param floatingIPAddress the Floating IP Address (a.k.a public IP address)
* @return the {@link FloatingIP} if found, null otherwise
*/
private FloatingIP getFloatingIPByIPAddress(final String floatingIPAddress) {
if (!isValidIP(floatingIPAddress)) {
return null;
}
Iterable<FloatingIP> floatingIP =
Iterables.filter(
floatingIPApi.list().concat().toList(),
new Predicate<FloatingIP>() {
@Override
public boolean apply(FloatingIP input) {
return input.getFloatingIpAddress() != null
&& input.getFloatingIpAddress().equals(floatingIPAddress);
}
});
if (floatingIP.iterator().hasNext()) {
return floatingIP.iterator().next();
}
return null;
}
@Test(timeout = 1000, expected = NoSuchElementException.class)
public void testEmpty() {
NbpBlockingObservable<Long> source = NbpObservable.<Long>empty().toBlocking();
Iterable<Long> iter = source.latest();
Iterator<Long> it = iter.iterator();
Assert.assertEquals(false, it.hasNext());
it.next();
}
public static void sendOSC(
String ipAddress, long port, String oscAddress, Iterable<Double> oscArguments) {
OscMessage message = new OscMessage(oscAddress);
Iterator iterator = oscArguments.iterator();
while (iterator.hasNext()) {
message.add(((Double) iterator.next()).floatValue());
}
UdpClient c = new UdpClient(ipAddress, (int) port);
c.send(message.getBytes());
}
@Override
public void reduce(Text key, Iterable<HMapStIW> values, Context context)
throws IOException, InterruptedException {
Iterator<HMapStIW> iter = values.iterator();
HMapStIW map = new HMapStIW();
while (iter.hasNext()) {
map.plus(iter.next());
}
context.write(key, map);
}
@Override
public void subscribe(Subscriber<? super T> s) {
Iterator<? extends T> it;
try {
it = iterable.iterator();
} catch (Throwable e) {
EmptySubscription.error(s, e);
return;
}
subscribe(s, it);
}
private static <T> Object[] toArray(Iterable<T> elements) {
if (elements instanceof java.util.List) {
final java.util.List<T> list = (java.util.List<T>) elements;
return list.toArray();
} else {
final java.util.Iterator<? extends T> it = elements.iterator();
final java.util.List<T> list = new java.util.ArrayList<>();
while (it.hasNext()) {
list.add(it.next());
}
return list.toArray();
}
}
/**
* Evaluates BuildRun description.
*
* @param changes - set of changes affected by this BuildRun.
* @return description string.
*/
public static String getModificationDescription(Iterable<VcsModification> changes) {
// Create Set to filter changes unique by User and Comment
StringBuilder result = new StringBuilder(256);
for (Iterator<VcsModification> it = changes.iterator(); it.hasNext(); ) {
VcsModification mod = it.next();
result.append(mod.getUserName());
result.append(": ");
result.append(mod.getComment());
if (it.hasNext()) {
result.append("<br>");
}
}
return result.toString();
}
/** {@inheritDoc} */
@Override
public Iterator<T> iterator() {
if (iter == null && iterTaken) throw new IgniteException("Cursor is closed.");
if (iterTaken) throw new IgniteException("Iterator is already taken from this cursor.");
iterTaken = true;
iter = iterExec.iterator();
assert iter != null;
return iter;
}
public static String collectionToDelimitedString(
Iterable<?> coll, String delim, String prefix, String suffix, StringBuilder sb) {
if (Iterables.isEmpty(coll)) {
return "";
}
Iterator<?> it = coll.iterator();
while (it.hasNext()) {
sb.append(prefix).append(it.next()).append(suffix);
if (it.hasNext()) {
sb.append(delim);
}
}
return sb.toString();
}
public static <T extends Comparable<T>> boolean isSorted(Iterable<T> iterable) {
Iterator<T> iter = iterable.iterator();
if (!iter.hasNext()) {
return true;
}
T t = iter.next();
while (iter.hasNext()) {
T t2 = iter.next();
if (t.compareTo(t2) > 0) {
return false;
}
t = t2;
}
return true;
}
/**
* Generates a synthetic network for provided vertices in the given graphh such that the provided
* expected number of communities are generated with the specified expected number of edges.
*
* @param graph
* @param vertices
* @param expectedNumCommunities
* @param expectedNumEdges
* @return The actual number of edges generated. May be different from the expected number.
*/
public int generate(
Graph graph, Iterable<Vertex> vertices, int expectedNumCommunities, int expectedNumEdges) {
if (communitySize == null)
throw new IllegalStateException("Need to initialize community size distribution");
if (edgeDegree == null)
throw new IllegalStateException("Need to initialize degree distribution");
int numVertices = SizableIterable.sizeOf(vertices);
Iterator<Vertex> iter = vertices.iterator();
ArrayList<ArrayList<Vertex>> communities =
new ArrayList<ArrayList<Vertex>>(expectedNumCommunities);
Distribution communityDist = communitySize.initialize(expectedNumCommunities, numVertices);
while (iter.hasNext()) {
int nextSize = communityDist.nextValue(random);
ArrayList<Vertex> community = new ArrayList<Vertex>(nextSize);
for (int i = 0; i < nextSize && iter.hasNext(); i++) {
community.add(iter.next());
}
if (!community.isEmpty()) communities.add(community);
}
double inCommunityPercentage = 1.0 - crossCommunityPercentage;
Distribution degreeDist = edgeDegree.initialize(numVertices, expectedNumEdges);
if (crossCommunityPercentage > 0 && communities.size() < 2)
throw new IllegalArgumentException("Cannot have cross links with only one community");
int addedEdges = 0;
// System.out.println("Generating links on communities: "+communities.size());
for (ArrayList<Vertex> community : communities) {
for (Vertex v : community) {
int degree = degreeDist.nextValue(random);
degree =
Math.min(degree, (int) Math.ceil((community.size() - 1) / inCommunityPercentage) - 1);
Set<Vertex> inlinks = new HashSet<Vertex>();
for (int i = 0; i < degree; i++) {
Vertex selected = null;
if (random.nextDouble() < crossCommunityPercentage
|| (community.size() - 1 <= inlinks.size())) {
// Cross community
ArrayList<Vertex> othercomm = null;
while (othercomm == null) {
othercomm = communities.get(random.nextInt(communities.size()));
if (othercomm.equals(community)) othercomm = null;
}
selected = othercomm.get(random.nextInt(othercomm.size()));
} else {
// In community
while (selected == null) {
selected = community.get(random.nextInt(community.size()));
if (v.equals(selected) || inlinks.contains(selected)) selected = null;
}
inlinks.add(selected);
}
addEdge(graph, v, selected);
addedEdges++;
}
}
}
return addedEdges;
}
