Cleanup (warnings; formatting)
[idea/community.git] / platform / testFramework / src / com / intellij / testFramework / VfsTestUtil.java
1 /*
2  * Copyright 2000-2016 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 com.intellij.testFramework;
17
18 import com.intellij.openapi.application.AccessToken;
19 import com.intellij.openapi.application.ApplicationManager;
20 import com.intellij.openapi.application.WriteAction;
21 import com.intellij.openapi.util.Key;
22 import com.intellij.openapi.util.SystemInfo;
23 import com.intellij.openapi.util.io.FileUtil;
24 import com.intellij.openapi.util.text.StringUtil;
25 import com.intellij.openapi.vfs.LocalFileSystem;
26 import com.intellij.openapi.vfs.VfsUtil;
27 import com.intellij.openapi.vfs.VirtualFile;
28 import com.intellij.openapi.vfs.VirtualFileManager;
29 import com.intellij.openapi.vfs.newvfs.BulkFileListener;
30 import com.intellij.openapi.vfs.newvfs.events.*;
31 import com.intellij.util.PathUtil;
32 import com.intellij.util.messages.MessageBusConnection;
33 import com.intellij.util.text.StringTokenizer;
34 import org.jetbrains.annotations.NotNull;
35 import org.junit.Assert;
36
37 import java.io.File;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.List;
41 import java.util.stream.Collectors;
42
43 /**
44  * @author nik
45  */
46 public class VfsTestUtil {
47   public static final Key<String> TEST_DATA_FILE_PATH = Key.create("TEST_DATA_FILE_PATH");
48
49   private VfsTestUtil() { }
50
51   public static VirtualFile createFile(final VirtualFile root, final String relativePath) {
52     return createFile(root, relativePath, "");
53   }
54
55   public static VirtualFile createFile(final VirtualFile root, final String relativePath, final String text) {
56     return createFileOrDir(root, relativePath, text, false);
57   }
58
59   public static VirtualFile createDir(final VirtualFile root, final String relativePath) {
60     return createFileOrDir(root, relativePath, "", true);
61   }
62
63   private static VirtualFile createFileOrDir(final VirtualFile root,
64                                              final String relativePath,
65                                              final String text,
66                                              final boolean dir) {
67     try {
68       AccessToken token = WriteAction.start();
69       try {
70         VirtualFile parent = root;
71         Assert.assertNotNull(parent);
72         StringTokenizer parents = new StringTokenizer(PathUtil.getParentPath(relativePath), "/");
73         while (parents.hasMoreTokens()) {
74           final String name = parents.nextToken();
75           VirtualFile child = parent.findChild(name);
76           if (child == null || !child.isValid()) {
77             child = parent.createChildDirectory(VfsTestUtil.class, name);
78           }
79           parent = child;
80         }
81
82         VirtualFile file;
83         parent.getChildren();//need this to ensure that fileCreated event is fired
84         if (dir) {
85           file = parent.createChildDirectory(VfsTestUtil.class, PathUtil.getFileName(relativePath));
86         }
87         else {
88           file = parent.findFileByRelativePath(relativePath);
89           if (file == null) {
90             file = parent.createChildData(VfsTestUtil.class, PathUtil.getFileName(relativePath));
91           }
92           VfsUtil.saveText(file, text);
93         }
94         return file;
95       }
96       finally {
97         token.finish();
98       }
99     }
100     catch (IOException e) {
101       throw new RuntimeException(e);
102     }
103   }
104
105   public static void deleteFile(@NotNull VirtualFile file) {
106     UtilKt.deleteFile(file);
107   }
108
109   public static void clearContent(@NotNull final VirtualFile file) {
110     ApplicationManager.getApplication().runWriteAction(() -> {
111       try {
112         VfsUtil.saveText(file, "");
113       }
114       catch (IOException e) {
115         throw new RuntimeException(e);
116       }
117     });
118   }
119
120   @SuppressWarnings("UnusedDeclaration")
121   public static void overwriteTestData(String filePath, String actual) {
122     try {
123       FileUtil.writeToFile(new File(filePath), actual);
124     }
125     catch (IOException e) {
126       throw new AssertionError(e);
127     }
128   }
129
130   @NotNull
131   public static VirtualFile findFileByCaseSensitivePath(@NotNull String absolutePath) {
132     String vfsPath = FileUtil.toSystemIndependentName(absolutePath);
133     VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(vfsPath);
134     Assert.assertNotNull("file " + absolutePath + " not found", vFile);
135     String realVfsPath = vFile.getPath();
136     if (!SystemInfo.isFileSystemCaseSensitive && !vfsPath.equals(realVfsPath) &&
137         vfsPath.equalsIgnoreCase(realVfsPath)) {
138       Assert.fail("Please correct case-sensitivity of path to prevent test failure on case-sensitive file systems:\n" +
139                   "     path " + vfsPath + "\n" +
140                   "real path " + realVfsPath);
141     }
142     return vFile;
143   }
144
145   public static void assertFilePathEndsWithCaseSensitivePath(@NotNull VirtualFile file, @NotNull String suffixPath) {
146     String vfsSuffixPath = FileUtil.toSystemIndependentName(suffixPath);
147     String vfsPath = file.getPath();
148     if (!SystemInfo.isFileSystemCaseSensitive && !vfsPath.endsWith(vfsSuffixPath) &&
149         StringUtil.endsWithIgnoreCase(vfsPath, vfsSuffixPath)) {
150       String realSuffixPath = vfsPath.substring(vfsPath.length() - vfsSuffixPath.length());
151       Assert.fail("Please correct case-sensitivity of path to prevent test failure on case-sensitive file systems:\n" +
152                   "     path " + suffixPath + "\n" +
153                   "real path " + realSuffixPath);
154     }
155   }
156
157   @NotNull
158   public static List<VFileEvent> getEvents(@NotNull Runnable action) {
159     List<VFileEvent> allEvents = new ArrayList<>();
160
161     MessageBusConnection connection = ApplicationManager.getApplication().getMessageBus().connect();
162     connection.subscribe(VirtualFileManager.VFS_CHANGES, new BulkFileListener.Adapter() {
163       @Override
164       public void after(@NotNull List<? extends VFileEvent> events) {
165         allEvents.addAll(events);
166       }
167     });
168     try {
169       action.run();
170     }
171     finally {
172       connection.disconnect();
173     }
174
175     return allEvents;
176   }
177
178   @NotNull
179   public static List<String> print(@NotNull List<? extends VFileEvent> events) {
180     return events.stream().map(VfsTestUtil::print).collect(Collectors.toList());
181   }
182
183   private static String print(VFileEvent e) {
184     char type = '?';
185     if (e instanceof VFileCreateEvent) type = 'C';
186     else if (e instanceof VFileDeleteEvent) type = 'D';
187     else if (e instanceof VFileContentChangeEvent) type = 'U';
188     else if (e instanceof VFilePropertyChangeEvent) type = 'P';
189     return type + " : " + e.getPath();
190   }
191 }