From fbcba4390533e5babd7fea0d89e46cb240fb5a57 Mon Sep 17 00:00:00 2001 From: Nikolay Chashnikov Date: Thu, 27 Jun 2024 17:22:53 +0200 Subject: [PATCH] [jps tests] refactoring: rework jps serialization tests to use JpsSerializationManager API JpsModelFromTestData utility is added which uses JpsSerializationManager instead of creating JpsModel and calling JpsProjectLoader directly. Tests are migrated to use it instead of extending JpsSerializationTestCase. This is needed to use these tests to verify the new implementation of JPS model serialization (IJPL-409). Also, the tests are migrated to JUnit 5. GitOrigin-RevId: 874f0b01ea6ae5d31666b2dafb843052cc017024 --- .../CompilerEncodingConfigurationTest.java | 66 +++--- ...platform.jps.model.serialization.tests.iml | 1 + .../JpsEncodingConfigurationServiceTest.java | 26 ++- .../JpsArtifactSerializationTest.java | 9 +- .../JpsGlobalSerializationTest.java | 26 ++- .../serialization/JpsModelFromTestData.kt | 54 +++++ .../JpsProjectSerializationTest.java | 190 ++++++++++-------- ...JpsRepositoryLibrarySerializationTest.java | 14 +- ...JpsRunConfigurationsSerializationTest.java | 16 +- .../jps/ant/JpsAntSerializationTest.kt | 72 +++---- .../JpsPluginProjectSerializationTest.java | 26 ++- .../JpsMavenModuleSerializationTest.java | 12 +- ...esignerConfigurationSerializationTest.java | 14 +- 13 files changed, 331 insertions(+), 195 deletions(-) create mode 100644 jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModelFromTestData.kt diff --git a/jps/jps-builders/testSrc/org/jetbrains/jps/model/CompilerEncodingConfigurationTest.java b/jps/jps-builders/testSrc/org/jetbrains/jps/model/CompilerEncodingConfigurationTest.java index eec9ab2f9f8a..99309d8e93e9 100644 --- a/jps/jps-builders/testSrc/org/jetbrains/jps/model/CompilerEncodingConfigurationTest.java +++ b/jps/jps-builders/testSrc/org/jetbrains/jps/model/CompilerEncodingConfigurationTest.java @@ -2,7 +2,6 @@ package org.jetbrains.jps.model; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.jps.builders.impl.BuildDataPathsImpl; import org.jetbrains.jps.builders.impl.BuildRootIndexImpl; import org.jetbrains.jps.builders.impl.BuildTargetRegistryImpl; @@ -12,54 +11,51 @@ import org.jetbrains.jps.indices.ModuleExcludeIndex; import org.jetbrains.jps.indices.impl.IgnoredFileIndexImpl; import org.jetbrains.jps.indices.impl.ModuleExcludeIndexImpl; import org.jetbrains.jps.model.module.JpsModule; +import org.jetbrains.jps.model.serialization.JpsProjectData; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.io.File; +import static org.junit.jupiter.api.Assertions.*; + /** * @author Eugene Zhuravlev */ -public class CompilerEncodingConfigurationTest extends JpsEncodingConfigurationServiceTest { +public class CompilerEncodingConfigurationTest { private File myDataStorageRoot; - private BuildRootIndexImpl myRootIndex; - @Override + @BeforeEach public void setUp() throws Exception { - super.setUp(); - - BuildTargetRegistryImpl targetRegistry = new BuildTargetRegistryImpl(myModel); - ModuleExcludeIndex index = new ModuleExcludeIndexImpl(myModel); - IgnoredFileIndexImpl ignoredFileIndex = new IgnoredFileIndexImpl(myModel); - myDataStorageRoot = FileUtil.createTempDirectory("compile-server-" + StringUtil.decapitalize(StringUtil.trimStart(getName(), "test")), null); - BuildDataPaths dataPaths = new BuildDataPathsImpl(myDataStorageRoot); - myRootIndex = new BuildRootIndexImpl(targetRegistry, myModel, index, dataPaths, ignoredFileIndex); + myDataStorageRoot = FileUtil.createTempDirectory("compile-server-compiler-encoding", null); } - @Override + @AfterEach protected void tearDown() throws Exception { - try { - FileUtil.delete(myDataStorageRoot); - } - catch (Throwable e) { - addSuppressedException(e); - } - finally { - super.tearDown(); - } + FileUtil.delete(myDataStorageRoot); } - @Override + @Test public void test() { - loadProject("/jps/jps-builders/testData/compilerEncoding/compilerEncoding.ipr"); - JpsEncodingProjectConfiguration projectConfig = JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(myProject); + JpsProjectData projectData = JpsProjectData.loadFromTestData("jps/jps-builders/testData/compilerEncoding/compilerEncoding.ipr", getClass()); + JpsModel model = projectData.getProject().getModel(); + BuildTargetRegistryImpl targetRegistry = new BuildTargetRegistryImpl(model); + ModuleExcludeIndex index = new ModuleExcludeIndexImpl(model); + IgnoredFileIndexImpl ignoredFileIndex = new IgnoredFileIndexImpl(model); + BuildDataPaths dataPaths = new BuildDataPathsImpl(myDataStorageRoot); + BuildRootIndexImpl rootIndex = new BuildRootIndexImpl(targetRegistry, model, index, dataPaths, ignoredFileIndex); + + JpsEncodingProjectConfiguration projectConfig = JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(projectData.getProject()); assertNotNull(projectConfig); - assertEncoding("UTF-8", "moduleA/src/dir/with-encoding.xml", projectConfig); // overridden by file's internal encoding - assertEncoding("windows-1251", "moduleA/src/dir/with-encoding.txt", projectConfig); - assertEncoding("UTF-8", "moduleA/src/dir/without-encoding.xml", projectConfig); - assertEncoding("UTF-8", "moduleA/src/dir/without-encoding.txt", projectConfig); - assertEncoding("UTF-8", "moduleA/src/dir/non-existent.xml", projectConfig); - assertEncoding("windows-1252", "moduleB/src/non-existent.xml", projectConfig); - final CompilerEncodingConfiguration compilerEncodingConfiguration = new CompilerEncodingConfiguration(myModel, myRootIndex); - for (JpsModule module : myProject.getModules()) { + assertEncoding("UTF-8", "moduleA/src/dir/with-encoding.xml", projectConfig, projectData); // overridden by file's internal encoding + assertEncoding("windows-1251", "moduleA/src/dir/with-encoding.txt", projectConfig, projectData); + assertEncoding("UTF-8", "moduleA/src/dir/without-encoding.xml", projectConfig, projectData); + assertEncoding("UTF-8", "moduleA/src/dir/without-encoding.txt", projectConfig, projectData); + assertEncoding("UTF-8", "moduleA/src/dir/non-existent.xml", projectConfig, projectData); + assertEncoding("windows-1252", "moduleB/src/non-existent.xml", projectConfig, projectData); + final CompilerEncodingConfiguration compilerEncodingConfiguration = new CompilerEncodingConfiguration(model, rootIndex); + for (JpsModule module : projectData.getProject().getModules()) { final String moduleEncoding = compilerEncodingConfiguration.getPreferredModuleEncoding(module); if ("moduleA".equals(module.getName())) { assertEquals("UTF-8", moduleEncoding); @@ -76,4 +72,8 @@ public class CompilerEncodingConfigurationTest extends JpsEncodingConfigurationS } } + protected void assertEncoding(final String encoding, final String path, JpsEncodingProjectConfiguration configuration, + JpsProjectData projectData) { + assertEquals(encoding, configuration.getEncoding(projectData.resolvePath(path).toFile())); + } } diff --git a/jps/model-serialization/intellij.platform.jps.model.serialization.tests.iml b/jps/model-serialization/intellij.platform.jps.model.serialization.tests.iml index 4c3fc1f3c1f0..61e0b62a67c1 100644 --- a/jps/model-serialization/intellij.platform.jps.model.serialization.tests.iml +++ b/jps/model-serialization/intellij.platform.jps.model.serialization.tests.iml @@ -7,6 +7,7 @@ + diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/JpsEncodingConfigurationServiceTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/JpsEncodingConfigurationServiceTest.java index 933859b45bb4..7e9e9f5e1fd6 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/JpsEncodingConfigurationServiceTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/JpsEncodingConfigurationServiceTest.java @@ -15,22 +15,26 @@ */ package org.jetbrains.jps.model; -import org.jetbrains.jps.model.serialization.JpsSerializationTestCase; +import org.jetbrains.jps.model.serialization.JpsProjectData; +import org.junit.jupiter.api.Test; -import java.io.File; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; -public class JpsEncodingConfigurationServiceTest extends JpsSerializationTestCase { +public class JpsEncodingConfigurationServiceTest { + @Test public void test() { - loadProject("/jps/model-serialization/testData/fileEncoding/fileEncoding.ipr"); - JpsEncodingProjectConfiguration configuration = JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(myProject); + JpsProjectData projectData = JpsProjectData.loadFromTestData("jps/model-serialization/testData/fileEncoding/fileEncoding.ipr", getClass()); + JpsEncodingProjectConfiguration configuration = JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(projectData.getProject()); assertNotNull(configuration); - assertEncoding("windows-1251", "dir/a.txt", configuration); - assertEncoding("UTF-8", "dir/with-encoding.xml", configuration); - assertEncoding("windows-1251", "dir/without-encoding.xml", configuration); - assertEncoding("windows-1251", "dir/non-existent.xml", configuration); + assertEncoding("windows-1251", "dir/a.txt", configuration, projectData); + assertEncoding("UTF-8", "dir/with-encoding.xml", configuration, projectData); + assertEncoding("windows-1251", "dir/without-encoding.xml", configuration, projectData); + assertEncoding("windows-1251", "dir/non-existent.xml", configuration, projectData); } - protected void assertEncoding(final String encoding, final String path, JpsEncodingProjectConfiguration configuration) { - assertEquals(encoding, configuration.getEncoding(new File(getAbsolutePath(path)))); + protected void assertEncoding(final String encoding, final String path, JpsEncodingProjectConfiguration configuration, + JpsProjectData projectData) { + assertEquals(encoding, configuration.getEncoding(projectData.resolvePath(path).toFile())); } } diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsArtifactSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsArtifactSerializationTest.java index 32ff2cf060cc..ba38dc0e763e 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsArtifactSerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsArtifactSerializationTest.java @@ -3,15 +3,18 @@ package org.jetbrains.jps.model.serialization; import org.jetbrains.jps.model.artifact.JpsArtifact; import org.jetbrains.jps.model.artifact.JpsArtifactService; +import org.junit.jupiter.api.Test; import java.util.List; import static org.jetbrains.jps.model.serialization.JpsProjectSerializationTest.SAMPLE_PROJECT_PATH; +import static org.junit.jupiter.api.Assertions.assertEquals; -public class JpsArtifactSerializationTest extends JpsSerializationTestCase { +public class JpsArtifactSerializationTest { + @Test public void testLoadProject() { - loadProject(SAMPLE_PROJECT_PATH); - List artifacts = getService().getSortedArtifacts(myProject); + JpsProjectData projectData = JpsProjectData.loadFromTestData(SAMPLE_PROJECT_PATH, getClass()); + List artifacts = getService().getSortedArtifacts(projectData.getProject()); assertEquals(2, artifacts.size()); assertEquals("dir", artifacts.get(0).getName()); assertEquals("jar", artifacts.get(1).getName()); diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsGlobalSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsGlobalSerializationTest.java index 6994134556d8..1d6943b858fd 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsGlobalSerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsGlobalSerializationTest.java @@ -3,18 +3,23 @@ package org.jetbrains.jps.model.serialization; import com.intellij.application.options.PathMacrosImpl; import org.jetbrains.jps.model.JpsEncodingConfigurationService; +import org.jetbrains.jps.model.JpsModel; import org.jetbrains.jps.model.library.JpsLibrary; +import org.junit.jupiter.api.Test; import java.util.List; import static com.intellij.testFramework.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; -public class JpsGlobalSerializationTest extends JpsSerializationTestCase { +public class JpsGlobalSerializationTest { private static final String OPTIONS_DIR = "jps/model-serialization/testData/config/options"; + @Test public void testLoadSdksAndGlobalLibraries() { - loadGlobalSettings(OPTIONS_DIR); - final List libraries = myModel.getGlobal().getLibraryCollection().getLibraries(); + JpsModel model = JpsModelFromTestData.loadGlobalSettings(OPTIONS_DIR, getClass()); + final List libraries = model.getGlobal().getLibraryCollection().getLibraries(); assertEquals(3, libraries.size()); assertEquals("Gant", libraries.get(0).getName()); final JpsLibrary sdk1 = libraries.get(1); @@ -23,21 +28,24 @@ public class JpsGlobalSerializationTest extends JpsSerializationTestCase { assertEquals("1.6", sdk2.getName()); } + @Test public void testLoadPathVariables() { - loadGlobalSettings(OPTIONS_DIR); - JpsPathVariablesConfiguration configuration = JpsModelSerializationDataService.getPathVariablesConfiguration(myModel.getGlobal()); + JpsModel model = JpsModelFromTestData.loadGlobalSettings(OPTIONS_DIR, getClass()); + JpsPathVariablesConfiguration configuration = JpsModelSerializationDataService.getPathVariablesConfiguration(model.getGlobal()); assertNotNull(configuration); assertEquals("/home/nik/.m2/repository", configuration.getUserVariableValue(PathMacrosImpl.MAVEN_REPOSITORY)); assertThat(configuration.getAllUserVariables()).hasSize(1); } + @Test public void testLoadEncoding() { - loadGlobalSettings(OPTIONS_DIR); - assertEquals("windows-1251", JpsEncodingConfigurationService.getInstance().getGlobalEncoding(myModel.getGlobal())); + JpsModel model = JpsModelFromTestData.loadGlobalSettings(OPTIONS_DIR, getClass()); + assertEquals("windows-1251", JpsEncodingConfigurationService.getInstance().getGlobalEncoding(model.getGlobal())); } + @Test public void testLoadIgnoredFiles() { - loadGlobalSettings(OPTIONS_DIR); - assertEquals("CVS;.svn;", myModel.getGlobal().getFileTypesConfiguration().getIgnoredPatternString()); + JpsModel model = JpsModelFromTestData.loadGlobalSettings(OPTIONS_DIR, getClass()); + assertEquals("CVS;.svn;", model.getGlobal().getFileTypesConfiguration().getIgnoredPatternString()); } } diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModelFromTestData.kt b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModelFromTestData.kt new file mode 100644 index 000000000000..7a04404ab6fc --- /dev/null +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModelFromTestData.kt @@ -0,0 +1,54 @@ +// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +@file:JvmName("JpsModelFromTestData") +package org.jetbrains.jps.model.serialization + +import com.intellij.openapi.application.ex.PathManagerEx +import org.jetbrains.jps.model.JpsElementFactory +import org.jetbrains.jps.model.JpsModel +import org.jetbrains.jps.model.JpsProject +import org.jetbrains.jps.util.JpsPathUtil +import java.nio.file.Path +import kotlin.io.path.* + +class JpsProjectData private constructor(relativeProjectPath: String, testClass: Class<*>, pathVariables: Map) { + val baseProjectDir: Path + val project: JpsProject + + init { + val homeDir = Path(PathManagerEx.getHomePath(testClass)) + val projectPath = homeDir.resolve(relativeProjectPath) + require(projectPath.exists()) { "$projectPath doesn't exist" } + baseProjectDir = if (projectPath.extension == "ipr") projectPath.parent else projectPath + project = JpsSerializationManager.getInstance().loadProject(projectPath.absolutePathString(), pathVariables) + } + + fun getUrl(relativePath: String): String = JpsPathUtil.pathToUrl(baseProjectDir.resolve(relativePath).invariantSeparatorsPathString) + + fun resolvePath(relativePath: String): Path = baseProjectDir.resolve(relativePath) + + companion object { + @JvmStatic + @JvmOverloads + fun loadFromTestData( + relativeProjectPath: String, testClass: Class<*>, + pathVariables: Map = emptyMap(), + ): JpsProjectData { + return JpsProjectData(relativeProjectPath, testClass, pathVariables) + } + } +} + +@JvmOverloads +fun loadGlobalSettings(relativeOptionsPath: String, testClass: Class<*>, additionalPathVariables: Map = emptyMap()): JpsModel { + val homeDir = Path(PathManagerEx.getHomePath(testClass)) + val optionsPath = homeDir.resolve(relativeOptionsPath) + require(optionsPath.exists()) { "$relativeOptionsPath doesn't exist" } + val model = JpsElementFactory.getInstance().createModel() + val configuration = JpsModelSerializationDataService.getOrCreatePathVariablesConfiguration(model.global) + for ((key, value) in additionalPathVariables.entries) { + configuration.addPathVariable(key, value) + } + JpsGlobalSettingsLoading.loadGlobalSettings(model.global, optionsPath.absolutePathString()) + return model +} + diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsProjectSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsProjectSerializationTest.java index 6a0e4fe77fcd..1c59b3b8ae8e 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsProjectSerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsProjectSerializationTest.java @@ -3,10 +3,9 @@ package org.jetbrains.jps.model.serialization; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.util.io.FileUtil; -import org.jetbrains.jps.model.JpsDummyElement; -import org.jetbrains.jps.model.JpsEncodingConfigurationService; -import org.jetbrains.jps.model.JpsEncodingProjectConfiguration; -import org.jetbrains.jps.model.JpsExcludePattern; +import com.intellij.testFramework.UsefulTestCase; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.*; import org.jetbrains.jps.model.artifact.JpsArtifactService; import org.jetbrains.jps.model.java.*; import org.jetbrains.jps.model.library.JpsLibrary; @@ -14,31 +13,41 @@ import org.jetbrains.jps.model.library.JpsOrderRootType; import org.jetbrains.jps.model.library.sdk.JpsSdkReference; import org.jetbrains.jps.model.module.*; import org.jetbrains.jps.util.JpsPathUtil; +import org.junit.jupiter.api.Test; import java.io.File; -import java.nio.file.Path; +import java.io.IOException; +import java.util.Collections; import java.util.List; import java.util.concurrent.TimeUnit; -public class JpsProjectSerializationTest extends JpsSerializationTestCase { - public static final String SAMPLE_PROJECT_PATH = "/jps/model-serialization/testData/sampleProject"; - public static final String SAMPLE_PROJECT_IPR_PATH = "/jps/model-serialization/testData/sampleProject-ipr/sampleProject.ipr"; +import static com.intellij.testFramework.UsefulTestCase.assertInstanceOf; +import static com.intellij.testFramework.UsefulTestCase.assertOneElement; +import static org.junit.jupiter.api.Assertions.*; +public class JpsProjectSerializationTest { + public static final String SAMPLE_PROJECT_PATH = "jps/model-serialization/testData/sampleProject"; + public static final String SAMPLE_PROJECT_IPR_PATH = "jps/model-serialization/testData/sampleProject-ipr/sampleProject.ipr"; + + @Test public void testLoadProject() { - loadProject(SAMPLE_PROJECT_PATH); - assertEquals("sampleProject", myProject.getName()); - checkSampleProjectConfiguration(getTestDataAbsoluteFile(SAMPLE_PROJECT_PATH).toFile()); + JpsProjectData projectData = loadProject(SAMPLE_PROJECT_PATH); + assertEquals("sampleProject", projectData.getProject().getName()); + checkSampleProjectConfiguration(projectData); } + @Test public void testLoadIprProject() { - loadProject(SAMPLE_PROJECT_IPR_PATH); - assertEquals("sampleProject", myProject.getName()); - checkSampleProjectConfiguration(getTestDataAbsoluteFile(SAMPLE_PROJECT_IPR_PATH).toFile().getParentFile()); + JpsProjectData projectData = loadProject(SAMPLE_PROJECT_IPR_PATH); + assertEquals("sampleProject", projectData.getProject().getName()); + checkSampleProjectConfiguration(projectData); } - private void checkSampleProjectConfiguration(File baseDirPath) { - assertTrue(FileUtil.filesEqual(baseDirPath, JpsModelSerializationDataService.getBaseDirectory(myProject))); - List modules = myProject.getModules(); + private static void checkSampleProjectConfiguration(JpsProjectData projectData) { + JpsProject project = projectData.getProject(); + File baseDirPath = projectData.getBaseProjectDir().toFile(); + assertTrue(FileUtil.filesEqual(baseDirPath, JpsModelSerializationDataService.getBaseDirectory(project))); + List modules = project.getModules(); assertEquals(3, modules.size()); JpsModule main = modules.get(0); assertEquals("main", main.getName()); @@ -49,7 +58,7 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { assertTrue(FileUtil.filesEqual(new File(baseDirPath, "util"), JpsModelSerializationDataService.getBaseDirectory(util))); - List libraries = myProject.getLibraryCollection().getLibraries(); + List libraries = project.getLibraryCollection().getLibraries(); assertEquals(3, libraries.size()); List dependencies = util.getDependenciesList().getDependencies(); @@ -68,33 +77,37 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { assertNotNull(projectSdkReference); assertEquals("1.6", projectSdkReference.getSdkName()); - assertEquals(getUrl("xxx/output"), JpsJavaExtensionService.getInstance().getOutputUrl(xxx, true)); - assertEquals(getUrl("xxx/output"), JpsJavaExtensionService.getInstance().getOutputUrl(xxx, false)); + assertEquals(projectData.getUrl("xxx/output"), JpsJavaExtensionService.getInstance().getOutputUrl(xxx, true)); + assertEquals(projectData.getUrl("xxx/output"), JpsJavaExtensionService.getInstance().getOutputUrl(xxx, false)); } + @Test public void testFileBasedProjectNameAndBaseDir() { - String relativePath = "/jps/model-serialization/testData/run-configurations/run-configurations.ipr"; - Path absolutePath = getTestDataAbsoluteFile(relativePath); - loadProject(relativePath); - assertEquals("run-configurations", myProject.getName()); - assertTrue(FileUtil.filesEqual(absolutePath.getParent().toFile(), JpsModelSerializationDataService.getBaseDirectory(myProject))); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/run-configurations/run-configurations.ipr"); + JpsProject project = projectData.getProject(); + assertEquals("run-configurations", project.getName()); + assertTrue(FileUtil.filesEqual(projectData.getBaseProjectDir().toFile(), JpsModelSerializationDataService.getBaseDirectory(project))); } + @Test public void testDirectoryBasedProjectName() { - loadProject("/jps/model-serialization/testData/run-configurations-dir"); - assertEquals("run-configurations-dir", myProject.getName()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/run-configurations-dir"); + assertEquals("run-configurations-dir", projectData.getProject().getName()); } + @Test public void testImlUnderDotIdea() { - loadProject("/jps/model-serialization/testData/imlUnderDotIdea"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/imlUnderDotIdea"); + JpsProject project = projectData.getProject(); + JpsModule module = assertOneElement(project.getModules()); JpsModuleSourceRoot root = assertOneElement(module.getSourceRoots()); - assertEquals(getUrl("src"), root.getUrl()); + assertEquals(projectData.getUrl("src"), root.getUrl()); } + @Test public void testTestModuleProperties() { - loadProject("/jps/model-serialization/testData/testModuleProperties/testModuleProperties.ipr"); - List modules = myProject.getModules(); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/testModuleProperties/testModuleProperties.ipr"); + List modules = projectData.getProject().getModules(); assertEquals(2, modules.size()); JpsModule testModule = modules.get(0); assertEquals("testModule", testModule.getName()); @@ -108,38 +121,42 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { assertSame(productionModule, testModuleProperties.getProductionModule()); } + @Test public void testInvalidLanguageLevel() { - loadProject("/jps/model-serialization/testData/testInvalidLanguageLevel/testInvalidLanguageLevel.ipr"); - List modules = myProject.getModules(); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/testInvalidLanguageLevel/testInvalidLanguageLevel.ipr"); + JpsProject project = projectData.getProject(); + List modules = project.getModules(); assertEquals(1, modules.size()); JpsModule testModule = modules.get(0); assertEquals("testModule", testModule.getName()); JpsJavaModuleExtension moduleExtension = JpsJavaExtensionService.getInstance().getModuleExtension(testModule); assertNull(moduleExtension.getLanguageLevel()); - JpsJavaProjectExtension projectExtension = JpsJavaExtensionService.getInstance().getProjectExtension(myProject); + JpsJavaProjectExtension projectExtension = JpsJavaExtensionService.getInstance().getProjectExtension(project); assertEquals(LanguageLevel.JDK_1_6, projectExtension.getLanguageLevel()); } + @Test public void testExcludePatterns() { - String projectPath = "/jps/model-serialization/testData/excludePatterns"; - loadProject(projectPath + "/excludePatterns.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/excludePatterns/excludePatterns.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); JpsExcludePattern pattern = assertOneElement(module.getExcludePatterns()); assertEquals("*.class", pattern.getPattern()); assertEquals(assertOneElement(module.getContentRootsList().getUrls()), pattern.getBaseDirUrl()); } + @Test public void testProjectSdkWithoutType() { - loadProject("/jps/model-serialization/testData/projectSdkWithoutType/projectSdkWithoutType.ipr"); - JpsSdkReference reference = myProject.getSdkReferencesTable().getSdkReference(JpsJavaSdkType.INSTANCE); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/projectSdkWithoutType/projectSdkWithoutType.ipr"); + JpsSdkReference reference = projectData.getProject().getSdkReferencesTable().getSdkReference(JpsJavaSdkType.INSTANCE); assertNotNull(reference); assertEquals("1.6", reference.getSdkName()); } + @Test public void testInvalidDependencyScope() { - loadProject("/jps/model-serialization/testData/invalidDependencyScope/invalidDependencyScope.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/invalidDependencyScope/invalidDependencyScope.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); List dependencies = module.getDependenciesList().getDependencies(); assertEquals(3, dependencies.size()); JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getDependencyExtension(dependencies.get(2)); @@ -147,52 +164,56 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { assertEquals(JpsJavaDependencyScope.COMPILE, extension.getScope()); } + @Test public void testDuplicatedModuleLibrary() { - loadProject("/jps/model-serialization/testData/duplicatedModuleLibrary/duplicatedModuleLibrary.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/duplicatedModuleLibrary/duplicatedModuleLibrary.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); List dependencies = module.getDependenciesList().getDependencies(); assertEquals(4, dependencies.size()); JpsLibrary lib1 = assertInstanceOf(dependencies.get(2), JpsLibraryDependency.class).getLibrary(); assertNotNull(lib1); - assertSameElements(lib1.getRootUrls(JpsOrderRootType.COMPILED), getUrl("data/lib1")); + UsefulTestCase.assertSameElements(lib1.getRootUrls(JpsOrderRootType.COMPILED), projectData.getUrl("data/lib1")); JpsLibrary lib2 = assertInstanceOf(dependencies.get(3), JpsLibraryDependency.class).getLibrary(); assertNotSame(lib1, lib2); assertNotNull(lib2); - assertSameElements(lib2.getRootUrls(JpsOrderRootType.COMPILED), getUrl("data/lib2")); + UsefulTestCase.assertSameElements(lib2.getRootUrls(JpsOrderRootType.COMPILED), projectData.getUrl("data/lib2")); } + @Test public void testDotIdeaUnderDotIdea() { - loadProject("/jps/model-serialization/testData/matryoshka/.idea"); - JpsJavaProjectExtension extension = JpsJavaExtensionService.getInstance().getProjectExtension(myProject); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/matryoshka/.idea"); + JpsJavaProjectExtension extension = JpsJavaExtensionService.getInstance().getProjectExtension(projectData.getProject()); assertNotNull(extension); - assertEquals(getUrl("out"), extension.getOutputUrl()); + assertEquals(projectData.getUrl("out"), extension.getOutputUrl()); } + @Test public void testLoadEncoding() { - loadProject(SAMPLE_PROJECT_PATH); - checkEncodingConfigurationInSampleProject(); + JpsProjectData projectData = loadProject(SAMPLE_PROJECT_PATH); + checkEncodingConfigurationInSampleProject(projectData); } + @Test public void testLoadEncodingIpr() { - loadProject(SAMPLE_PROJECT_IPR_PATH); - checkEncodingConfigurationInSampleProject(); + JpsProjectData projectData = loadProject(SAMPLE_PROJECT_IPR_PATH); + checkEncodingConfigurationInSampleProject(projectData); } - private void checkEncodingConfigurationInSampleProject() { + private void checkEncodingConfigurationInSampleProject(JpsProjectData projectData) { JpsEncodingConfigurationService service = JpsEncodingConfigurationService.getInstance(); - assertEquals("UTF-8", service.getProjectEncoding(myModel)); - JpsEncodingProjectConfiguration configuration = service.getEncodingConfiguration(myProject); + assertEquals("UTF-8", service.getProjectEncoding(projectData.getProject().getModel())); + JpsEncodingProjectConfiguration configuration = service.getEncodingConfiguration(projectData.getProject()); assertNotNull(configuration); assertEquals("UTF-8", configuration.getProjectEncoding()); - assertEquals("windows-1251", configuration.getEncoding(new File(getAbsolutePath("util")))); - assertEquals("windows-1251", configuration.getEncoding(new File(getAbsolutePath("util/foo/bar/file.txt")))); - assertEquals("UTF-8", configuration.getEncoding(new File(getAbsolutePath("other")))); + assertEquals("windows-1251", configuration.getEncoding(projectData.resolvePath("util").toFile())); + assertEquals("windows-1251", configuration.getEncoding(projectData.resolvePath("util/foo/bar/file.txt").toFile())); + assertEquals("UTF-8", configuration.getEncoding(projectData.resolvePath("other").toFile())); } + @Test public void testResourceRoots() { - String projectPath = "/jps/model-serialization/testData/resourceRoots/"; - loadProject(projectPath + "resourceRoots.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/resourceRoots/resourceRoots.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); List roots = module.getSourceRoots(); assertSame(JavaSourceRootType.SOURCE, roots.get(0).getRootType()); checkResourceRoot(roots.get(1), false, ""); @@ -200,9 +221,11 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { checkResourceRoot(roots.get(3), true, "foo"); } + @Test public void testMissingModuleSourcesOrderEntry() { - loadProject("/jps/model-serialization/testData/missingModuleSourcesOrderEntry/missingModuleSourcesOrderEntry.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = + loadProject("jps/model-serialization/testData/missingModuleSourcesOrderEntry/missingModuleSourcesOrderEntry.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); List dependencies = module.getDependenciesList().getDependencies(); assertEquals(2, dependencies.size()); assertInstanceOf(dependencies.get(0), JpsSdkDependency.class); @@ -217,35 +240,44 @@ public class JpsProjectSerializationTest extends JpsSerializationTestCase { assertEquals(relativeOutput, properties.getRelativeOutputPath()); } + @Test public void testUnloadedModule() { - String projectPath = "/jps/model-serialization/testData/unloadedModule"; - loadProject(projectPath); - assertEquals("main", assertOneElement(myProject.getModules()).getName()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/unloadedModule"); + assertEquals("main", assertOneElement(projectData.getProject().getModules()).getName()); } + @Test public void testMissingImlFile() { - loadProject("/jps/model-serialization/testData/missingImlFile/missingImlFile.ipr"); - assertEmpty(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/missingImlFile/missingImlFile.ipr"); + UsefulTestCase.assertEmpty(projectData.getProject().getModules()); } + @Test public void testMissingContentUrlAttribute() { - loadProject("/jps/model-serialization/testData/missingContentUrlAttribute/missingContentUrlAttribute.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/missingContentUrlAttribute/missingContentUrlAttribute.ipr"); + JpsModule module = assertOneElement(projectData.getProject().getModules()); assertEquals("missingContentUrlAttribute", module.getName()); } - public void testLoadIdeaProject() { + @Test + public void testLoadIdeaProject() throws IOException { long start = System.nanoTime(); - loadProjectByAbsolutePath(PathManager.getHomePath()); - assertTrue(myProject.getModules().size() > 0); - System.out.println("JpsProjectSerializationTest: " + myProject.getModules().size() + " modules, " + myProject.getLibraryCollection().getLibraries().size() + " libraries and " + - JpsArtifactService.getInstance().getArtifacts(myProject).size() + " artifacts loaded in " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) + "ms"); + JpsProject project = JpsSerializationManager.getInstance().loadProject(PathManager.getHomePath(), Collections.emptyMap()); + assertFalse(project.getModules().isEmpty()); + System.out.println("JpsProjectSerializationTest: " + project.getModules().size() + " modules, " + project.getLibraryCollection().getLibraries().size() + " libraries and " + + JpsArtifactService.getInstance().getArtifacts(project).size() + " artifacts loaded in " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) + "ms"); } + @Test public void testExcludesInLibraries() { - loadProject("/jps/model-serialization/testData/excludesInLibraries"); - JpsLibrary library = assertOneElement(myProject.getLibraryCollection().getLibraries()); + JpsProjectData projectData = loadProject("jps/model-serialization/testData/excludesInLibraries"); + JpsLibrary library = assertOneElement(projectData.getProject().getLibraryCollection().getLibraries()); assertEquals("junit", library.getName()); - assertEquals(JpsPathUtil.getLibraryRootUrl(new File(getAbsolutePath("lib/junit.jar"))), assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl()); + assertEquals(JpsPathUtil.getLibraryRootUrl(projectData.resolvePath("lib/junit.jar").toFile()), + assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl()); + } + + private @NotNull JpsProjectData loadProject(String projectPath) { + return JpsProjectData.loadFromTestData(projectPath, getClass()); } } diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRepositoryLibrarySerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRepositoryLibrarySerializationTest.java index 146fec0873e7..36c3d59a112f 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRepositoryLibrarySerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRepositoryLibrarySerializationTest.java @@ -7,8 +7,14 @@ import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.library.JpsMavenRepositoryLibraryDescriptor; import org.jetbrains.jps.model.library.JpsRepositoryLibraryType; import org.jetbrains.jps.model.library.JpsTypedLibrary; +import org.junit.jupiter.api.Test; -public class JpsRepositoryLibrarySerializationTest extends JpsSerializationTestCase { +import static com.intellij.testFramework.UsefulTestCase.assertEmpty; +import static com.intellij.testFramework.UsefulTestCase.assertSameElements; +import static org.junit.jupiter.api.Assertions.*; + +public class JpsRepositoryLibrarySerializationTest { + @Test public void testPlain() { JpsMavenRepositoryLibraryDescriptor properties = loadLibrary("plain"); assertEquals("junit", properties.getGroupId()); @@ -18,12 +24,14 @@ public class JpsRepositoryLibrarySerializationTest extends JpsSerializationTestC assertEmpty(properties.getExcludedDependencies()); } + @Test public void testWithoutTransitiveDependencies() { JpsMavenRepositoryLibraryDescriptor properties = loadLibrary("without-transitive-dependencies"); assertFalse(properties.isIncludeTransitiveDependencies()); assertEmpty(properties.getExcludedDependencies()); } + @Test public void testWithExcludedDependencies() { JpsMavenRepositoryLibraryDescriptor properties = loadLibrary("with-excluded-dependencies"); assertTrue(properties.isIncludeTransitiveDependencies()); @@ -32,8 +40,8 @@ public class JpsRepositoryLibrarySerializationTest extends JpsSerializationTestC @NotNull private JpsMavenRepositoryLibraryDescriptor loadLibrary(String name) { - loadProject("/jps/model-serialization/testData/repositoryLibraries"); - JpsLibrary library = myProject.getLibraryCollection().findLibrary(name); + JpsProjectData projectData = JpsProjectData.loadFromTestData("jps/model-serialization/testData/repositoryLibraries", getClass()); + JpsLibrary library = projectData.getProject().getLibraryCollection().findLibrary(name); assertNotNull(library); assertSame(JpsRepositoryLibraryType.INSTANCE, library.getType()); JpsTypedLibrary> typed = library.asTyped(JpsRepositoryLibraryType.INSTANCE); diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java index 10c97dbaec38..74ea19d56bab 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java @@ -17,28 +17,36 @@ package org.jetbrains.jps.model.serialization; import com.intellij.util.containers.ContainerUtil; import junit.framework.AssertionFailedError; +import org.jetbrains.jps.model.JpsProject; import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationProperties; import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationType; import org.jetbrains.jps.model.runConfiguration.JpsRunConfiguration; import org.jetbrains.jps.model.runConfiguration.JpsRunConfigurationType; import org.jetbrains.jps.model.runConfiguration.JpsTypedRunConfiguration; import org.jetbrains.jps.model.serialization.runConfigurations.JpsUnknownRunConfigurationType; +import org.junit.jupiter.api.Test; import java.util.List; -public class JpsRunConfigurationsSerializationTest extends JpsSerializationTestCase { +import static com.intellij.testFramework.UsefulTestCase.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class JpsRunConfigurationsSerializationTest { + @Test public void testLoadIpr() { doTest("jps/model-serialization/testData/run-configurations/run-configurations.ipr"); } + @Test public void testLoadDirectoryBased() { doTest("jps/model-serialization/testData/run-configurations-dir"); } private void doTest(final String relativePath) { - loadProject(relativePath); + JpsProjectData projectData = JpsProjectData.loadFromTestData(relativePath, getClass()); + JpsProject project = projectData.getProject(); List> - configurations = ContainerUtil.newArrayList(myProject.getRunConfigurations(JpsApplicationRunConfigurationType.INSTANCE)); + configurations = ContainerUtil.newArrayList(project.getRunConfigurations(JpsApplicationRunConfigurationType.INSTANCE)); assertEquals(2, configurations.size()); JpsTypedRunConfiguration shared = configurations.get(0); @@ -49,7 +57,7 @@ public class JpsRunConfigurationsSerializationTest extends JpsSerializationTestC assertEquals("Main", main.getName()); assertEquals("xxx.Main", main.getProperties().getMainClass()); - List all = myProject.getRunConfigurations(); + List all = project.getRunConfigurations(); JpsRunConfiguration junit = findByName(all, "test"); JpsRunConfigurationType type = ((JpsTypedRunConfiguration)junit).getType(); assertEquals("JUnit", assertInstanceOf(type, JpsUnknownRunConfigurationType.class).getTypeId()); diff --git a/plugins/ant/jps-plugin/testSrc/org/jetbrains/jps/ant/JpsAntSerializationTest.kt b/plugins/ant/jps-plugin/testSrc/org/jetbrains/jps/ant/JpsAntSerializationTest.kt index f1ba84804d58..f7034ca7daee 100644 --- a/plugins/ant/jps-plugin/testSrc/org/jetbrains/jps/ant/JpsAntSerializationTest.kt +++ b/plugins/ant/jps-plugin/testSrc/org/jetbrains/jps/ant/JpsAntSerializationTest.kt @@ -1,27 +1,30 @@ // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.jps.ant +import com.intellij.openapi.application.ex.PathManagerEx import com.intellij.openapi.util.io.FileUtil import com.intellij.testFramework.UsefulTestCase +import com.intellij.testFramework.UsefulTestCase.assertContainsElements +import com.intellij.testFramework.UsefulTestCase.assertOneElement import com.intellij.util.SystemProperties import com.intellij.util.containers.FileCollectionFactory import com.intellij.util.io.directoryContent import org.jetbrains.jps.ant.model.JpsAntExtensionService import org.jetbrains.jps.ant.model.impl.artifacts.JpsAntArtifactExtensionImpl import org.jetbrains.jps.model.artifact.JpsArtifactService -import org.jetbrains.jps.model.serialization.JpsSerializationTestCase +import org.jetbrains.jps.model.serialization.JpsGlobalSettingsLoading.loadGlobalSettings +import org.jetbrains.jps.model.serialization.JpsProjectData +import org.junit.jupiter.api.Assertions.* +import org.junit.jupiter.api.Test import java.io.File +import kotlin.io.path.Path +import kotlin.io.path.absolutePathString -class JpsAntSerializationTest : JpsSerializationTestCase() { - private lateinit var antHome: File - - override fun setUp() { - super.setUp() - antHome = createTempDir("antHome") - } - +class JpsAntSerializationTest { + @Test fun testLoadArtifactProperties() { - loadProject(PROJECT_PATH) + val projectData = JpsProjectData.loadFromTestData(PROJECT_PATH, javaClass) + val myProject = projectData.project val artifacts = JpsArtifactService.getInstance().getSortedArtifacts(myProject) assertEquals(2, artifacts.size) val dir = artifacts[0] @@ -29,13 +32,13 @@ class JpsAntSerializationTest : JpsSerializationTestCase() { val preprocessing = JpsAntExtensionService.getPreprocessingExtension(dir)!! assertTrue(preprocessing.isEnabled) - assertEquals(getUrl("build.xml"), preprocessing.fileUrl) + assertEquals(projectData.getUrl("build.xml"), preprocessing.fileUrl) assertEquals("show-message", preprocessing.targetName) assertEquals(JpsAntArtifactExtensionImpl.ARTIFACT_OUTPUT_PATH_PROPERTY, assertOneElement(preprocessing.antProperties).getPropertyName()) val postprocessing = JpsAntExtensionService.getPostprocessingExtension(dir)!! - assertEquals(getUrl("build.xml"), postprocessing.fileUrl) + assertEquals(projectData.getUrl("build.xml"), postprocessing.fileUrl) assertEquals("create-file", postprocessing.targetName) val properties = postprocessing.antProperties assertEquals(2, properties.size) @@ -51,57 +54,56 @@ class JpsAntSerializationTest : JpsSerializationTestCase() { assertNull(JpsAntExtensionService.getPreprocessingExtension(jar)) } + @Test fun testLoadAntInstallations() { - directoryContent { + val antHome = directoryContent { file("foo.jar") dir("lib") { file("bar.jar") } - }.generate(antHome) - loadGlobalSettings(OPTIONS_PATH) - val installation = JpsAntExtensionService.findAntInstallation(myModel, "Apache Ant version 1.8.2") + }.generateInTempDir() + val model = org.jetbrains.jps.model.serialization.loadGlobalSettings(OPTIONS_PATH, javaClass, mapOf( + "MY_ANT_HOME_DIR" to antHome.absolutePathString() + )) + val installation = JpsAntExtensionService.findAntInstallation(model, "Apache Ant version 1.8.2") assertNotNull(installation) assertEquals(FileUtil.toSystemIndependentName(installation!!.antHome.absolutePath), FileUtil.toSystemIndependentName( File(SystemProperties.getUserHome(), "applications/apache-ant-1.8.2").absolutePath)) - val installation2 = JpsAntExtensionService.findAntInstallation(myModel, "Patched Ant") + val installation2 = JpsAntExtensionService.findAntInstallation(model, "Patched Ant") assertNotNull(installation2) UsefulTestCase.assertSameElements(toFiles(installation2!!.classpath), - File(antHome, "foo.jar"), - File(antHome, "lib/bar.jar")) - } - - override fun getPathVariables(): Map { - val pathVariables = super.getPathVariables() - pathVariables.put("MY_ANT_HOME_DIR", antHome.absolutePath) - return pathVariables + File(antHome.toFile(), "foo.jar"), + File(antHome.toFile(), "lib/bar.jar")) } + @Test fun testLoadAntConfiguration() { - loadProject(PROJECT_PATH) - loadGlobalSettings(OPTIONS_PATH) - val buildXmlUrl = getUrl("build.xml") - val options = JpsAntExtensionService.getOptions(myProject, buildXmlUrl) + val projectData = JpsProjectData.loadFromTestData(PROJECT_PATH, javaClass) + val model = projectData.project.model + loadGlobalSettings(model.global, Path(PathManagerEx.getCommunityHomePath()).resolve(OPTIONS_PATH).absolutePathString()) + val buildXmlUrl = projectData.getUrl("build.xml") + val options = JpsAntExtensionService.getOptions(projectData.project, buildXmlUrl) assertEquals(128, options.maxHeapSize) assertEquals("-J-Dmy.ant.prop=123", options.antCommandLineParameters) assertContainsElements(toFiles(options.additionalClasspath), - File(getAbsolutePath("lib/jdom.jar")), - File(getAbsolutePath("ant-lib/a.jar"))) + projectData.baseProjectDir.resolve("lib/jdom.jar").toFile(), + projectData.baseProjectDir.resolve("ant-lib/a.jar").toFile()) val property = assertOneElement(options.properties) assertEquals("my.property", property.getPropertyName()) assertEquals("its value", property.getPropertyValue()) - val emptyFileUrl = getUrl("empty.xml") - val options2 = JpsAntExtensionService.getOptions(myProject, emptyFileUrl) + val emptyFileUrl = projectData.getUrl("empty.xml") + val options2 = JpsAntExtensionService.getOptions(projectData.project, emptyFileUrl) assertEquals(256, options2.maxHeapSize) assertEquals(10, options2.maxStackSize) assertEquals("1.6", options2.customJdkName) - val bundled = JpsAntExtensionService.getAntInstallationForBuildFile(myModel, buildXmlUrl)!! + val bundled = JpsAntExtensionService.getAntInstallationForBuildFile(model, buildXmlUrl)!! assertEquals("Bundled Ant", bundled.name) - val installation = JpsAntExtensionService.getAntInstallationForBuildFile(myModel, emptyFileUrl)!! + val installation = JpsAntExtensionService.getAntInstallationForBuildFile(model, emptyFileUrl)!! assertEquals("Apache Ant version 1.8.2", installation.name) } diff --git a/plugins/devkit/jps-plugin/testSrc/org/jetbrains/jps/devkit/model/JpsPluginProjectSerializationTest.java b/plugins/devkit/jps-plugin/testSrc/org/jetbrains/jps/devkit/model/JpsPluginProjectSerializationTest.java index f12b6f5508f6..d620c7105bed 100644 --- a/plugins/devkit/jps-plugin/testSrc/org/jetbrains/jps/devkit/model/JpsPluginProjectSerializationTest.java +++ b/plugins/devkit/jps-plugin/testSrc/org/jetbrains/jps/devkit/model/JpsPluginProjectSerializationTest.java @@ -15,30 +15,36 @@ */ package org.jetbrains.jps.devkit.model; -import org.jetbrains.jps.model.JpsDummyElement; -import org.jetbrains.jps.model.JpsElementFactory; -import org.jetbrains.jps.model.JpsSimpleElement; +import org.jetbrains.jps.model.*; import org.jetbrains.jps.model.java.JpsJavaSdkType; import org.jetbrains.jps.model.library.JpsTypedLibrary; import org.jetbrains.jps.model.library.sdk.JpsSdk; import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsTypedModule; -import org.jetbrains.jps.model.serialization.JpsSerializationTestCase; +import org.jetbrains.jps.model.serialization.JpsProjectData; +import org.junit.jupiter.api.Test; -public class JpsPluginProjectSerializationTest extends JpsSerializationTestCase { +import static com.intellij.testFramework.UsefulTestCase.assertOneElement; +import static org.junit.jupiter.api.Assertions.*; + +public class JpsPluginProjectSerializationTest { + @Test public void testLoadProject() { - loadProject("plugins/devkit/jps-plugin/testData/pluginProject/pluginProject.ipr"); - JpsModule module = assertOneElement(myProject.getModules()); + JpsProjectData projectData = + JpsProjectData.loadFromTestData("plugins/devkit/jps-plugin/testData/pluginProject/pluginProject.ipr", getClass()); + JpsProject project = projectData.getProject(); + JpsModule module = assertOneElement(project.getModules()); assertEquals(JpsPluginModuleType.INSTANCE, module.getModuleType()); JpsTypedModule> pluginModule = module.asTyped(JpsPluginModuleType.INSTANCE); assertNotNull(pluginModule); String url = pluginModule.getProperties().getData().getPluginXmlUrl(); - assertEquals(getUrl("META-INF/plugin.xml"), url); + assertEquals(projectData.getUrl("META-INF/plugin.xml"), url); - JpsTypedLibrary> javaSdk = myModel.getGlobal().addSdk("1.6", null, null, JpsJavaSdkType.INSTANCE); + JpsGlobal global = project.getModel().getGlobal(); + JpsTypedLibrary> javaSdk = global.addSdk("1.6", null, null, JpsJavaSdkType.INSTANCE); JpsSimpleElement properties = JpsElementFactory.getInstance().createSimpleElement(new JpsIdeaSdkProperties(null, "1.6")); - JpsTypedLibrary>> pluginSdk = myModel.getGlobal() + JpsTypedLibrary>> pluginSdk = global .addSdk("IDEA plugin SDK", null, null, JpsIdeaSdkType.INSTANCE, properties); assertSame(pluginSdk.getProperties(), module.getSdk(JpsIdeaSdkType.INSTANCE)); assertSame(javaSdk.getProperties(), module.getSdk(JpsJavaSdkType.INSTANCE)); diff --git a/plugins/maven/jps-plugin/testSrc/org/jetbrains/jps/maven/model/JpsMavenModuleSerializationTest.java b/plugins/maven/jps-plugin/testSrc/org/jetbrains/jps/maven/model/JpsMavenModuleSerializationTest.java index 618481411cf6..785d9494de3f 100644 --- a/plugins/maven/jps-plugin/testSrc/org/jetbrains/jps/maven/model/JpsMavenModuleSerializationTest.java +++ b/plugins/maven/jps-plugin/testSrc/org/jetbrains/jps/maven/model/JpsMavenModuleSerializationTest.java @@ -2,14 +2,18 @@ package org.jetbrains.jps.maven.model; import org.jetbrains.jps.model.module.JpsDependencyElement; import org.jetbrains.jps.model.module.JpsModule; -import org.jetbrains.jps.model.serialization.JpsSerializationTestCase; +import org.jetbrains.jps.model.serialization.JpsProjectData; +import org.junit.jupiter.api.Test; import java.util.List; -public class JpsMavenModuleSerializationTest extends JpsSerializationTestCase { +import static org.junit.jupiter.api.Assertions.*; + +public class JpsMavenModuleSerializationTest { + @Test public void testLoadProject() { - loadProject("plugins/maven/jps-plugin/testData/compiler/classpathTest"); - List modules = myProject.getModules(); + JpsProjectData projectData = JpsProjectData.loadFromTestData("plugins/maven/jps-plugin/testData/compiler/classpathTest", getClass()); + List modules = projectData.getProject().getModules(); assertEquals(3, modules.size()); JpsModule main = modules.get(0); assertEquals("main", main.getName()); diff --git a/plugins/ui-designer/jps-plugin/testSrc/org/jetbrains/jps/uiDesigner/model/JpsUiDesignerConfigurationSerializationTest.java b/plugins/ui-designer/jps-plugin/testSrc/org/jetbrains/jps/uiDesigner/model/JpsUiDesignerConfigurationSerializationTest.java index 73ae93af3c04..d016e6588ae0 100644 --- a/plugins/ui-designer/jps-plugin/testSrc/org/jetbrains/jps/uiDesigner/model/JpsUiDesignerConfigurationSerializationTest.java +++ b/plugins/ui-designer/jps-plugin/testSrc/org/jetbrains/jps/uiDesigner/model/JpsUiDesignerConfigurationSerializationTest.java @@ -15,12 +15,18 @@ */ package org.jetbrains.jps.uiDesigner.model; -import org.jetbrains.jps.model.serialization.JpsSerializationTestCase; +import org.jetbrains.jps.model.JpsProject; +import org.jetbrains.jps.model.serialization.JpsProjectData; +import org.junit.jupiter.api.Test; -public class JpsUiDesignerConfigurationSerializationTest extends JpsSerializationTestCase { +import static org.junit.jupiter.api.Assertions.*; + +public class JpsUiDesignerConfigurationSerializationTest { + @Test public void testLoad() { - loadProject("plugins/ui-designer/jps-plugin/testData/uiDesigner"); - JpsUiDesignerConfiguration configuration = JpsUiDesignerExtensionService.getInstance().getUiDesignerConfiguration(myProject); + JpsProjectData projectData = JpsProjectData.loadFromTestData("plugins/ui-designer/jps-plugin/testData/uiDesigner", getClass()); + JpsProject project = projectData.getProject(); + JpsUiDesignerConfiguration configuration = JpsUiDesignerExtensionService.getInstance().getUiDesignerConfiguration(project); assertNotNull(configuration); assertTrue(configuration.isInstrumentClasses()); assertFalse(configuration.isCopyFormsRuntimeToOutput());