artifact builder tests: duplicated method removed
[idea/community.git] / jps / jps-builders / testSrc / org / jetbrains / jps / incremental / artifacts / ArtifactBuilderTestCase.java
1 /*
2  * Copyright 2000-2012 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.jetbrains.jps.incremental.artifacts;
17
18 import com.intellij.openapi.application.PathManager;
19 import com.intellij.openapi.util.io.FileUtil;
20 import com.intellij.util.ArrayUtil;
21 import com.intellij.util.io.TestFileSystemBuilder;
22 import com.intellij.util.text.UniqueNameGenerator;
23 import org.jetbrains.jps.builders.CompileScopeTestBuilder;
24 import org.jetbrains.jps.builders.JpsBuildTestCase;
25 import org.jetbrains.jps.model.JpsElementFactory;
26 import org.jetbrains.jps.model.artifact.DirectoryArtifactType;
27 import org.jetbrains.jps.model.artifact.JpsArtifact;
28 import org.jetbrains.jps.model.artifact.JpsArtifactService;
29 import org.jetbrains.jps.model.java.JpsJavaExtensionService;
30 import org.jetbrains.jps.model.java.JpsJavaLibraryType;
31 import org.jetbrains.jps.model.library.JpsLibrary;
32 import org.jetbrains.jps.model.library.JpsOrderRootType;
33 import org.jetbrains.jps.model.module.JpsModule;
34 import org.jetbrains.jps.util.JpsPathUtil;
35
36 import java.io.File;
37 import java.io.IOException;
38 import java.util.Collection;
39 import java.util.HashSet;
40 import java.util.Set;
41
42 import static com.intellij.util.io.TestFileSystemItem.fs;
43
44 /**
45  * @author nik
46  */
47 public abstract class ArtifactBuilderTestCase extends JpsBuildTestCase {
48   protected static void createFileInArtifactOutput(JpsArtifact a, final String relativePath) {
49     createFileInOutputDir(a.getOutputPath(), relativePath);
50   }
51
52   protected static void createFileInModuleOutput(JpsModule m, final String relativePath) {
53     File outputDirectory = JpsJavaExtensionService.getInstance().getOutputDirectory(m, false);
54     assertNotNull(outputDirectory);
55     createFileInOutputDir(outputDirectory.getAbsolutePath(), relativePath);
56   }
57
58   private static void createFileInOutputDir(final String outputPath, final String relativePath) {
59     try {
60       boolean created = new File(outputPath, relativePath).createNewFile();
61       assertTrue(created);
62     }
63     catch (IOException e) {
64       throw new RuntimeException(e);
65     }
66   }
67
68   @Override
69   protected void tearDown() throws Exception {
70     for (JpsArtifact artifact : JpsArtifactService.getInstance().getArtifacts(myProject)) {
71       String outputPath = artifact.getOutputPath();
72       if (outputPath != null) {
73         FileUtil.delete(new File(FileUtil.toSystemDependentName(outputPath)));
74       }
75     }
76     super.tearDown();
77   }
78
79   public JpsArtifact addArtifact(LayoutElementTestUtil.LayoutElementCreator root) {
80     Set<String> usedNames = getArtifactNames();
81     final String name = UniqueNameGenerator.generateUniqueName("a", usedNames);
82     return addArtifact(name, root);
83   }
84
85   private Set<String> getArtifactNames() {
86     Set<String> usedNames = new HashSet<String>();
87     for (JpsArtifact artifact : JpsArtifactService.getInstance().getArtifacts(myProject)) {
88       usedNames.add(artifact.getName());
89     }
90     return usedNames;
91   }
92
93   protected JpsArtifact addArtifact(String name, LayoutElementTestUtil.LayoutElementCreator root) {
94     assertFalse("JpsArtifact " + name + " already exists", getArtifactNames().contains(name));
95     JpsArtifact artifact = JpsArtifactService.getInstance().addArtifact(myProject, name, root.buildElement(), DirectoryArtifactType.INSTANCE,
96                                                                         JpsElementFactory.getInstance().createDummyElement());
97     artifact.setOutputPath(getAbsolutePath("out/artifacts/" + name));
98     return artifact;
99   }
100
101   protected JpsLibrary addProjectLibrary(String name, String jarPath) {
102     final JpsLibrary library = myProject.getLibraryCollection().addLibrary(name, JpsJavaLibraryType.INSTANCE);
103     library.addRoot(JpsPathUtil.pathToUrl(jarPath), JpsOrderRootType.COMPILED);
104     return library;
105   }
106
107   protected void buildAll() {
108     Collection<JpsArtifact> artifacts = JpsArtifactService.getInstance().getArtifacts(myProject);
109     buildArtifacts(artifacts.toArray(new JpsArtifact[artifacts.size()]));
110   }
111
112   protected void buildArtifacts(JpsArtifact... artifacts) {
113     doBuild(CompileScopeTestBuilder.make().allModules().artifacts(artifacts)).assertSuccessful();
114   }
115
116   protected static String getJUnitJarPath() {
117     final File file = PathManager.findFileInLibDirectory("junit.jar");
118     assertTrue("File " + file.getAbsolutePath() + " doesn't exist", file.exists());
119     return FileUtil.toSystemIndependentName(file.getAbsolutePath());
120   }
121
122   protected static void assertEmptyOutput(JpsArtifact a) {
123     assertOutput(a, fs());
124   }
125
126   protected void assertBuildFailed(JpsArtifact a) {
127     doBuild(CompileScopeTestBuilder.make().allModules().artifact(a)).assertFailed();
128   }
129
130   protected void assertCopied(String... filePaths) {
131     assertDeletedAndCopied(ArrayUtil.EMPTY_STRING_ARRAY, filePaths);
132   }
133
134   protected void assertDeletedAndCopied(String deletedPath, String... copiedPaths) {
135     assertDeletedAndCopied(new String[]{deletedPath}, copiedPaths);
136   }
137
138   protected void assertDeletedAndCopied(String[] deletedPaths, String... copiedPaths) {
139     assertCompiled(IncArtifactBuilder.BUILDER_NAME, copiedPaths);
140     super.assertDeleted(deletedPaths);
141   }
142
143   @Override
144   protected void assertDeleted(String... paths) {
145     assertDeletedAndCopied(paths);
146   }
147
148   protected static void assertOutput(JpsArtifact a, TestFileSystemBuilder expected) {
149     assertOutput(a.getOutputPath(), expected);
150   }
151
152   protected void buildAllAndAssertUpToDate() {
153     buildAll();
154     assertUpToDate();
155   }
156
157   protected void assertUpToDate() {
158     assertDeletedAndCopied(ArrayUtil.EMPTY_STRING_ARRAY);
159   }
160
161 }