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);
}
/*
* (non-Javadoc)
* @see de.hpi.bpt.graph.abs.IDirectedEdge#setVertices(de.hpi.bpt.hypergraph.abs.IVertex, de.hpi.bpt.hypergraph.abs.IVertex)
*/
@SuppressWarnings("unchecked")
public void setVertices(V s, V t) {
if (this.graph == null) return;
if (s == null || t == null) return;
if (!this.graph.isMultiGraph()) {
Collection<IDirectedHyperEdge<V>> es = this.graph.getEdgesWithSourceAndTarget(s, t);
if (es.size() > 0) {
Iterator<IDirectedHyperEdge<V>> i = es.iterator();
while (i.hasNext()) {
IDirectedHyperEdge<V> e = i.next();
if (e.getVertices().size() == 2) return;
}
}
}
Collection<V> ss = new ArrayList<V>();
Collection<V> ts = new ArrayList<V>();
if (this.source != null && this.target != null) {
ss.add(this.source);
ts.add(this.target);
super.removeSourceAndTagetVertices(ss, ts);
}
ss.clear();
ss.add(s);
ts.clear();
ts.add(t);
super.addSourceAndTagetVertices(ss, ts);
this.source = s;
this.target = t;
}
private void prepareAnimation() {
yMap.clear();
positionMap.clear();
beforeVisible.clear();
afterVisible.clear();
adapter.setMayNotify(false);
final int childCount = getChildCount();
final int firstVisiblePosition = getFirstVisiblePosition();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final long id = adapter.getItemId(firstVisiblePosition + i);
yMap.put(id, ViewHelper.getY(child));
positionMap.put(id, firstVisiblePosition + i);
}
for (int i = 0; i < firstVisiblePosition; i++) {
final long id = adapter.getItemId(i);
beforeVisible.add(id);
}
final int count = adapter.getCount();
for (int i = firstVisiblePosition + childCount; i < count; i++) {
final long id = adapter.getItemId(i);
afterVisible.add(id);
}
}
/**
* Handles activation of the editor or it's associated views.
* <!--
* begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
protected void handleActivate() {
// Recompute the read only state.
//
if (editingDomain.getResourceToReadOnlyMap() != null) {
editingDomain.getResourceToReadOnlyMap().clear();
// Refresh any actions that may become enabled or disabled.
//
setSelection(getSelection());
}
if (!removedResources.isEmpty()) {
if (handleDirtyConflict()) {
getSite().getPage().closeEditor(RmapEditor.this, false);
} else {
removedResources.clear();
changedResources.clear();
savedResources.clear();
}
} else if (!changedResources.isEmpty()) {
changedResources.removeAll(savedResources);
handleChangedResources();
changedResources.clear();
savedResources.clear();
}
}
public void reset() {
dotsA.clear();
dotsB.clear();
fillWithDots(dotsA, oval1a, dotsCountA1);
fillWithDots(dotsA, oval1b, dotsCountA2);
fillWithDots(dotsB, oval2, dotsCountB);
resetConnections();
}
public void clearInformation() {
assertions_.clear();
standing_ = new WeightedStanding();
infoboxType_ = null;
concreteAssertions_.clear();
concreteParentageAssertions_.clear();
minedTypes_ = -1;
isModified_ = false;
}
/** Clear all observers */
public void clear() {
lock.lock();
try {
onceUsedObservers.clear();
} finally {
lock.unlock();
}
observers.clear();
attackCalcObservers.clear();
}
/** Cleans up resources to avoid excessive memory usage. */
public void cleanUp() {
topSnapshot.set(null);
singleMsgs.clear();
fullMsgs.clear();
rcvdIds.clear();
oldestNode.set(null);
partReleaseFut = null;
Collection<ClusterNode> rmtNodes = this.rmtNodes;
if (rmtNodes != null) rmtNodes.clear();
}
@Override
protected void finalizeDismiss() {
if (getActiveDismissCount() == 0 && getActiveSwipeCount() == 0) {
restoreViewPresentations(mDismissedViews);
notifyCallback(mDismissedPositions);
Collection<Integer> newUndoPositions =
ListViewAnimationsUtils.processDeletions(mUndoPositions, mDismissedPositions);
mUndoPositions.clear();
mUndoPositions.addAll(newUndoPositions);
mDismissedViews.clear();
mDismissedPositions.clear();
}
}
@BeforeTest
public void reset() {
first = false;
second = false;
values.clear();
out.println("NEW TEST");
}
/**
* Creates an instance of an AtomCache that is pointed to the a particular path in the file
* system.
*
* @param pdbFilePath a directory in the file system to use as a location to cache files.
* @param cachePath
*/
public AtomCache(String pdbFilePath, String cachePath) {
logger.debug(
"Initialising AtomCache with pdbFilePath={}, cachePath={}", pdbFilePath, cachePath);
if (!pdbFilePath.endsWith(FILE_SEPARATOR)) {
pdbFilePath += FILE_SEPARATOR;
}
// we are caching the binary files that contain the PDBs gzipped
// that is the most memory efficient way of caching...
// set the input stream provider to caching mode
System.setProperty(InputStreamProvider.CACHE_PROPERTY, "true");
setPath(pdbFilePath);
this.cachePath = cachePath;
fetchBehavior = FetchBehavior.DEFAULT;
obsoleteBehavior = ObsoleteBehavior.DEFAULT;
currentlyLoading.clear();
params = new FileParsingParameters();
setUseMmCif(true);
}
public void index() {
returns.clear();
yields.clear();
code.visit(
new AbstractIRVisitor() {
@Override
public void visitReturn(ReturnInstruction returnInstruction) {
returns.add(returnInstruction);
}
@Override
public void visitYieldCall(YieldCall yieldCall) {
yields.add(yieldCall);
}
});
}
protected void clearCollection(final Collection val) {
if (val == null) {
return;
}
val.clear();
}
protected void makeCopyOfPoints(Collection<Point> col) {
Collection<Point> col_copy = new LinkedList<Point>(col);
col.clear();
for (Point p : col_copy) {
col.add((Point) p.clone());
}
}
public static Collection<Element> getElements(Element root, String path) {
String tPath = path;
List<Element> fila = new LinkedList<Element>();
fila.add(root);
Collection<Element> resp = new LinkedList<Element>();
do {
int p = tPath.indexOf("/");
String name = p > 0 ? tPath.substring(0, p) : tPath;
fila.addAll(resp);
resp.clear();
while (!fila.isEmpty()) {
Element element = (Element) fila.remove(0);
NodeList nodes = element.getElementsByTagName(name);
for (int i = 0; i < nodes.getLength(); i++) {
resp.add((Element) nodes.item(i));
}
}
tPath = p > 0 ? tPath.substring(p + 1) : "";
} while (tPath.length() != 0);
return resp;
}
@Override
public Collection<Coin> getChangeFor(int pence, Product p)
throws NotEnoughChangeException, NotEnoughMoneyException {
changeInProgress.clear();
int difference = pence - p.getProductPrice();
loadConfig();
if (enoughMoneyProvided(pence, p)) {
if (enoughChange(difference)) {
for (Coin coin : Coin.values()) {
if (isCoinTypeNeeded(coin, difference - getCurrentChange())) {
supplyThisCoinType(coin, difference - getCurrentChange(), true);
}
}
if (getCurrentChange() != difference)
throw new NotEnoughChangeException("The machine has run out of change.");
updateConfig();
} else {
throw new NotEnoughChangeException("The machine has run out of change.");
}
} else {
throw new NotEnoughMoneyException("You have not provided enough money.");
}
return changeInProgress;
}
public static void tickAll() {
for (Animation a : animations) {
a.tick();
}
animations.removeAll(removeAnimations);
removeAnimations.clear();
}
@Override
public synchronized void close() throws SQLException {
try {
closeLock.writeLock().lock();
if (closed) {
return;
}
closed = true;
} finally {
closeLock.writeLock().unlock();
}
try {
Collection<ConnectionQueryServices> connectionQueryServices =
connectionQueryServicesMap.values();
try {
SQLCloseables.closeAll(connectionQueryServices);
} finally {
connectionQueryServices.clear();
}
} finally {
if (services != null) {
try {
services.close();
} finally {
ExecutorService executor = services.getExecutor();
// Even if something wrong happened while closing services above, we still
// want to set it to null. Otherwise, we will end up having a possibly non-working
// services instance.
services = null;
executor.shutdown();
}
}
}
}
public static <E> void replace(final Collection<E> into, final Collection<E> values) {
checkNotNull(into, "target cannot be null");
checkNotNull(values, "source cannot be null");
into.clear();
into.addAll(values);
}
protected void clearGroups() {
for (Collection<Tuple> collection : collections) {
collection.clear();
if (collection instanceof Spillable) ((Spillable) collection).setGrouping(grouping);
}
}
/**
* Converts the values of an FeatureMap, the values of the collection are converted to and added
* to the list in the correct feature in the modelObject.
*
* @param eObject the eObject from which the value is read
* @param modelObject the {@link ModelObject} in which the value is to be set
* @param eFeature the eFeature which is converted
*/
protected void convertFeatureMap(
final EObject eObject, final ModelObject<?> modelObject, final EStructuralFeature eFeature) {
final Collection<?> eValues = (Collection<?>) eObject.eGet(eFeature);
@SuppressWarnings("unchecked")
final Collection<Object> values = (Collection<Object>) modelObject.eGet(eFeature);
// clear as the object may have been read from the db
values.clear();
for (final Object eValue : eValues) {
final FeatureMap.Entry eEntry = (FeatureMap.Entry) eValue;
final Object featureMapEntry = ModelResolver.getInstance().createFeatureMapEntry(eFeature);
final ModelFeatureMapEntry<?> mEntry =
ModelResolver.getInstance().getModelFeatureMapEntry(eFeature, featureMapEntry);
mEntry.setEStructuralFeature(eEntry.getEStructuralFeature());
final Object convertedValue;
if (mEntry.getEStructuralFeature() instanceof EAttribute) {
convertedValue =
convertEAttributeValue(
eEntry.getValue(),
((EAttribute) eEntry.getEStructuralFeature()).getEAttributeType());
} else {
convertedValue = createTarget((EObject) eEntry.getValue());
}
mEntry.setValue(convertedValue);
values.add(featureMapEntry);
}
}
public static void main(String[] args) {
Collection c = new ArrayList();
// 添加元素
c.add("孙悟空");
// 虽然集合里不能放基本类型的值，但Java支持自动装箱
c.add(6);
System.out.println("c集合的元素个数为:" + c.size());
// 删除指定元素
c.remove(6);
System.out.println("c集合的元素个数为:" + c.size());
// 判断是否包含指定字符串
System.out.println("c集合的是否包含\"孙悟空\"字符串:" + c.contains("孙悟空"));
c.add("轻量级Java EE企业应用实战");
System.out.println("c集合的元素：" + c);
Collection books = new HashSet();
books.add("轻量级Java EE企业应用实战");
books.add("疯狂Java讲义");
System.out.println("c集合是否完全包含books集合？" + c.containsAll(books));
// 用c集合减去books集合里的元素
c.removeAll(books);
System.out.println("c集合的元素：" + c);
// 删除c集合里所有元素
c.clear();
System.out.println("c集合的元素：" + c);
// books集合里只剩下c集合里也包含的元素
books.retainAll(c);
System.out.println("books集合的元素:" + books);
}
/**
* Set the refs collection to the entity reference strings from the entities collection (and
* nothing more)
*
* @param refs The collection (String) of entity references to modify.
* @param entities The collection (Entity) of entity objects to use.
*/
public static void setEntityRefsFromEntities(Collection refs, Collection entities) {
refs.clear();
for (Iterator i = entities.iterator(); i.hasNext(); ) {
Entity entity = (Entity) i.next();
refs.add(entity.getReference());
}
}
// look up and apply coarts for given rels to each sign in result
private void applyCoarts(List<String> coartRels, Collection<Sign> result) {
List<Sign> inputSigns = new ArrayList<Sign>(result);
result.clear();
List<Sign> outputSigns = new ArrayList<Sign>(inputSigns.size());
// for each rel, lookup coarts and apply to input signs, storing results in output signs
for (Iterator<String> it = coartRels.iterator(); it.hasNext(); ) {
String rel = it.next();
Collection<String> preds = (Collection<String>) _coartRelsToPreds.get(rel);
if (preds == null) continue; // not expected
Collection<Sign> coartResult = getSignsFromRelAndPreds(rel, preds);
if (coartResult == null) continue;
for (Iterator<Sign> it2 = coartResult.iterator(); it2.hasNext(); ) {
Sign coartSign = it2.next();
// apply to each input
for (int j = 0; j < inputSigns.size(); j++) {
Sign sign = inputSigns.get(j);
grammar.rules.applyCoart(sign, coartSign, outputSigns);
}
}
// switch output to input for next iteration
inputSigns.clear();
inputSigns.addAll(outputSigns);
outputSigns.clear();
}
// add results back
result.addAll(inputSigns);
}
@Override
public boolean uninstall(OTEStatusCallback<ConfigurationStatus> statusCallback) {
boolean result = true;
for (Bundle bundle : installedBundles) {
try {
bundle.uninstall();
} catch (BundleException ex) {
result = false;
statusCallback.error("Failed to uninstall " + bundle.getSymbolicName(), ex);
}
}
installedBundles.clear();
for (Bundle bundle : runningBundles) {
try {
String entry = bundle.getHeaders().get("Fragment-Host");
if (entry == null) {
bundle.stop();
}
bundle.uninstall();
} catch (BundleException ex) {
result = false;
statusCallback.error("Failed to stop and uninstall " + bundle.getSymbolicName(), ex);
}
}
runningBundles.clear();
return result;
}
/** @see junit.framework.TestCase */
protected void tearDown() throws Exception {
assertNotNull("The collection of logs is null!", logs);
logs.clear();
logs = null;
logRecv = null;
super.tearDown();
}
public void refreshColumns(DatabaseMetaData metaData) throws SQLException {
columns.clear();
ResultSet rs = null;
try {
rs = metaData.getColumns(catalog, schema, name, null);
while (rs.next()) {
Column column = new Column();
columns.add(column);
column.setOwner(this);
column.setName(rs.getString("COLUMN_NAME"));
column.setDataType(rs.getInt("DATA_TYPE"));
column.setTypeName(rs.getString("TYPE_NAME"));
column.setSize(rs.getInt("COLUMN_SIZE"));
column.setDecimalDigits(rs.getInt("DECIMAL_DIGITS"));
column.setRadix(rs.getInt("NUM_PREC_RADIX"));
column.setNullable(rs.getInt("NULLABLE"));
column.setRemarks(rs.getString("REMARKS"));
column.setDefaultValue(rs.getString("COLUMN_DEF"));
column.setCharOctetLength(rs.getInt("CHAR_OCTET_LENGTH"));
column.setOrdinalPosition(rs.getInt("ORDINAL_POSITION"));
}
} catch (SQLException sqle) {
throw sqle;
} finally {
try {
rs.close();
} catch (Exception ex) {
}
}
}
/** @param cnt Count. */
private void checkPoll(int cnt) {
init();
int step = 10;
assert cnt % step == 0;
Collection<Long> set = new HashSet<>(step);
for (int i = 0; i < cnt; i++) lru.offer(0, i, i);
assertEquals(cnt, lru.size());
for (int i = 0; i < cnt; i += step) {
for (int j = 0; j < step; j++) {
long qAddr = lru.prePoll();
assertTrue(qAddr != 0);
assertTrue(set.add(qAddr));
}
for (long qAddr : set) lru.poll(qAddr);
set.clear();
}
assertEquals(0, lru.size());
}
private void finishCurrentDataSourceOperation(boolean theIsTop) throws DataSourceException {
if (theIsTop) {
mCascadePending.clear();
mOp.execute();
mOp = null;
}
}
public void refreshForeignKeys(DatabaseMetaData metaData) throws SQLException {
foreignKeys.clear();
ResultSet rs = null;
try {
rs = metaData.getImportedKeys(catalog, schema, name);
while (rs.next()) {
ForeignKey fk = new ForeignKey();
foreignKeys.add(fk);
fk.setOwner(this);
fk.setPkTableCatalog(rs.getString("PKTABLE_CAT"));
fk.setPkTableSchema(rs.getString("PKTABLE_SCHEM"));
fk.setPkTableName(rs.getString("PKTABLE_NAME"));
fk.setPkColumnName(rs.getString("PKCOLUMN_NAME"));
fk.setColumnName(rs.getString("FKCOLUMN_NAME"));
fk.setKeySequence(rs.getShort("KEY_SEQ"));
fk.setUpdateRule(rs.getShort("UPDATE_RULE"));
fk.setDeleteRule(rs.getShort("DELETE_RULE"));
fk.setName(rs.getString("FK_NAME"));
fk.setPkName(rs.getString("PK_NAME"));
fk.setDeferrability(rs.getShort("DEFERRABILITY"));
}
} catch (SQLException sqle) {
throw sqle;
} finally {
try {
rs.close();
} catch (Exception ex) {
}
}
}
