run tests on module classpath: lvcs
[idea/community.git] / platform / lvcs-impl / testSrc / com / intellij / historyIntegrTests / IntegrationTestCase.java
1 /*
2  * Copyright 2000-2009 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
17 package com.intellij.historyIntegrTests;
18
19 import com.intellij.history.Clock;
20 import com.intellij.history.core.LocalHistoryFacade;
21 import com.intellij.history.core.LocalHistoryTestCase;
22 import com.intellij.history.core.Paths;
23 import com.intellij.history.core.revisions.Revision;
24 import com.intellij.history.core.tree.Entry;
25 import com.intellij.history.core.tree.RootEntry;
26 import com.intellij.history.integration.IdeaGateway;
27 import com.intellij.history.integration.LocalHistoryImpl;
28 import com.intellij.history.utils.RunnableAdapter;
29 import com.intellij.openapi.application.ApplicationManager;
30 import com.intellij.openapi.fileEditor.FileDocumentManager;
31 import com.intellij.openapi.module.Module;
32 import com.intellij.openapi.roots.ContentEntry;
33 import com.intellij.openapi.roots.ModifiableRootModel;
34 import com.intellij.openapi.roots.ModuleRootManager;
35 import com.intellij.openapi.util.io.FileUtil;
36 import com.intellij.openapi.vfs.*;
37 import com.intellij.testFramework.PlatformTestCase;
38 import com.intellij.testFramework.PsiTestUtil;
39 import org.jetbrains.annotations.NotNull;
40
41 import java.io.File;
42 import java.io.IOException;
43 import java.util.List;
44 import java.util.Locale;
45
46 public abstract class IntegrationTestCase extends PlatformTestCase {
47   public static final int TIMESTAMP_INCREMENT = 3000;
48   protected static final String FILTERED_DIR_NAME = "CVS";
49
50   private Locale myDefaultLocale;
51   protected VirtualFile myRoot;
52   protected IdeaGateway myGateway;
53
54   @SuppressWarnings({"JUnitTestCaseWithNonTrivialConstructors"})
55   public IntegrationTestCase() {
56     PlatformTestCase.initPlatformLangPrefix();
57   }
58
59   @Override
60   public void setUp() throws Exception {
61     super.setUp();
62     Clock.useRealClock();
63     Paths.useSystemCaseSensitivity();
64
65     myDefaultLocale = Locale.getDefault();
66     Locale.setDefault(new Locale("ru", "RU"));
67
68     myGateway = new IdeaGateway();
69
70     runWriteAction(new RunnableAdapter() {
71       @Override
72       public void doRun() throws Exception {
73         setUpInWriteAction();
74       }
75     });
76   }
77
78   protected File getIprFile() throws IOException {
79     return new File(createTempDirectory(), "test.ipr");
80   }
81
82   protected void setUpInWriteAction() throws Exception {
83     myRoot = LocalFileSystem.getInstance().findFileByIoFile(createTempDirectory());
84     PsiTestUtil.addContentRoot(myModule, myRoot);
85   }
86
87   @Override
88   protected void tearDown() throws Exception {
89     Locale.setDefault(myDefaultLocale);
90     Clock.useRealClock();
91     Paths.useSystemCaseSensitivity();
92     super.tearDown();
93   }
94
95   protected void runWriteAction(Runnable r) {
96     ApplicationManager.getApplication().runWriteAction(r);
97   }
98
99   protected VirtualFile createFile(String name) throws IOException {
100     return createFile(name, null);
101   }
102
103   @NotNull
104   protected VirtualFile createFile(String name, String content) throws IOException {
105     return LocalFileSystem.getInstance().refreshAndFindFileByPath(createFileExternally(name, content));
106   }
107
108   @NotNull
109   protected VirtualFile createDirectory(String name) throws IOException {
110     return LocalFileSystem.getInstance().refreshAndFindFileByPath(createDirectoryExternally(name));
111   }
112
113   protected void setContent(VirtualFile f, String content) throws IOException {
114     setContent(f, content, f.getTimeStamp() + TIMESTAMP_INCREMENT);
115   }
116
117   protected void setContent(VirtualFile f, String content, long timestamp) throws IOException {
118     f.setBinaryContent(content.getBytes(), -1, timestamp);
119   }
120
121   protected String createFileExternally(String name) throws IOException {
122     return createFileExternally(name, null);
123   }
124
125   protected String createFileExternally(String name, String content) throws IOException {
126     File f = new File(myRoot.getPath(), name);
127     f.getParentFile().mkdirs();
128     f.createNewFile();
129     if (content != null) FileUtil.writeToFile(f, content.getBytes());
130     return FileUtil.toSystemIndependentName(f.getPath());
131   }
132
133   protected String createDirectoryExternally(String name) throws IOException {
134     File f = new File(myRoot.getPath(), name);
135     f.mkdirs();
136     return FileUtil.toSystemIndependentName(f.getPath());
137   }
138
139   protected void setContentExternally(String path, String content) throws IOException {
140     File f = new File(path);
141     FileUtil.writeToFile(f, content.getBytes());
142     f.setLastModified(f.lastModified() + 2000);
143   }
144
145   protected void setDocumentTextFor(VirtualFile f, String text) {
146     FileDocumentManager.getInstance().getDocument(f).setText(text);
147   }
148
149   protected LocalHistoryFacade getVcs() {
150     return LocalHistoryImpl.getInstanceImpl().getFacade();
151   }
152
153   protected List<Revision> getRevisionsFor(VirtualFile f) {
154     return getRevisionsFor(f, null);
155   }
156
157   protected List<Revision> getRevisionsFor(VirtualFile f, String pattern) {
158     return LocalHistoryTestCase.collectRevisions(getVcs(), getRootEntry(), f.getPath(), myProject.getLocationHash(), pattern);
159   }
160
161   protected RootEntry getRootEntry() {
162     return myGateway.createTransientRootEntry();
163   }
164
165   protected void addContentRoot(String path) {
166     addContentRoot(myModule, path);
167   }
168
169   protected void addContentRoot(Module module, String path) {
170     ModuleRootManager rm = ModuleRootManager.getInstance(module);
171     ModifiableRootModel m = rm.getModifiableModel();
172     m.addContentEntry(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(path)));
173     m.commit();
174   }
175
176   protected void addExcludedDir(String path) {
177     ModuleRootManager rm = ModuleRootManager.getInstance(myModule);
178     ModifiableRootModel m = rm.getModifiableModel();
179     for (ContentEntry e : m.getContentEntries()) {
180       if (e.getFile() != myRoot) continue;
181       e.addExcludeFolder(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(path)));
182     }
183     m.commit();
184   }
185
186   protected void addFileListenerDuring(VirtualFileListener l, Runnable r) throws Exception {
187     VirtualFileManager.getInstance().addVirtualFileListener(l);
188     try {
189       r.run();
190     }
191     finally {
192       VirtualFileManager.getInstance().removeVirtualFileListener(l);
193     }
194   }
195
196
197   protected void assertContent(String expected, Entry e) {
198     assertEquals(expected, new String(e.getContent().getBytes()));
199   }
200
201   protected class ContentChangesListener extends VirtualFileAdapter {
202     private final VirtualFile myFile;
203     private final String[] myContents = new String[2];
204
205     public ContentChangesListener(VirtualFile f) {
206       myFile = f;
207     }
208
209     public String getContentBefore() {
210       return myContents[0];
211     }
212
213     public String getContentAfter() {
214       return myContents[1];
215     }
216
217     @Override
218     public void beforeContentsChange(VirtualFileEvent e) {
219       logContent(e, 0);
220     }
221
222     @Override
223     public void contentsChanged(VirtualFileEvent e) {
224       logContent(e, 1);
225     }
226
227     private void logContent(VirtualFileEvent e, int i) {
228       try {
229         if (!e.getFile().equals(myFile)) return;
230         myContents[i] = new String(myFile.contentsToByteArray());
231       }
232       catch (IOException ex) {
233         throw new RuntimeException(ex);
234       }
235     }
236   }
237 }