mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-03-22 15:19:59 +07:00
[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
This commit is contained in:
Nikolay Chashnikov
committed by
intellij-monorepo-bot
intellij-monorepo-bot
parent
c992e6c464
commit
fbcba43905
@@ -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()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
<orderEntry type="module" module-name="intellij.platform.testFramework.junit5" exported="" scope="TEST" />
|
||||
<orderEntry type="module" module-name="intellij.platform.jps.model.serialization" />
|
||||
<orderEntry type="module" module-name="intellij.platform.jps.model.tests" exported="" scope="TEST" />
|
||||
<orderEntry type="module" module-name="intellij.platform.testExtensions" scope="TEST" />
|
||||
|
||||
@@ -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()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<JpsArtifact> artifacts = getService().getSortedArtifacts(myProject);
|
||||
JpsProjectData projectData = JpsProjectData.loadFromTestData(SAMPLE_PROJECT_PATH, getClass());
|
||||
List<JpsArtifact> artifacts = getService().getSortedArtifacts(projectData.getProject());
|
||||
assertEquals(2, artifacts.size());
|
||||
assertEquals("dir", artifacts.get(0).getName());
|
||||
assertEquals("jar", artifacts.get(1).getName());
|
||||
|
||||
@@ -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<JpsLibrary> libraries = myModel.getGlobal().getLibraryCollection().getLibraries();
|
||||
JpsModel model = JpsModelFromTestData.loadGlobalSettings(OPTIONS_DIR, getClass());
|
||||
final List<JpsLibrary> 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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<String, String>) {
|
||||
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<String, String> = emptyMap(),
|
||||
): JpsProjectData {
|
||||
return JpsProjectData(relativeProjectPath, testClass, pathVariables)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@JvmOverloads
|
||||
fun loadGlobalSettings(relativeOptionsPath: String, testClass: Class<*>, additionalPathVariables: Map<String, String> = 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
|
||||
}
|
||||
|
||||
@@ -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<JpsModule> 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<JpsModule> 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<JpsLibrary> libraries = myProject.getLibraryCollection().getLibraries();
|
||||
List<JpsLibrary> libraries = project.getLibraryCollection().getLibraries();
|
||||
assertEquals(3, libraries.size());
|
||||
|
||||
List<JpsDependencyElement> 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<JpsModule> modules = myProject.getModules();
|
||||
JpsProjectData projectData = loadProject("jps/model-serialization/testData/testModuleProperties/testModuleProperties.ipr");
|
||||
List<JpsModule> 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<JpsModule> modules = myProject.getModules();
|
||||
JpsProjectData projectData = loadProject("jps/model-serialization/testData/testInvalidLanguageLevel/testInvalidLanguageLevel.ipr");
|
||||
JpsProject project = projectData.getProject();
|
||||
List<JpsModule> 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<JpsDummyElement> reference = myProject.getSdkReferencesTable().getSdkReference(JpsJavaSdkType.INSTANCE);
|
||||
JpsProjectData projectData = loadProject("jps/model-serialization/testData/projectSdkWithoutType/projectSdkWithoutType.ipr");
|
||||
JpsSdkReference<JpsDummyElement> 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<JpsDependencyElement> 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<JpsDependencyElement> 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<JpsModuleSourceRoot> 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<JpsDependencyElement> 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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<JpsSimpleElement<JpsMavenRepositoryLibraryDescriptor>> typed = library.asTyped(JpsRepositoryLibraryType.INSTANCE);
|
||||
|
||||
@@ -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<JpsTypedRunConfiguration<JpsApplicationRunConfigurationProperties>>
|
||||
configurations = ContainerUtil.newArrayList(myProject.getRunConfigurations(JpsApplicationRunConfigurationType.INSTANCE));
|
||||
configurations = ContainerUtil.newArrayList(project.getRunConfigurations(JpsApplicationRunConfigurationType.INSTANCE));
|
||||
assertEquals(2, configurations.size());
|
||||
|
||||
JpsTypedRunConfiguration<JpsApplicationRunConfigurationProperties> shared = configurations.get(0);
|
||||
@@ -49,7 +57,7 @@ public class JpsRunConfigurationsSerializationTest extends JpsSerializationTestC
|
||||
assertEquals("Main", main.getName());
|
||||
assertEquals("xxx.Main", main.getProperties().getMainClass());
|
||||
|
||||
List<JpsRunConfiguration> all = myProject.getRunConfigurations();
|
||||
List<JpsRunConfiguration> all = project.getRunConfigurations();
|
||||
JpsRunConfiguration junit = findByName(all, "test");
|
||||
JpsRunConfigurationType type = ((JpsTypedRunConfiguration)junit).getType();
|
||||
assertEquals("JUnit", assertInstanceOf(type, JpsUnknownRunConfigurationType.class).getTypeId());
|
||||
|
||||
@@ -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<String, String> {
|
||||
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)
|
||||
|
||||
}
|
||||
|
||||
@@ -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<JpsSimpleElement<JpsPluginModuleProperties>> 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<JpsSdk<JpsDummyElement>> javaSdk = myModel.getGlobal().addSdk("1.6", null, null, JpsJavaSdkType.INSTANCE);
|
||||
JpsGlobal global = project.getModel().getGlobal();
|
||||
JpsTypedLibrary<JpsSdk<JpsDummyElement>> javaSdk = global.addSdk("1.6", null, null, JpsJavaSdkType.INSTANCE);
|
||||
JpsSimpleElement<JpsIdeaSdkProperties> properties =
|
||||
JpsElementFactory.getInstance().createSimpleElement(new JpsIdeaSdkProperties(null, "1.6"));
|
||||
JpsTypedLibrary<JpsSdk<JpsSimpleElement<JpsIdeaSdkProperties>>> pluginSdk = myModel.getGlobal()
|
||||
JpsTypedLibrary<JpsSdk<JpsSimpleElement<JpsIdeaSdkProperties>>> 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));
|
||||
|
||||
@@ -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<JpsModule> modules = myProject.getModules();
|
||||
JpsProjectData projectData = JpsProjectData.loadFromTestData("plugins/maven/jps-plugin/testData/compiler/classpathTest", getClass());
|
||||
List<JpsModule> modules = projectData.getProject().getModules();
|
||||
assertEquals(3, modules.size());
|
||||
JpsModule main = modules.get(0);
|
||||
assertEquals("main", main.getName());
|
||||
|
||||
@@ -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());
|
||||
|
||||
Reference in New Issue
Block a user