plugins/maven/src/test/java/org/jetbrains/idea/maven/MavenImportingTestCase.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.jetbrains.idea.maven;

 import com.intellij.compiler.server.BuildManager;
 import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.progress.EmptyProgressIndicator;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.ui.TestDialog;
 import com.intellij.openapi.util.AsyncResult;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.testFramework.IdeaTestUtil;
 import com.intellij.util.Consumer;
 import com.intellij.util.PathUtil;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.idea.maven.execution.*;
 import org.jetbrains.idea.maven.model.MavenArtifact;
 import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
 import org.jetbrains.idea.maven.project.MavenArtifactDownloader;
 import org.jetbrains.idea.maven.project.MavenProject;
 import org.jetbrains.idea.maven.project.MavenProjectsManager;
 import org.jetbrains.idea.maven.project.MavenProjectsTree;
 import org.jetbrains.jps.model.java.JavaResourceRootType;
 import org.jetbrains.jps.model.java.JavaSourceRootProperties;
 import org.jetbrains.jps.model.java.JavaSourceRootType;
 import org.jetbrains.jps.model.module.JpsModuleSourceRootType;

 import java.io.File;
 import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;

 public abstract class MavenImportingTestCase extends MavenTestCase {
   protected MavenProjectsTree myProjectsTree;
   protected MavenProjectsManager myProjectsManager;

   @Override
   protected void setUpInWriteAction() throws Exception {
     super.setUpInWriteAction();
     myProjectsManager = MavenProjectsManager.getInstance(myProject);
     removeFromLocalRepository("test");
   }

   @Override
   protected void tearDown() throws Exception {
     try {
       Messages.setTestDialog(TestDialog.DEFAULT);
       myProjectsManager.projectClosed();
       removeFromLocalRepository("test");
       FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory());
     }
     finally {
       super.tearDown();
     }
   }

   protected void assertModules(String... expectedNames) {
     Module[] actual = ModuleManager.getInstance(myProject).getModules();
     List<String> actualNames = new ArrayList<String>();

     for (Module m : actual) {
       actualNames.add(m.getName());
     }

     assertUnorderedElementsAreEqual(actualNames, expectedNames);
   }

   protected void assertContentRoots(String moduleName, String... expectedRoots) {
     List<String> actual = new ArrayList<String>();
     for (ContentEntry e : getContentRoots(moduleName)) {
       actual.add(e.getUrl());
     }

     for (int i = 0; i < expectedRoots.length; i++) {
       expectedRoots[i] = VfsUtil.pathToUrl(expectedRoots[i]);
     }

     assertUnorderedPathsAreEqual(actual, Arrays.asList(expectedRoots));
   }

   protected void assertSources(String moduleName, String... expectedSources) {
     doAssertContentFolders(moduleName, JavaSourceRootType.SOURCE, expectedSources);
   }

   protected void assertGeneratedSources(String moduleName, String... expectedSources) {
     ContentEntry contentRoot = getContentRoot(moduleName);
     List<ContentFolder> folders = new ArrayList<ContentFolder>();
     for (SourceFolder folder : contentRoot.getSourceFolders(JavaSourceRootType.SOURCE)) {
       JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaSourceRootType.SOURCE);
       assertNotNull(properties);
       if (properties.isForGeneratedSources()) {
         folders.add(folder);
       }
     }
     doAssertContentFolders(contentRoot, folders, expectedSources);
   }

   protected void assertResources(String moduleName, String... expectedSources) {
     doAssertContentFolders(moduleName, JavaResourceRootType.RESOURCE, expectedSources);
   }

   protected void assertTestSources(String moduleName, String... expectedSources) {
     doAssertContentFolders(moduleName, JavaSourceRootType.TEST_SOURCE, expectedSources);
   }

   protected void assertTestResources(String moduleName, String... expectedSources) {
     doAssertContentFolders(moduleName, JavaResourceRootType.TEST_RESOURCE, expectedSources);
   }

   protected void assertExcludes(String moduleName, String... expectedExcludes) {
     ContentEntry contentRoot = getContentRoot(moduleName);
     doAssertContentFolders(contentRoot, Arrays.asList(contentRoot.getExcludeFolders()), expectedExcludes);
   }

   protected void assertContentRootExcludes(String moduleName, String contentRoot, String... expectedExcudes) {
     ContentEntry root = getContentRoot(moduleName, contentRoot);
     doAssertContentFolders(root, Arrays.asList(root.getExcludeFolders()), expectedExcudes);
   }

   private void doAssertContentFolders(String moduleName, @NotNull JpsModuleSourceRootType<?> rootType, String... expected) {
     ContentEntry contentRoot = getContentRoot(moduleName);
     doAssertContentFolders(contentRoot, contentRoot.getSourceFolders(rootType), expected);
   }

   private static void doAssertContentFolders(ContentEntry e, final List<? extends ContentFolder> folders, String... expected) {
     List<String> actual = new ArrayList<String>();
     for (ContentFolder f : folders) {
       String rootUrl = e.getUrl();
       String folderUrl = f.getUrl();

       if (folderUrl.startsWith(rootUrl)) {
         int length = rootUrl.length() + 1;
         folderUrl = folderUrl.substring(Math.min(length, folderUrl.length()));
       }

       actual.add(folderUrl);
     }

     assertOrderedElementsAreEqual(actual, Arrays.asList(expected));
   }

   protected void assertModuleOutput(String moduleName, String output, String testOutput) {
     CompilerModuleExtension e = getCompilerExtension(moduleName);

     assertFalse(e.isCompilerOutputPathInherited());
     assertEquals(output, getAbsolutePath(e.getCompilerOutputUrl()));
     assertEquals(testOutput, getAbsolutePath(e.getCompilerOutputUrlForTests()));
   }

   private static String getAbsolutePath(String path) {
     path = VfsUtil.urlToPath(path);
     path = PathUtil.getCanonicalPath(path);
     return FileUtil.toSystemIndependentName(path);
   }

   protected void assertProjectOutput(String module) {
     assertTrue(getCompilerExtension(module).isCompilerOutputPathInherited());
   }

   protected CompilerModuleExtension getCompilerExtension(String module) {
     ModuleRootManager m = getRootManager(module);
     return CompilerModuleExtension.getInstance(m.getModule());
   }

   protected void assertModuleLibDep(String moduleName, String depName) {
     assertModuleLibDep(moduleName, depName, null);
   }

   protected void assertModuleLibDep(String moduleName, String depName, String classesPath) {
     assertModuleLibDep(moduleName, depName, classesPath, null, null);
   }

   protected void assertModuleLibDep(String moduleName, String depName, String classesPath, String sourcePath, String javadocPath) {
     LibraryOrderEntry lib = getModuleLibDep(moduleName, depName);

     assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPath == null ? null : Collections.singletonList(classesPath));
     assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePath == null ? null : Collections.singletonList(sourcePath));
     assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), javadocPath == null ? null : Collections.singletonList(javadocPath));
   }

   protected void assertModuleLibDep(String moduleName,
                                     String depName,
                                     List<String> classesPaths,
                                     List<String> sourcePaths,
                                     List<String> javadocPaths) {
     LibraryOrderEntry lib = getModuleLibDep(moduleName, depName);

     assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPaths);
     assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePaths);
     assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), javadocPaths);
   }

   private static void assertModuleLibDepPath(LibraryOrderEntry lib, OrderRootType type, List<String> paths) {
     if (paths == null) return;
     assertUnorderedPathsAreEqual(Arrays.asList(lib.getRootUrls(type)), paths);
     // also check the library because it may contain slight different set of urls (e.g. with duplicates)
     assertUnorderedPathsAreEqual(Arrays.asList(lib.getLibrary().getUrls(type)), paths);
   }

   protected void assertModuleLibDepScope(String moduleName, String depName, DependencyScope scope) {
     LibraryOrderEntry dep = getModuleLibDep(moduleName, depName);
     assertEquals(scope, dep.getScope());
   }

   private LibraryOrderEntry getModuleLibDep(String moduleName, String depName) {
     return getModuleDep(moduleName, depName, LibraryOrderEntry.class);
   }

   protected void assertModuleLibDeps(String moduleName, String... expectedDeps) {
     assertModuleDeps(moduleName, LibraryOrderEntry.class, expectedDeps);
   }

   protected void assertExportedDeps(String moduleName, String... expectedDeps) {
     final List<String> actual = new ArrayList<String>();

     getRootManager(moduleName).orderEntries().withoutSdk().withoutModuleSourceEntries().exportedOnly().process(new RootPolicy<Object>() {
       @Override
       public Object visitModuleOrderEntry(ModuleOrderEntry e, Object value) {
         actual.add(e.getModuleName());
         return null;
       }

       @Override
       public Object visitLibraryOrderEntry(LibraryOrderEntry e, Object value) {
         actual.add(e.getLibraryName());
         return null;
       }
     }, null);

     assertOrderedElementsAreEqual(actual, expectedDeps);
   }

   protected void assertModuleModuleDeps(String moduleName, String... expectedDeps) {
     assertModuleDeps(moduleName, ModuleOrderEntry.class, expectedDeps);
   }

   private void assertModuleDeps(String moduleName, Class clazz, String... expectedDeps) {
     assertOrderedElementsAreEqual(collectModuleDepsNames(moduleName, clazz), expectedDeps);
   }

   protected void assertModuleModuleDepScope(String moduleName, String depName, DependencyScope scope) {
     ModuleOrderEntry dep = getModuleModuleDep(moduleName, depName);
     assertEquals(scope, dep.getScope());
   }

   private ModuleOrderEntry getModuleModuleDep(String moduleName, String depName) {
     return getModuleDep(moduleName, depName, ModuleOrderEntry.class);
   }

   private List<String> collectModuleDepsNames(String moduleName, Class clazz) {
     List<String> actual = new ArrayList<String>();

     for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
       if (clazz.isInstance(e)) {
         actual.add(e.getPresentableName());
       }
     }
     return actual;
   }

   private <T> T getModuleDep(String moduleName, String depName, Class<T> clazz) {
     T dep = null;

     for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
       if (clazz.isInstance(e) && e.getPresentableName().equals(depName)) {
         dep = (T)e;
       }
     }
     assertNotNull("Dependency not found: " + depName
                   + "\namong: " + collectModuleDepsNames(moduleName, clazz),
                   dep);
     return dep;
   }

   public void assertProjectLibraries(String... expectedNames) {
     List<String> actualNames = new ArrayList<String>();
     for (Library each : ProjectLibraryTable.getInstance(myProject).getLibraries()) {
       String name = each.getName();
       actualNames.add(name == null ? "<unnamed>" : name);
     }
     assertUnorderedElementsAreEqual(actualNames, expectedNames);
   }

   protected void assertModuleGroupPath(String moduleName, String... expected) {
     String[] path = ModuleManager.getInstance(myProject).getModuleGroupPath(getModule(moduleName));

     if (expected.length == 0) {
       assertNull(path);
     }
     else {
       assertNotNull(path);
       assertOrderedElementsAreEqual(Arrays.asList(path), expected);
     }
   }

   protected Module getModule(final String name) {
     AccessToken accessToken = ApplicationManager.getApplication().acquireReadActionLock();
     try {
       Module m = ModuleManager.getInstance(myProject).findModuleByName(name);
       assertNotNull("Module " + name + " not found", m);
       return m;
     }
     finally {
       accessToken.finish();
     }
   }

   private ContentEntry getContentRoot(String moduleName) {
     ContentEntry[] ee = getContentRoots(moduleName);
     List<String> roots = new ArrayList<String>();
     for (ContentEntry e : ee) {
       roots.add(e.getUrl());
     }

     String message = "Several content roots found: [" + StringUtil.join(roots, ", ") + "]";
     assertEquals(message, 1, ee.length);

     return ee[0];
   }

   private ContentEntry getContentRoot(String moduleName, String path) {
     for (ContentEntry e : getContentRoots(moduleName)) {
       if (e.getUrl().equals(VfsUtil.pathToUrl(path))) return e;
     }
     throw new AssertionError("content root not found");
   }

   public ContentEntry[] getContentRoots(String moduleName) {
     return getRootManager(moduleName).getContentEntries();
   }

   private ModuleRootManager getRootManager(String module) {
     return ModuleRootManager.getInstance(getModule(module));
   }

   protected void importProject(@NonNls String xml) throws IOException {
     createProjectPom(xml);
     importProject();
   }

   protected void importProject() {
     importProjectWithProfiles();
   }

   protected void importProjectWithProfiles(String... profiles) {
     doImportProjects(Collections.singletonList(myProjectPom), profiles);
   }

   protected void importProject(VirtualFile file) {
     importProjects(file);
   }

   protected void importProjects(VirtualFile... files) {
     doImportProjects(Arrays.asList(files));
   }

   private void doImportProjects(final List<VirtualFile> files, String... profiles) {
     initProjectsManager(false);

     readProjects(files, profiles);

     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
       public void run() {
         myProjectsManager.waitForResolvingCompletion();
         myProjectsManager.scheduleImportInTests(files);
         myProjectsManager.importProjects();
       }
     });

     for (MavenProject each : myProjectsTree.getProjects()) {
       if (each.hasReadingProblems()) {
         System.out.println(each + " has problems: " + each.getProblems());
       }
     }
   }

   protected void readProjects(List<VirtualFile> files, String... profiles) {
     myProjectsManager.resetManagedFilesAndProfilesInTests(files, new MavenExplicitProfiles(Arrays.asList(profiles)));
     waitForReadingCompletion();
   }

   protected void updateProjectsAndImport(VirtualFile... files) {
     readProjects(files);
     myProjectsManager.performScheduledImportInTests();
   }

   protected void initProjectsManager(boolean enableEventHandling) {
     myProjectsManager.initForTests();
     myProjectsTree = myProjectsManager.getProjectsTreeForTests();
     if (enableEventHandling) myProjectsManager.listenForExternalChanges();
   }

   protected void scheduleResolveAll() {
     myProjectsManager.scheduleResolveAllInTests();
   }

   protected void waitForReadingCompletion() {
     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
       public void run() {
         try {
           myProjectsManager.waitForReadingCompletion();
         }
         catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     });
   }

   protected void readProjects() {
     readProjects(myProjectsManager.getProjectsFiles());
   }

   protected void readProjects(VirtualFile... files) {
     List<MavenProject> projects = new ArrayList<MavenProject>();
     for (VirtualFile each : files) {
       projects.add(myProjectsManager.findProject(each));
     }
     myProjectsManager.forceUpdateProjects(projects);
     waitForReadingCompletion();
   }

   protected void resolveDependenciesAndImport() {
     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
       public void run() {
         myProjectsManager.waitForResolvingCompletion();
         myProjectsManager.performScheduledImportInTests();
       }
     });
   }

   protected void resolveFoldersAndImport() {
     myProjectsManager.scheduleFoldersResolveForAllProjects();
     myProjectsManager.waitForFoldersResolvingCompletion();
     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
       public void run() {
         myProjectsManager.performScheduledImportInTests();
       }
     });
   }

   protected void resolvePlugins() {
     myProjectsManager.waitForPluginsResolvingCompletion();
   }

   protected void downloadArtifacts() {
     downloadArtifacts(myProjectsManager.getProjects(), null);
   }

   protected MavenArtifactDownloader.DownloadResult downloadArtifacts(Collection<MavenProject> projects,
                                                                      List<MavenArtifact> artifacts) {
     final MavenArtifactDownloader.DownloadResult[] unresolved = new MavenArtifactDownloader.DownloadResult[1];

     AsyncResult<MavenArtifactDownloader.DownloadResult> result = new AsyncResult<MavenArtifactDownloader.DownloadResult>();
     result.doWhenDone(new Consumer<MavenArtifactDownloader.DownloadResult>() {
       @Override
       public void consume(MavenArtifactDownloader.DownloadResult unresolvedArtifacts) {
         unresolved[0] = unresolvedArtifacts;
       }
     });

     myProjectsManager.scheduleArtifactsDownloading(projects, artifacts, true, true, result);
     myProjectsManager.waitForArtifactsDownloadingCompletion();

     return unresolved[0];
   }

   protected void performPostImportTasks() {
     myProjectsManager.waitForPostImportTasksCompletion();
   }

   protected void executeGoal(String relativePath, String goal) {
     VirtualFile dir = myProjectRoot.findFileByRelativePath(relativePath);

     MavenRunnerParameters rp = new MavenRunnerParameters(true, dir.getPath(), Arrays.asList(goal), Collections.<String>emptyList());
     MavenRunnerSettings rs = new MavenRunnerSettings();
     MavenExecutor e = new MavenExternalExecutor(myProject, rp, getMavenGeneralSettings(), rs, new SoutMavenConsole());

     e.execute(new EmptyProgressIndicator());
   }

   protected void removeFromLocalRepository(String relativePath) throws IOException {
     FileUtil.delete(new File(getRepositoryPath(), relativePath));
   }

   protected void setupJdkForModules(String... moduleNames) {
     for (String each : moduleNames) {
       setupJdkForModule(each);
     }
   }

   protected Sdk setupJdkForModule(final String moduleName) {
     final Sdk sdk = JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
     ModuleRootModificationUtil.setModuleSdk(getModule(moduleName), sdk);
     return sdk;
   }

   protected static Sdk createJdk(String versionName) {
     return IdeaTestUtil.getMockJdk17(versionName);
   }

   protected static AtomicInteger configConfirmationForYesAnswer() {
     final AtomicInteger counter = new AtomicInteger();
     Messages.setTestDialog(new TestDialog() {
       @Override
       public int show(String message) {
         counter.set(counter.get() + 1);
         return 0;
       }
     });
     return counter;
   }

   protected static AtomicInteger configConfirmationForNoAnswer() {
     final AtomicInteger counter = new AtomicInteger();
     Messages.setTestDialog(new TestDialog() {
       @Override
       public int show(String message) {
         counter.set(counter.get() + 1);
         return 1;
       }
     });
     return counter;
   }
 }
	/*
	* Copyright 2000-2012 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.jetbrains.idea.maven;

	import com.intellij.compiler.server.BuildManager;
	import com.intellij.openapi.application.AccessToken;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.module.Module;
	import com.intellij.openapi.module.ModuleManager;
	import com.intellij.openapi.progress.EmptyProgressIndicator;
	import com.intellij.openapi.projectRoots.Sdk;
	import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
	import com.intellij.openapi.roots.*;
	import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable;
	import com.intellij.openapi.roots.libraries.Library;
	import com.intellij.openapi.ui.Messages;
	import com.intellij.openapi.ui.TestDialog;
	import com.intellij.openapi.util.AsyncResult;
	import com.intellij.openapi.util.io.FileUtil;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.openapi.vfs.VfsUtil;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.testFramework.IdeaTestUtil;
	import com.intellij.util.Consumer;
	import com.intellij.util.PathUtil;
	import com.intellij.util.ui.UIUtil;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.idea.maven.execution.*;
	import org.jetbrains.idea.maven.model.MavenArtifact;
	import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
	import org.jetbrains.idea.maven.project.MavenArtifactDownloader;
	import org.jetbrains.idea.maven.project.MavenProject;
	import org.jetbrains.idea.maven.project.MavenProjectsManager;
	import org.jetbrains.idea.maven.project.MavenProjectsTree;
	import org.jetbrains.jps.model.java.JavaResourceRootType;
	import org.jetbrains.jps.model.java.JavaSourceRootProperties;
	import org.jetbrains.jps.model.java.JavaSourceRootType;
	import org.jetbrains.jps.model.module.JpsModuleSourceRootType;

	import java.io.File;
	import java.io.IOException;
	import java.util.*;
	import java.util.concurrent.atomic.AtomicInteger;

	public abstract class MavenImportingTestCase extends MavenTestCase {
	protected MavenProjectsTree myProjectsTree;
	protected MavenProjectsManager myProjectsManager;

	@Override
	protected void setUpInWriteAction() throws Exception {
	super.setUpInWriteAction();
	myProjectsManager = MavenProjectsManager.getInstance(myProject);
	removeFromLocalRepository("test");
	}

	@Override
	protected void tearDown() throws Exception {
	try {
	Messages.setTestDialog(TestDialog.DEFAULT);
	myProjectsManager.projectClosed();
	removeFromLocalRepository("test");
	FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory());
	}
	finally {
	super.tearDown();
	}
	}

	protected void assertModules(String... expectedNames) {
	Module[] actual = ModuleManager.getInstance(myProject).getModules();
	List<String> actualNames = new ArrayList<String>();

	for (Module m : actual) {
	actualNames.add(m.getName());
	}

	assertUnorderedElementsAreEqual(actualNames, expectedNames);
	}

	protected void assertContentRoots(String moduleName, String... expectedRoots) {
	List<String> actual = new ArrayList<String>();
	for (ContentEntry e : getContentRoots(moduleName)) {
	actual.add(e.getUrl());
	}

	for (int i = 0; i < expectedRoots.length; i++) {
	expectedRoots[i] = VfsUtil.pathToUrl(expectedRoots[i]);
	}

	assertUnorderedPathsAreEqual(actual, Arrays.asList(expectedRoots));
	}

	protected void assertSources(String moduleName, String... expectedSources) {
	doAssertContentFolders(moduleName, JavaSourceRootType.SOURCE, expectedSources);
	}

	protected void assertGeneratedSources(String moduleName, String... expectedSources) {
	ContentEntry contentRoot = getContentRoot(moduleName);
	List<ContentFolder> folders = new ArrayList<ContentFolder>();
	for (SourceFolder folder : contentRoot.getSourceFolders(JavaSourceRootType.SOURCE)) {
	JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaSourceRootType.SOURCE);
	assertNotNull(properties);
	if (properties.isForGeneratedSources()) {
	folders.add(folder);
	}
	}
	doAssertContentFolders(contentRoot, folders, expectedSources);
	}

	protected void assertResources(String moduleName, String... expectedSources) {
	doAssertContentFolders(moduleName, JavaResourceRootType.RESOURCE, expectedSources);
	}

	protected void assertTestSources(String moduleName, String... expectedSources) {
	doAssertContentFolders(moduleName, JavaSourceRootType.TEST_SOURCE, expectedSources);
	}

	protected void assertTestResources(String moduleName, String... expectedSources) {
	doAssertContentFolders(moduleName, JavaResourceRootType.TEST_RESOURCE, expectedSources);
	}

	protected void assertExcludes(String moduleName, String... expectedExcludes) {
	ContentEntry contentRoot = getContentRoot(moduleName);
	doAssertContentFolders(contentRoot, Arrays.asList(contentRoot.getExcludeFolders()), expectedExcludes);
	}

	protected void assertContentRootExcludes(String moduleName, String contentRoot, String... expectedExcudes) {
	ContentEntry root = getContentRoot(moduleName, contentRoot);
	doAssertContentFolders(root, Arrays.asList(root.getExcludeFolders()), expectedExcudes);
	}

	private void doAssertContentFolders(String moduleName, @NotNull JpsModuleSourceRootType<?> rootType, String... expected) {
	ContentEntry contentRoot = getContentRoot(moduleName);
	doAssertContentFolders(contentRoot, contentRoot.getSourceFolders(rootType), expected);
	}

	private static void doAssertContentFolders(ContentEntry e, final List<? extends ContentFolder> folders, String... expected) {
	List<String> actual = new ArrayList<String>();
	for (ContentFolder f : folders) {
	String rootUrl = e.getUrl();
	String folderUrl = f.getUrl();

	if (folderUrl.startsWith(rootUrl)) {
	int length = rootUrl.length() + 1;
	folderUrl = folderUrl.substring(Math.min(length, folderUrl.length()));
	}

	actual.add(folderUrl);
	}

	assertOrderedElementsAreEqual(actual, Arrays.asList(expected));
	}

	protected void assertModuleOutput(String moduleName, String output, String testOutput) {
	CompilerModuleExtension e = getCompilerExtension(moduleName);

	assertFalse(e.isCompilerOutputPathInherited());
	assertEquals(output, getAbsolutePath(e.getCompilerOutputUrl()));
	assertEquals(testOutput, getAbsolutePath(e.getCompilerOutputUrlForTests()));
	}

	private static String getAbsolutePath(String path) {
	path = VfsUtil.urlToPath(path);
	path = PathUtil.getCanonicalPath(path);
	return FileUtil.toSystemIndependentName(path);
	}

	protected void assertProjectOutput(String module) {
	assertTrue(getCompilerExtension(module).isCompilerOutputPathInherited());
	}

	protected CompilerModuleExtension getCompilerExtension(String module) {
	ModuleRootManager m = getRootManager(module);
	return CompilerModuleExtension.getInstance(m.getModule());
	}

	protected void assertModuleLibDep(String moduleName, String depName) {
	assertModuleLibDep(moduleName, depName, null);
	}

	protected void assertModuleLibDep(String moduleName, String depName, String classesPath) {
	assertModuleLibDep(moduleName, depName, classesPath, null, null);
	}

	protected void assertModuleLibDep(String moduleName, String depName, String classesPath, String sourcePath, String javadocPath) {
	LibraryOrderEntry lib = getModuleLibDep(moduleName, depName);

	assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPath == null ? null : Collections.singletonList(classesPath));
	assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePath == null ? null : Collections.singletonList(sourcePath));
	assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), javadocPath == null ? null : Collections.singletonList(javadocPath));
	}

	protected void assertModuleLibDep(String moduleName,
	String depName,
	List<String> classesPaths,
	List<String> sourcePaths,
	List<String> javadocPaths) {
	LibraryOrderEntry lib = getModuleLibDep(moduleName, depName);

	assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPaths);
	assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePaths);
	assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), javadocPaths);
	}

	private static void assertModuleLibDepPath(LibraryOrderEntry lib, OrderRootType type, List<String> paths) {
	if (paths == null) return;
	assertUnorderedPathsAreEqual(Arrays.asList(lib.getRootUrls(type)), paths);
	// also check the library because it may contain slight different set of urls (e.g. with duplicates)
	assertUnorderedPathsAreEqual(Arrays.asList(lib.getLibrary().getUrls(type)), paths);
	}

	protected void assertModuleLibDepScope(String moduleName, String depName, DependencyScope scope) {
	LibraryOrderEntry dep = getModuleLibDep(moduleName, depName);
	assertEquals(scope, dep.getScope());
	}

	private LibraryOrderEntry getModuleLibDep(String moduleName, String depName) {
	return getModuleDep(moduleName, depName, LibraryOrderEntry.class);
	}

	protected void assertModuleLibDeps(String moduleName, String... expectedDeps) {
	assertModuleDeps(moduleName, LibraryOrderEntry.class, expectedDeps);
	}

	protected void assertExportedDeps(String moduleName, String... expectedDeps) {
	final List<String> actual = new ArrayList<String>();

	getRootManager(moduleName).orderEntries().withoutSdk().withoutModuleSourceEntries().exportedOnly().process(new RootPolicy<Object>() {
	@Override
	public Object visitModuleOrderEntry(ModuleOrderEntry e, Object value) {
	actual.add(e.getModuleName());
	return null;
	}

	@Override
	public Object visitLibraryOrderEntry(LibraryOrderEntry e, Object value) {
	actual.add(e.getLibraryName());
	return null;
	}
	}, null);

	assertOrderedElementsAreEqual(actual, expectedDeps);
	}

	protected void assertModuleModuleDeps(String moduleName, String... expectedDeps) {
	assertModuleDeps(moduleName, ModuleOrderEntry.class, expectedDeps);
	}

	private void assertModuleDeps(String moduleName, Class clazz, String... expectedDeps) {
	assertOrderedElementsAreEqual(collectModuleDepsNames(moduleName, clazz), expectedDeps);
	}

	protected void assertModuleModuleDepScope(String moduleName, String depName, DependencyScope scope) {
	ModuleOrderEntry dep = getModuleModuleDep(moduleName, depName);
	assertEquals(scope, dep.getScope());
	}

	private ModuleOrderEntry getModuleModuleDep(String moduleName, String depName) {
	return getModuleDep(moduleName, depName, ModuleOrderEntry.class);
	}

	private List<String> collectModuleDepsNames(String moduleName, Class clazz) {
	List<String> actual = new ArrayList<String>();

	for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
	if (clazz.isInstance(e)) {
	actual.add(e.getPresentableName());
	}
	}
	return actual;
	}

	private <T> T getModuleDep(String moduleName, String depName, Class<T> clazz) {
	T dep = null;

	for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
	if (clazz.isInstance(e) && e.getPresentableName().equals(depName)) {
	dep = (T)e;
	}
	}
	assertNotNull("Dependency not found: " + depName
	+ "\namong: " + collectModuleDepsNames(moduleName, clazz),
	dep);
	return dep;
	}

	public void assertProjectLibraries(String... expectedNames) {
	List<String> actualNames = new ArrayList<String>();
	for (Library each : ProjectLibraryTable.getInstance(myProject).getLibraries()) {
	String name = each.getName();
	actualNames.add(name == null ? "<unnamed>" : name);
	}
	assertUnorderedElementsAreEqual(actualNames, expectedNames);
	}

	protected void assertModuleGroupPath(String moduleName, String... expected) {
	String[] path = ModuleManager.getInstance(myProject).getModuleGroupPath(getModule(moduleName));

	if (expected.length == 0) {
	assertNull(path);
	}
	else {
	assertNotNull(path);
	assertOrderedElementsAreEqual(Arrays.asList(path), expected);
	}
	}

	protected Module getModule(final String name) {
	AccessToken accessToken = ApplicationManager.getApplication().acquireReadActionLock();
	try {
	Module m = ModuleManager.getInstance(myProject).findModuleByName(name);
	assertNotNull("Module " + name + " not found", m);
	return m;
	}
	finally {
	accessToken.finish();
	}
	}

	private ContentEntry getContentRoot(String moduleName) {
	ContentEntry[] ee = getContentRoots(moduleName);
	List<String> roots = new ArrayList<String>();
	for (ContentEntry e : ee) {
	roots.add(e.getUrl());
	}

	String message = "Several content roots found: [" + StringUtil.join(roots, ", ") + "]";
	assertEquals(message, 1, ee.length);

	return ee[0];
	}

	private ContentEntry getContentRoot(String moduleName, String path) {
	for (ContentEntry e : getContentRoots(moduleName)) {
	if (e.getUrl().equals(VfsUtil.pathToUrl(path))) return e;
	}
	throw new AssertionError("content root not found");
	}

	public ContentEntry[] getContentRoots(String moduleName) {
	return getRootManager(moduleName).getContentEntries();
	}

	private ModuleRootManager getRootManager(String module) {
	return ModuleRootManager.getInstance(getModule(module));
	}

	protected void importProject(@NonNls String xml) throws IOException {
	createProjectPom(xml);
	importProject();
	}

	protected void importProject() {
	importProjectWithProfiles();
	}

	protected void importProjectWithProfiles(String... profiles) {
	doImportProjects(Collections.singletonList(myProjectPom), profiles);
	}

	protected void importProject(VirtualFile file) {
	importProjects(file);
	}

	protected void importProjects(VirtualFile... files) {
	doImportProjects(Arrays.asList(files));
	}

	private void doImportProjects(final List<VirtualFile> files, String... profiles) {
	initProjectsManager(false);

	readProjects(files, profiles);

	UIUtil.invokeAndWaitIfNeeded(new Runnable() {
	@Override
	public void run() {
	myProjectsManager.waitForResolvingCompletion();
	myProjectsManager.scheduleImportInTests(files);
	myProjectsManager.importProjects();
	}
	});

	for (MavenProject each : myProjectsTree.getProjects()) {
	if (each.hasReadingProblems()) {
	System.out.println(each + " has problems: " + each.getProblems());
	}
	}
	}

	protected void readProjects(List<VirtualFile> files, String... profiles) {
	myProjectsManager.resetManagedFilesAndProfilesInTests(files, new MavenExplicitProfiles(Arrays.asList(profiles)));
	waitForReadingCompletion();
	}

	protected void updateProjectsAndImport(VirtualFile... files) {
	readProjects(files);
	myProjectsManager.performScheduledImportInTests();
	}

	protected void initProjectsManager(boolean enableEventHandling) {
	myProjectsManager.initForTests();
	myProjectsTree = myProjectsManager.getProjectsTreeForTests();
	if (enableEventHandling) myProjectsManager.listenForExternalChanges();
	}

	protected void scheduleResolveAll() {
	myProjectsManager.scheduleResolveAllInTests();
	}

	protected void waitForReadingCompletion() {
	UIUtil.invokeAndWaitIfNeeded(new Runnable() {
	@Override
	public void run() {
	try {
	myProjectsManager.waitForReadingCompletion();
	}
	catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	});
	}

	protected void readProjects() {
	readProjects(myProjectsManager.getProjectsFiles());
	}

	protected void readProjects(VirtualFile... files) {
	List<MavenProject> projects = new ArrayList<MavenProject>();
	for (VirtualFile each : files) {
	projects.add(myProjectsManager.findProject(each));
	}
	myProjectsManager.forceUpdateProjects(projects);
	waitForReadingCompletion();
	}

	protected void resolveDependenciesAndImport() {
	UIUtil.invokeAndWaitIfNeeded(new Runnable() {
	@Override
	public void run() {
	myProjectsManager.waitForResolvingCompletion();
	myProjectsManager.performScheduledImportInTests();
	}
	});
	}

	protected void resolveFoldersAndImport() {
	myProjectsManager.scheduleFoldersResolveForAllProjects();
	myProjectsManager.waitForFoldersResolvingCompletion();
	UIUtil.invokeAndWaitIfNeeded(new Runnable() {
	@Override
	public void run() {
	myProjectsManager.performScheduledImportInTests();
	}
	});
	}

	protected void resolvePlugins() {
	myProjectsManager.waitForPluginsResolvingCompletion();
	}

	protected void downloadArtifacts() {
	downloadArtifacts(myProjectsManager.getProjects(), null);
	}

	protected MavenArtifactDownloader.DownloadResult downloadArtifacts(Collection<MavenProject> projects,
	List<MavenArtifact> artifacts) {
	final MavenArtifactDownloader.DownloadResult[] unresolved = new MavenArtifactDownloader.DownloadResult[1];

	AsyncResult<MavenArtifactDownloader.DownloadResult> result = new AsyncResult<MavenArtifactDownloader.DownloadResult>();
	result.doWhenDone(new Consumer<MavenArtifactDownloader.DownloadResult>() {
	@Override
	public void consume(MavenArtifactDownloader.DownloadResult unresolvedArtifacts) {
	unresolved[0] = unresolvedArtifacts;
	}
	});

	myProjectsManager.scheduleArtifactsDownloading(projects, artifacts, true, true, result);
	myProjectsManager.waitForArtifactsDownloadingCompletion();

	return unresolved[0];
	}

	protected void performPostImportTasks() {
	myProjectsManager.waitForPostImportTasksCompletion();
	}

	protected void executeGoal(String relativePath, String goal) {
	VirtualFile dir = myProjectRoot.findFileByRelativePath(relativePath);

	MavenRunnerParameters rp = new MavenRunnerParameters(true, dir.getPath(), Arrays.asList(goal), Collections.<String>emptyList());
	MavenRunnerSettings rs = new MavenRunnerSettings();
	MavenExecutor e = new MavenExternalExecutor(myProject, rp, getMavenGeneralSettings(), rs, new SoutMavenConsole());

	e.execute(new EmptyProgressIndicator());
	}

	protected void removeFromLocalRepository(String relativePath) throws IOException {
	FileUtil.delete(new File(getRepositoryPath(), relativePath));
	}

	protected void setupJdkForModules(String... moduleNames) {
	for (String each : moduleNames) {
	setupJdkForModule(each);
	}
	}

	protected Sdk setupJdkForModule(final String moduleName) {
	final Sdk sdk = JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
	ModuleRootModificationUtil.setModuleSdk(getModule(moduleName), sdk);
	return sdk;
	}

	protected static Sdk createJdk(String versionName) {
	return IdeaTestUtil.getMockJdk17(versionName);
	}

	protected static AtomicInteger configConfirmationForYesAnswer() {
	final AtomicInteger counter = new AtomicInteger();
	Messages.setTestDialog(new TestDialog() {
	@Override
	public int show(String message) {
	counter.set(counter.get() + 1);
	return 0;
	}
	});
	return counter;
	}

	protected static AtomicInteger configConfirmationForNoAnswer() {
	final AtomicInteger counter = new AtomicInteger();
	Messages.setTestDialog(new TestDialog() {
	@Override
	public int show(String message) {
	counter.set(counter.get() + 1);
	return 1;
	}
	});
	return counter;
	}
	}