private List<InjInfo> getSelectedInjections() {
final ArrayList<InjInfo> toRemove = new ArrayList<InjInfo>();
for (int row : myInjectionsTable.getSelectedRows()) {
toRemove.add(myInjectionsTable.getItems().get(myInjectionsTable.convertRowIndexToModel(row)));
}
return toRemove;
}
@Nullable
public static Configuration load(final InputStream is) throws IOException, JDOMException {
try {
final Document document = JDOMUtil.loadDocument(is);
final ArrayList<Element> elements = new ArrayList<Element>();
elements.add(document.getRootElement());
elements.addAll(document.getRootElement().getChildren("component"));
final Element element =
ContainerUtil.find(
elements,
new Condition<Element>() {
public boolean value(final Element element) {
return "component".equals(element.getName())
&& COMPONENT_NAME.equals(element.getAttributeValue("name"));
}
});
if (element != null) {
final Configuration cfg = new Configuration();
cfg.loadState(element, false);
return cfg;
}
return null;
} finally {
is.close();
}
}
public void addProgress(@NotNull ProgressIndicatorEx original, @NotNull TaskInfo info) {
synchronized (myOriginals) {
final boolean veryFirst = !hasProgressIndicators();
myOriginals.add(original);
myInfos.add(info);
final InlineProgressIndicator expanded = createInlineDelegate(info, original, false);
final InlineProgressIndicator compact = createInlineDelegate(info, original, true);
myPopup.addIndicator(expanded);
myProgressIcon.resume();
if (veryFirst && !myPopup.isShowing()) {
buildInInlineIndicator(compact);
} else {
buildInProcessCount();
if (myInfos.size() > 1 && Registry.is("ide.windowSystem.autoShowProcessPopup")) {
openProcessPopup(false);
}
}
runQuery();
}
}
@NotNull
public EditorWindow[] getOrderedWindows() {
final ArrayList<EditorWindow> res = new ArrayList<EditorWindow>();
// Collector for windows in tree ordering:
class Inner {
final void collect(final JPanel panel) {
final Component comp = panel.getComponent(0);
if (comp instanceof Splitter) {
final Splitter splitter = (Splitter) comp;
collect((JPanel) splitter.getFirstComponent());
collect((JPanel) splitter.getSecondComponent());
} else if (comp instanceof JPanel || comp instanceof JBTabs) {
final EditorWindow window = findWindowWith(comp);
if (window != null) {
res.add(window);
}
}
}
}
// get root component and traverse splitters tree:
if (getComponentCount() != 0) {
final Component comp = getComponent(0);
LOG.assertTrue(comp instanceof JPanel);
final JPanel panel = (JPanel) comp;
if (panel.getComponentCount() != 0) {
new Inner().collect(panel);
}
}
LOG.assertTrue(res.size() == myWindows.size());
return res.toArray(new EditorWindow[res.size()]);
}
private synchronized void assertAllPointersDisposed() {
for (Map.Entry<VirtualFilePointerListener, FilePointerPartNode> entry : myPointers.entrySet()) {
FilePointerPartNode root = entry.getValue();
ArrayList<FilePointerPartNode> left = new ArrayList<FilePointerPartNode>();
root.getPointersUnder(null, false, "", left);
if (!left.isEmpty()) {
VirtualFilePointerImpl p = left.get(0).leaf;
try {
p.throwDisposalError("Not disposed pointer: " + p);
} finally {
for (FilePointerPartNode pair : left) {
VirtualFilePointerImpl pointer = pair.leaf;
pointer.dispose();
}
}
}
}
synchronized (myContainers) {
if (!myContainers.isEmpty()) {
VirtualFilePointerContainerImpl container = myContainers.iterator().next();
container.throwDisposalError("Not disposed container");
}
}
}
@Override
public void writeExternal(Element rootElement) throws WriteExternalException {
LOG.assertTrue(!isDisposed(), "Already disposed!");
Element element = new Element(ELEMENT);
if (myName != null) {
element.setAttribute(LIBRARY_NAME_ATTR, myName);
}
if (myKind != null) {
element.setAttribute(LIBRARY_TYPE_ATTR, myKind.getKindId());
final Object state = myProperties.getState();
if (state != null) {
final Element propertiesElement = XmlSerializer.serialize(state, SERIALIZATION_FILTERS);
if (propertiesElement != null
&& (!propertiesElement.getContent().isEmpty()
|| !propertiesElement.getAttributes().isEmpty())) {
element.addContent(propertiesElement.setName(PROPERTIES_ELEMENT));
}
}
}
ArrayList<OrderRootType> storableRootTypes = new ArrayList<OrderRootType>();
storableRootTypes.addAll(Arrays.asList(OrderRootType.getAllTypes()));
if (myKind != null) {
storableRootTypes.addAll(Arrays.asList(myKind.getAdditionalRootTypes()));
}
for (OrderRootType rootType : sortRootTypes(storableRootTypes)) {
final VirtualFilePointerContainer roots = myRoots.get(rootType);
if (roots.size() == 0 && rootType.skipWriteIfEmpty()) continue; // compatibility iml/ipr
final Element rootTypeElement = new Element(rootType.name());
roots.writeExternal(rootTypeElement, ROOT_PATH_ELEMENT);
element.addContent(rootTypeElement);
}
myJarDirectories.writeExternal(element);
rootElement.addContent(element);
}
public EditorWithProviderComposite[] getEditorsComposites() {
final ArrayList<EditorWithProviderComposite> res = new ArrayList<EditorWithProviderComposite>();
for (final EditorWindow myWindow : myWindows) {
final EditorWithProviderComposite[] editors = myWindow.getEditors();
ContainerUtil.addAll(res, editors);
}
return res.toArray(new EditorWithProviderComposite[res.size()]);
}
@NotNull
public List<EditorWindow> findWindows(final VirtualFile file) {
final ArrayList<EditorWindow> res = new ArrayList<EditorWindow>();
for (final EditorWindow window : myWindows) {
if (window.findFileComposite(file) != null) {
res.add(window);
}
}
return res;
}
static {
ourAbstractUrlProviders.add(new ModuleUrl(null, null));
ourAbstractUrlProviders.add(new DirectoryUrl(null, null));
ourAbstractUrlProviders.add(new ModuleGroupUrl(null));
ourAbstractUrlProviders.add(new PsiFileUrl(null));
ourAbstractUrlProviders.add(new LibraryModuleGroupUrl(null));
ourAbstractUrlProviders.add(new NamedLibraryUrl(null, null));
}
@NotNull
public List<EditorWithProviderComposite> findEditorComposites(final VirtualFile file) {
final ArrayList<EditorWithProviderComposite> res = new ArrayList<EditorWithProviderComposite>();
for (final EditorWindow window : myWindows) {
final EditorWithProviderComposite fileComposite = window.findFileComposite(file);
if (fileComposite != null) {
res.add(fileComposite);
}
}
return res;
}
private void removeInvalidBreakpoints() {
ArrayList<Breakpoint> toDelete = new ArrayList<Breakpoint>();
for (Breakpoint breakpoint : getBreakpoints()) {
if (!breakpoint.isValid()) {
toDelete.add(breakpoint);
}
}
for (final Breakpoint aToDelete : toDelete) {
removeBreakpoint(aToDelete);
}
}
/**
* @return breakpoints of one of the category: LINE_BREAKPOINTS, EXCEPTION_BREAKPOINTS,
* FIELD_BREAKPOINTS, METHOD_BREAKPOINTS
*/
public <T extends Breakpoint> Breakpoint[] getBreakpoints(@NotNull final Key<T> category) {
ApplicationManager.getApplication().assertIsDispatchThread();
removeInvalidBreakpoints();
final ArrayList<Breakpoint> breakpoints = new ArrayList<Breakpoint>();
for (Breakpoint breakpoint : getBreakpoints()) {
if (category.equals(breakpoint.getCategory())) {
breakpoints.add(breakpoint);
}
}
return breakpoints.toArray(new Breakpoint[breakpoints.size()]);
}
/**
* Import from another configuration (e.g. imported file). Returns the number of imported items.
*
* @param cfg configuration to import from
* @return added injections count
*/
public int importFrom(final Configuration cfg) {
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
importInjections(
getInjections(supportId),
cfg.getInjections(supportId),
originalInjections,
newInjections);
}
if (!newInjections.isEmpty()) configurationModified();
replaceInjections(newInjections, originalInjections);
return newInjections.size();
}
private void mergeWithDefaultConfiguration() {
final ArrayList<Configuration> cfgList = new ArrayList<Configuration>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
final String config = support.getDefaultConfigUrl();
final URL url = config == null ? null : support.getClass().getResource(config);
if (url != null) {
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
}
final THashSet<Object> visited = new THashSet<Object>();
for (IdeaPluginDescriptor pluginDescriptor : PluginManager.getPlugins()) {
if (pluginDescriptor instanceof IdeaPluginDescriptorImpl
&& !((IdeaPluginDescriptorImpl) pluginDescriptor).isEnabled()) continue;
final ClassLoader loader = pluginDescriptor.getPluginClassLoader();
if (!visited.add(loader)) continue;
if (loader instanceof PluginClassLoader && ((PluginClassLoader) loader).getUrls().isEmpty())
continue;
try {
final Enumeration<URL> enumeration = loader.getResources("META-INF/languageInjections.xml");
if (enumeration == null) continue;
while (enumeration.hasMoreElements()) {
URL url = enumeration.nextElement();
if (!visited.add(url.getFile())) continue; // for DEBUG mode
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
} catch (Exception e) {
LOG.warn(e);
}
}
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
myDefaultInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
for (Configuration cfg : cfgList) {
final List<BaseInjection> imported = cfg.getInjections(supportId);
myDefaultInjections.addAll(imported);
importInjections(getInjections(supportId), imported, originalInjections, newInjections);
}
}
replaceInjections(newInjections, originalInjections);
}
@NotNull
public List<Pair<TaskInfo, ProgressIndicator>> getBackgroundProcesses() {
synchronized (myOriginals) {
if (myOriginals.isEmpty()) return Collections.emptyList();
List<Pair<TaskInfo, ProgressIndicator>> result =
new ArrayList<Pair<TaskInfo, ProgressIndicator>>(myOriginals.size());
for (int i = 0; i < myOriginals.size(); i++) {
result.add(Pair.<TaskInfo, ProgressIndicator>create(myInfos.get(i), myOriginals.get(i)));
}
return Collections.unmodifiableList(result);
}
}
private ProgressIndicatorEx removeFromMaps(@NotNull InlineProgressIndicator progress) {
final ProgressIndicatorEx original = myInline2Original.get(progress);
myInline2Original.remove(progress);
myOriginal2Inlines.remove(original, progress);
if (myOriginal2Inlines.get(original) == null) {
final int originalIndex = myOriginals.indexOf(original);
myOriginals.remove(originalIndex);
myInfos.remove(originalIndex);
}
return original;
}
void hideProcessPopup() {
synchronized (myOriginals) {
if (!myPopup.isShowing()) return;
if (myOriginals.size() == 1) {
buildInInlineIndicator(createInlineDelegate(myInfos.get(0), myOriginals.get(0), true));
} else if (!hasProgressIndicators()) {
restoreEmptyStatus();
} else {
buildInProcessCount();
}
myPopup.hide();
}
}
private static List<ShelvedBinaryFile> getBinaryFilesToUnshelve(
final ShelvedChangeList changeList,
final List<ShelvedBinaryFile> binaryFiles,
final List<ShelvedBinaryFile> remainingBinaries) {
if (binaryFiles == null) {
return new ArrayList<ShelvedBinaryFile>(changeList.getBinaryFiles());
}
ArrayList<ShelvedBinaryFile> result = new ArrayList<ShelvedBinaryFile>();
for (ShelvedBinaryFile file : changeList.getBinaryFiles()) {
if (binaryFiles.contains(file)) {
result.add(file);
} else {
remainingBinaries.add(file);
}
}
return result;
}
public void addEntryPoint(RefElement newEntryPoint, boolean isPersistent) {
if (!newEntryPoint.isValid()) return;
if (newEntryPoint instanceof RefClass) {
RefClass refClass = (RefClass) newEntryPoint;
if (refClass.isAnonymous()) {
// Anonymous class cannot be an entry point.
return;
}
ArrayList<RefMethod> refConstructors = refClass.getConstructors();
if (refConstructors.size() == 1) {
addEntryPoint(refConstructors.get(0), isPersistent);
return;
} else if (refConstructors.size() > 1) {
// Many constructors here. Need to ask user which ones are used
for (int i = 0; i < refConstructors.size(); i++) {
addEntryPoint((RefMethod) ((ArrayList) refConstructors).get(i), isPersistent);
}
return;
}
}
if (isPersistent) {
myTemporaryEntryPoints.add(newEntryPoint);
((RefElementImpl) newEntryPoint).setEntry(true);
} else {
if (myPersistentEntryPoints.get(newEntryPoint.getExternalName()) == null) {
final SmartRefElementPointerImpl entry =
new SmartRefElementPointerImpl(newEntryPoint, true);
myPersistentEntryPoints.put(entry.getFQName(), entry);
((RefElementImpl) newEntryPoint).setEntry(true);
((RefElementImpl) newEntryPoint).setPermanentEntry(true);
if (entry.isPersistent()) { // do save entry points
final EntryPointsManagerImpl entryPointsManager =
getInstance(newEntryPoint.getElement().getProject());
if (this != entryPointsManager) {
entryPointsManager.addEntryPoint(newEntryPoint, true);
}
}
}
}
}
@Override
public Configurable[] getConfigurables() {
if (myConfigurables == null) {
final ArrayList<Configurable> configurables = new ArrayList<Configurable>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(configurables, support.createSettings(myProject, myConfiguration));
}
Collections.sort(
configurables,
new Comparator<Configurable>() {
public int compare(final Configurable o1, final Configurable o2) {
return Comparing.compare(o1.getDisplayName(), o2.getDisplayName());
}
});
myConfigurables = configurables.toArray(new Configurable[configurables.size()]);
}
return myConfigurables;
}
public static <T> void assertOrderedEquals(
final String erroMsg,
final Iterable<? extends T> actual,
final Collection<? extends T> expected) {
ArrayList<T> list = new ArrayList<T>();
for (T t : actual) {
list.add(t);
}
if (!list.equals(new ArrayList<T>(expected))) {
String expectedString = toString(expected);
String actualString = toString(actual);
Assert.assertEquals(erroMsg, expectedString, actualString);
Assert.fail(
"Warning! 'toString' does not reflect the difference.\nExpected: "
+ expectedString
+ "\nActual: "
+ actualString);
}
}
private void baseRevisionsOfDvcsIntoContext(
List<Change> textChanges, CommitContext commitContext) {
ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (vcsManager.dvcsUsedInProject()
&& VcsConfiguration.getInstance(myProject).INCLUDE_TEXT_INTO_SHELF) {
final Set<Change> big = SelectFilesToAddTextsToPatchPanel.getBig(textChanges);
final ArrayList<FilePath> toKeep = new ArrayList<FilePath>();
for (Change change : textChanges) {
if (change.getBeforeRevision() == null || change.getAfterRevision() == null) continue;
if (big.contains(change)) continue;
FilePath filePath = ChangesUtil.getFilePath(change);
final AbstractVcs vcs = vcsManager.getVcsFor(filePath);
if (vcs != null && VcsType.distibuted.equals(vcs.getType())) {
toKeep.add(filePath);
}
}
commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, true);
commitContext.putUserData(BaseRevisionTextPatchEP.ourBaseRevisionPaths, toKeep);
}
}
@Override
public Object findElement(String s) {
List<ObjectWithWeight> elements = new ArrayList<ObjectWithWeight>();
s = s.trim();
final ListIterator<Object> it = getElementIterator(0);
while (it.hasNext()) {
final ObjectWithWeight o = new ObjectWithWeight(it.next(), s, getComparator());
if (!o.weights.isEmpty()) {
elements.add(o);
}
}
ObjectWithWeight cur = null;
ArrayList<ObjectWithWeight> current = new ArrayList<ObjectWithWeight>();
for (ObjectWithWeight element : elements) {
if (cur == null) {
cur = element;
current.add(cur);
continue;
}
final int i = element.compareWith(cur);
if (i == 0) {
current.add(element);
} else if (i < 0) {
cur = element;
current.clear();
current.add(cur);
}
}
return current.isEmpty() ? null : findClosestTo(myInitialPsiElement, current);
}
private void removeProgress(@NotNull InlineProgressIndicator progress) {
synchronized (myOriginals) {
if (!myInline2Original.containsKey(progress)) return;
final boolean last = myOriginals.size() == 1;
final boolean beforeLast = myOriginals.size() == 2;
myPopup.removeIndicator(progress);
final ProgressIndicatorEx original = removeFromMaps(progress);
if (myOriginals.contains(original)) return;
if (last) {
restoreEmptyStatus();
if (myShouldClosePopupAndOnProcessFinish) {
hideProcessPopup();
}
} else {
if (myPopup.isShowing() || myOriginals.size() > 1) {
buildInProcessCount();
} else if (beforeLast) {
buildInInlineIndicator(createInlineDelegate(myInfos.get(0), myOriginals.get(0), true));
} else {
restoreEmptyStatus();
}
}
runQuery();
}
}
private int importPlaces(final List<BaseInjection> injections) {
final Map<String, Set<BaseInjection>> map =
ContainerUtil.classify(
injections.iterator(),
new Convertor<BaseInjection, String>() {
@Override
public String convert(final BaseInjection o) {
return o.getSupportId();
}
});
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
final Set<BaseInjection> importingInjections = map.get(supportId);
if (importingInjections == null) continue;
importInjections(
getInjections(supportId), importingInjections, originalInjections, newInjections);
}
if (!newInjections.isEmpty()) configurationModified();
replaceInjections(newInjections, originalInjections, true);
return newInjections.size();
}
public boolean setHostInjectionEnabled(
final PsiLanguageInjectionHost host,
final Collection<String> languages,
final boolean enabled) {
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
for (BaseInjection injection : getInjections(support.getId())) {
if (!languages.contains(injection.getInjectedLanguageId())) continue;
boolean replace = false;
final ArrayList<InjectionPlace> newPlaces = new ArrayList<InjectionPlace>();
for (InjectionPlace place : injection.getInjectionPlaces()) {
if (place.isEnabled() != enabled
&& place.getElementPattern() != null
&& (place.getElementPattern().accepts(host)
|| place.getElementPattern().accepts(host.getParent()))) {
newPlaces.add(place.enabled(enabled));
replace = true;
} else newPlaces.add(place);
}
if (replace) {
originalInjections.add(injection);
final BaseInjection newInjection = injection.copy();
newInjection.setInjectionPlaces(newPlaces.toArray(new InjectionPlace[newPlaces.size()]));
newInjections.add(newInjection);
}
}
}
if (!originalInjections.isEmpty()) {
replaceInjectionsWithUndo(
host.getProject(),
newInjections,
originalInjections,
Collections.<PsiElement>emptyList());
return true;
}
return false;
}
private void buildInProcessCount() {
removeAll();
setLayout(new BorderLayout());
final JPanel progressCountPanel = new JPanel(new BorderLayout(0, 0));
progressCountPanel.setOpaque(false);
String processWord = myOriginals.size() == 1 ? " process" : " processes";
final LinkLabel label =
new LinkLabel(
myOriginals.size() + processWord + " running...",
null,
new LinkListener() {
@Override
public void linkSelected(final LinkLabel aSource, final Object aLinkData) {
triggerPopupShowing();
}
});
if (SystemInfo.isMac) label.setFont(UIUtil.getLabelFont().deriveFont(11.0f));
label.setOpaque(false);
final Wrapper labelComp = new Wrapper(label);
labelComp.setOpaque(false);
progressCountPanel.add(labelComp, BorderLayout.CENTER);
// myProgressIcon.setBorder(new IdeStatusBarImpl.MacStatusBarWidgetBorder());
progressCountPanel.add(myProgressIcon, BorderLayout.WEST);
add(myRefreshAndInfoPanel, BorderLayout.CENTER);
progressCountPanel.setBorder(new EmptyBorder(0, 0, 0, 4));
add(progressCountPanel, BorderLayout.EAST);
revalidate();
repaint();
}
private static List<BaseInjection> loadDefaultInjections() {
final ArrayList<Configuration> cfgList = new ArrayList<Configuration>();
final THashSet<Object> visited = new THashSet<Object>();
for (LanguageInjectionConfigBean configBean :
Extensions.getExtensions(LanguageInjectionSupport.CONFIG_EP_NAME)) {
PluginDescriptor descriptor = configBean.getPluginDescriptor();
final ClassLoader loader = descriptor.getPluginClassLoader();
try {
final Enumeration<URL> enumeration = loader.getResources(configBean.getConfigUrl());
if (enumeration == null || !enumeration.hasMoreElements()) {
LOG.warn(descriptor.getPluginId() + ": " + configBean.getConfigUrl() + " was not found");
} else {
while (enumeration.hasMoreElements()) {
URL url = enumeration.nextElement();
if (!visited.add(url.getFile())) continue; // for DEBUG mode
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
}
} catch (Exception e) {
LOG.warn(e);
}
}
final ArrayList<BaseInjection> defaultInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
for (Configuration cfg : cfgList) {
final List<BaseInjection> imported = cfg.getInjections(supportId);
defaultInjections.addAll(imported);
}
}
return defaultInjections;
}
@Nullable
private Object findClosestTo(PsiElement path, ArrayList<ObjectWithWeight> paths) {
if (path == null || myInitialPsiElement == null) {
return paths.get(0).node;
}
final Set<PsiElement> parents = getAllParents(myInitialPsiElement);
ArrayList<ObjectWithWeight> cur = new ArrayList<ObjectWithWeight>();
int max = -1;
for (ObjectWithWeight p : paths) {
final Object last = ((TreePath) p.node).getLastPathComponent();
final List<PsiElement> elements = new ArrayList<PsiElement>();
final Object object = ((DefaultMutableTreeNode) last).getUserObject();
if (object instanceof FilteringTreeStructure.FilteringNode) {
FilteringTreeStructure.FilteringNode node = (FilteringTreeStructure.FilteringNode) object;
FilteringTreeStructure.FilteringNode candidate = node;
while (node != null) {
elements.add(getPsi(node));
node = node.getParentNode();
}
final int size = ContainerUtil.intersection(parents, elements).size();
if (size == elements.size() - 1
&& size == parents.size() - (myInitialNodeIsLeaf ? 1 : 0)
&& candidate.children().isEmpty()) {
return p.node;
}
if (size > max) {
max = size;
cur.clear();
cur.add(p);
} else if (size == max) {
cur.add(p);
}
}
}
Collections.sort(
cur,
new Comparator<ObjectWithWeight>() {
@Override
public int compare(ObjectWithWeight o1, ObjectWithWeight o2) {
final int i = o1.compareWith(o2);
return i != 0
? i
: ((TreePath) o2.node).getPathCount() - ((TreePath) o1.node).getPathCount();
}
});
return cur.isEmpty() ? null : cur.get(0).node;
}
public <T> void assertDoesntContain(
Collection<? extends T> collection, Collection<T> notExpected) {
ArrayList<T> expected = new ArrayList<T>(collection);
expected.removeAll(notExpected);
assertSameElements(collection, expected);
}
