diff --git a/java/java-tests/testSrc/com/intellij/unscramble/NormalizeTextTest.java b/java/java-tests/testSrc/com/intellij/unscramble/NormalizeTextTest.java new file mode 100644 index 000000000000..e00b46d40241 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/unscramble/NormalizeTextTest.java @@ -0,0 +1,116 @@ +package com.intellij.unscramble; + +import junit.framework.TestCase; +import org.jetbrains.annotations.NonNls; + +/** + * @author cdr + */ +public class NormalizeTextTest extends TestCase { + public void testCausedBy() { + doTest("javax.faces.FacesException: Error calling action method of component with id _id6:_id10\n" + + " at java.lang.Th\n" + + "read.run(Thread.java:626)\n" + + "Caused by: javax.faces.el.EvaluationException: Exception while invoking expression #{_loginAction.login}\n" + + " at org.apache.myfaces.el.MethodBindingImpl.invoke(MethodBindingImpl.java:153)\n" + + " at org.apache.myfaces.application.ActionListenerImpl.processAction(ActionListenerImpl.java:63)\n", + + "javax.faces.FacesException: Error calling action method of component with id _id6:_id10\n" + + " at java.lang.Thread.run(Thread.java:626)\n" + + "Caused by: javax.faces.el.EvaluationException: Exception while invoking expression #{_loginAction.login}\n" + + " at org.apache.myfaces.el.MethodBindingImpl.invoke(MethodBindingImpl.java:153)\n" + + " at org.apache.myfaces.application.ActionListenerImpl.processAction(ActionListenerImpl.java:63)" + ); + } + + public void testThreadNames() { + doTest("\"Background process\" prio=6 tid=0x21193b88 nid=0x11ea4 waiting on condition [0x2\n" + "2cbf000..0x22cbfd68]\n" + + " at java.lang.Thread.sleep(Native Method)\n" + " at com.intellij.util.ui.Timer$1.run(Timer.java:23)\n" + "\n" + + "\"Alarm pool\" prio=6 tid=0x37cacbe0 nid=0x7940 waiting on condition [0x3972f000..\n" + "0x3972fae8]\n" + + " at sun.misc.Unsafe.park(Native Method)\n" + + " at java.util.concurrent.locks.LockSupport.park(LockSupport.java:118)\n" + + " at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject\n" + + ".await(AbstractQueuedSynchronizer.java:1767)\n\n" + + " at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.jav\n" + "a:359)\n" + + " at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.ja\n" + "va:470)\n" + + " at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor\n" + ".java:674)\n" + + " at java.lang.Thread.run(Thread.java:595)", + + + "\"Background process\" prio=6 tid=0x21193b88 nid=0x11ea4 waiting on condition [0x22cbf000..0x22cbfd68]\n" + + " at java.lang.Thread.sleep(Native Method)\n" + + " at com.intellij.util.ui.Timer$1.run(Timer.java:23)\n" + + "\n" + + "\"Alarm pool\" prio=6 tid=0x37cacbe0 nid=0x7940 waiting on condition [0x3972f000..0x3972fae8]\n" + + " at sun.misc.Unsafe.park(Native Method)\n" + + " at java.util.concurrent.locks.LockSupport.park(LockSupport.java:118)\n" + + " at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:1767)\n" + + " at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:359)\n" + + " at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:470)\n" + + " at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:674)\n" + + " at java.lang.Thread.run(Thread.java:595)" + ); + } + + public void testLocked() { + doTest(" at com.intellij.lang.jsp.JspFileViewProviderImpl.getKeyPrefixes(JspFileV\n" + "iewProviderImpl.java:76)\n" + + " at com.intellij.lang.jsp.JspFileViewProviderImpl.getKnownTaglibPrefixes(\n" + "JspFileViewProviderImpl.java:89)\n" + + " - locked <0x04cc0768> (a java.lang.Object)\n" + + " at com.intellij.psi.impl.source.parsing.jsp.JspLexer.doInitOriginal(JspL\n" + "exer.java:39)\n" + + " at com.intellij.psi.impl.source.parsing.jsp.JspLexer.start(JspLexer.java\n" + ":49)", + + " at com.intellij.lang.jsp.JspFileViewProviderImpl.getKeyPrefixes(JspFileViewProviderImpl.java:76)\n" + + " at com.intellij.lang.jsp.JspFileViewProviderImpl.getKnownTaglibPrefixes(JspFileViewProviderImpl.java:89)\n" + + " - locked <0x04cc0768> (a java.lang.Object)\n" + + " at com.intellij.psi.impl.source.parsing.jsp.JspLexer.doInitOriginal(JspLexer.java:39)\n" + + " at com.intellij.psi.impl.source.parsing.jsp.JspLexer.start(JspLexer.java:49)"); + } + public void testAtSplit() { + doTest("java.lang.Throwable\n" + + "at\n" + + "com.intellij.openapi.util.objectTree.ObjectNode.(ObjectNode.jav\n" + "a:31)\n" + + "at\n" + + "com.intellij.openapi.util.objectTree.ObjectTree.getNodeFor(ObjectTree\n" + ".java:79)", + + "java.lang.Throwable\n" + + "at com.intellij.openapi.util.objectTree.ObjectNode.(ObjectNode.java:31)\n" + + "at com.intellij.openapi.util.objectTree.ObjectTree.getNodeFor(ObjectTree.java:79)"); + } + + public void testSplitMergedLines() { + doTest("org.apache.velocity.exception.MethodInvocationException " + + "at org.apache.velocity.runtime.parser.node.ASTMethod.execute(ASTMethod.java:246) " + + "at org.apache.velocity.runtime.parser.node.ASTReference.execute(ASTReference.java:175) " + + "at org.apache.velocity.runtime.parser.node.ASTReference.value(ASTReference.java:327) " + + "at org.apache.velocity.runtime.parser.node.ASTExpression.value(ASTExpression.java:51) " + + "at org.apache.velocity.runtime.parser.node.ASTSetDirective.render(ASTSetDirective.java:95) " + + "at org.apache.velocity.runtime.parser.node.ASTBlock.render(ASTBlock.java:55) " + + "at org.apache.velocity.runtime.directive.Foreach.render(Foreach.java:166) " + + "at org.apache.velocity.runtime.parser.node.ASTDirective.render(ASTDirective.java:114) " + + "at org.apache.velocity.runtime.parser.node.SimpleNode.render(SimpleNode.java:230) " + + "at org.apache.velocity.runtime.directive.VelocimacroProxy.render(VelocimacroProxy.java:172) " + + "at org.apache.velocity.runtime.parser.node.ASTDirective.render(ASTDirective.java:114) " + + "at org.apache.velocity.runtime.parser.node.SimpleNode.render(SimpleNode.java:230) " + + "at org.apache.velocity.Template.merge(Template.java:256)", + + "org.apache.velocity.exception.MethodInvocationException\n" + + "at org.apache.velocity.runtime.parser.node.ASTMethod.execute(ASTMethod.java:246)\n" + + "at org.apache.velocity.runtime.parser.node.ASTReference.execute(ASTReference.java:175)\n" + + "at org.apache.velocity.runtime.parser.node.ASTReference.value(ASTReference.java:327)\n" + + "at org.apache.velocity.runtime.parser.node.ASTExpression.value(ASTExpression.java:51)\n" + + "at org.apache.velocity.runtime.parser.node.ASTSetDirective.render(ASTSetDirective.java:95)\n" + + "at org.apache.velocity.runtime.parser.node.ASTBlock.render(ASTBlock.java:55)\n" + + "at org.apache.velocity.runtime.directive.Foreach.render(Foreach.java:166)\n" + + "at org.apache.velocity.runtime.parser.node.ASTDirective.render(ASTDirective.java:114)\n" + + "at org.apache.velocity.runtime.parser.node.SimpleNode.render(SimpleNode.java:230)\n" + + "at org.apache.velocity.runtime.directive.VelocimacroProxy.render(VelocimacroProxy.java:172)\n" + + "at org.apache.velocity.runtime.parser.node.ASTDirective.render(ASTDirective.java:114)\n" + + "at org.apache.velocity.runtime.parser.node.SimpleNode.render(SimpleNode.java:230)\n" + + "at org.apache.velocity.Template.merge(Template.java:256)"); + } + + private static void doTest(@NonNls String stackTrace, @NonNls String expected) { + String normalized = UnscrambleDialog.normalizeText(stackTrace); + assertEquals(expected, normalized); + } +} diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/fileChooser/ex/FileChooserCompletionTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/fileChooser/ex/FileChooserCompletionTest.java new file mode 100644 index 000000000000..7ae1a97a7f6e --- /dev/null +++ b/platform/platform-tests/testSrc/com/intellij/openapi/fileChooser/ex/FileChooserCompletionTest.java @@ -0,0 +1,183 @@ +package com.intellij.openapi.fileChooser.ex; + +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.testFramework.FlyIdeaTestCase; +import com.intellij.util.ArrayUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.io.File; +import java.io.IOException; +import java.util.*; + +public class FileChooserCompletionTest extends FlyIdeaTestCase { + + private File myParent; + private LocalFsFinder myFinder; + + private final Map myMacros = new HashMap(); + private File myFolder11; + private File myFolder21; + + private void basicSetup() throws IOException { + myParent = getTempDir(); + + myFolder11 = new File(myParent, "folder1/folder11"); + assertTrue(myFolder11.mkdirs()); + assertTrue(new File(myParent, "a").mkdirs()); + myFolder21 = new File(myParent, "folder1/folder11/folder21"); + assertTrue(myFolder21.mkdirs()); + assertTrue(new File(myParent, "folder1/folder12").mkdirs()); + assertTrue(new File(myParent, "file1").mkdir()); + } + + public void testBasicComplete() throws Exception { + assertComplete("", ArrayUtil.EMPTY_STRING_ARRAY, null); + assertComplete("1", ArrayUtil.EMPTY_STRING_ARRAY, null); + + + basicSetup(); + + assertComplete("f", ArrayUtil.EMPTY_STRING_ARRAY, null); + + assertComplete("/", new String[] { + "a", + "folder1", + "file1" + }, "a"); + + assertComplete("/f", new String[] { + "folder1", + "file1" + }, "file1"); + + assertComplete("/fo", new String[] { + "folder1", + }, "folder1"); + + assertComplete("/folder", new String[] { + "folder1", + }, "folder1"); + + assertComplete("/folder1", new String[] { + "folder1", + }, "folder1"); + + assertComplete("/folder1/", new String[] { + "folder11", + "folder12", + }, "folder11"); + + assertComplete("/folder1/folder1", new String[] { + "folder11", + "folder12", + }, "folder11"); + + assertComplete("/foo", ArrayUtil.EMPTY_STRING_ARRAY, null); + + assertTrue(new File(myParent, "qw/child.txt").mkdirs()); + assertTrue(new File(myParent, "qwe").mkdir()); + assertComplete("/qw", new String[] { + "qw", + "qwe" + }, "qw"); + + assertComplete("/qw/", new String[] { + "child.txt" + }, "child.txt"); + } + + public void testComplete() throws Exception { + basicSetup(); + + myParent = null; + myMacros.put("$FOLDER_11$", myFolder11.getAbsolutePath()); + myMacros.put("$FOLDER_21$", myFolder21.getAbsolutePath()); + myMacros.put("$WHATEVER$", "/somepath"); + + assertComplete("$", new String[] {"$FOLDER_11$", "$FOLDER_21$"}, "$FOLDER_11$"); + } + + private void assertComplete(String typed, String[] expected, String preselected) { + myFinder = new LocalFsFinder() { + @Override + public LookupFile find(@NotNull final String path) { + final File ioFile = new File(path); + return ioFile.isAbsolute() ? new IoFile(ioFile) : null; + } + }; + + String typedText = typed.replace("/", myFinder.getSeparator()); + + final FileTextFieldImpl.CompletionResult result = new FileTextFieldImpl.CompletionResult(); + result.myCompletionBase = myParent != null ? (myParent.getAbsolutePath() + typedText) : typedText; + + new FileTextFieldImpl(new JTextField(), myFinder, new FileLookup.LookupFilter() { + @Override + public boolean isAccepted(final FileLookup.LookupFile file) { + return true; + } + }, myMacros, getRootDisposable()) { + @Override + @Nullable + public VirtualFile getSelectedFile() { + return null; + } + }.processCompletion(result); + + for (int i = 0; i < expected.length; i++) { + expected[i] = expected[i].replace("/", myFinder.getSeparator()); + } + + final List expectedList = Arrays.asList(expected); + + Collections.sort(result.myToComplete, new Comparator() { + @Override + public int compare(final FileLookup.LookupFile o1, final FileLookup.LookupFile o2) { + return o1.getName().compareTo(o2.getName()); + } + }); + Collections.sort(expectedList); + + assertEquals(asString(expectedList, result), asString(result.myToComplete, result)); + + final String preselectedText = preselected != null ? preselected.replace("/", myFinder.getSeparator()) : null; + assertEquals(preselectedText, toFileText(result.myPreselected, result)); + if (preselected != null) { + assertTrue(result.myToComplete.contains(result.myPreselected)); + } + } + + private String asString(List objects, FileTextFieldImpl.CompletionResult completion) { + StringBuffer result = new StringBuffer(); + for (int i = 0; i < objects.size(); i++) { + final Object each = objects.get(i); + result.append(toFileText(each, completion)); + if (i < objects.size() - 1) { + result.append("\n"); + } + } + + return result.toString(); + } + + private String toFileText(final Object each, final FileTextFieldImpl.CompletionResult completion) { + String text = null; + if (each instanceof FileLookup.LookupFile) { + final FileLookup.LookupFile file = (FileLookup.LookupFile)each; + if (file.getMacro() != null) { + text = file.getMacro(); + } else { + text = file.getName(); + } + } else if (each != null) { + text = each.toString(); + } + + if (text == null) return null; + + return (completion.myKidsAfterSeparator.contains(each) ? myFinder.getSeparator() : "" ) + text; + } + +} diff --git a/platform/platform-tests/testSrc/com/intellij/patterns/StandardPatternsTest.java b/platform/platform-tests/testSrc/com/intellij/patterns/StandardPatternsTest.java new file mode 100644 index 000000000000..1e05add24302 --- /dev/null +++ b/platform/platform-tests/testSrc/com/intellij/patterns/StandardPatternsTest.java @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. + */ +package com.intellij.patterns; + +import com.intellij.openapi.util.Key; +import com.intellij.testFramework.UsefulTestCase; +import com.intellij.util.ProcessingContext; + +import java.util.Arrays; + +import static com.intellij.patterns.StandardPatterns.*; + +/** + * @author peter + */ +public class StandardPatternsTest extends UsefulTestCase { + + public void testNull() throws Throwable { + assertTrue(object().isNull().accepts(null)); + assertFalse(object().isNull().accepts("")); + assertFalse(string().isNull().accepts("")); + assertTrue(string().isNull().accepts(null)); + } + + public void testString() throws Throwable { + final ElementPattern pattern = string(); + assertFalse(string().accepts(new Object())); + assertTrue(pattern.accepts("")); + } + + public void testStartsWith() throws Throwable { + final ElementPattern pattern = string().startsWith("abc"); + assertFalse(pattern.accepts("")); + assertTrue(pattern.accepts("abcd")); + assertTrue(pattern.accepts("abc")); + + assertFalse(string().startsWith("abc").accepts(new Object())); + } + + public void testEndsWith() throws Throwable { + final ElementPattern pattern = string().endsWith("abc"); + assertFalse(pattern.accepts("")); + assertFalse(pattern.accepts("abcd")); + assertTrue(pattern.accepts("abc")); + } + + private static void checkPrefixSuffix(final ElementPattern pattern) { + assertFalse(pattern.accepts("")); + assertFalse(pattern.accepts("abcd")); + assertTrue(pattern.accepts("abc")); + assertTrue(pattern.accepts("abcdabc")); + assertFalse(pattern.accepts("abcdab")); + } + + public void testPrefixSuffix() throws Throwable { + checkPrefixSuffix(string().endsWith("abc").startsWith("abc")); + } + + public void testAnd1() throws Throwable { + checkPrefixSuffix(and(string().endsWith("abc"), string().startsWith("abc"))); + } + + public void testAnd2() throws Throwable { + checkPrefixSuffix(string().endsWith("abc").and(string().startsWith("abc"))); + } + + public void testOr1() throws Throwable { + checkOr(or(string().endsWith("abc"), string().startsWith("abc"))); + } + + public void testNot1() throws Throwable { + final ElementPattern pattern = not(or(string().endsWith("abc"), string().startsWith("abc"))); + assertTrue(pattern.accepts("")); + assertTrue(pattern.accepts("xxx")); + assertFalse(pattern.accepts("abcd")); + assertTrue(pattern.accepts("dabcd")); + assertFalse(pattern.accepts("abc")); + assertFalse(pattern.accepts("abcdabc")); + assertFalse(pattern.accepts("abcdab")); + } + + private static void checkOr(final ElementPattern filterFactory) { + assertFalse(filterFactory.accepts("")); + assertFalse(filterFactory.accepts("xxx")); + assertTrue(filterFactory.accepts("abcd")); + assertFalse(filterFactory.accepts("dabcd")); + assertTrue(filterFactory.accepts("abc")); + assertTrue(filterFactory.accepts("abcdabc")); + assertTrue(filterFactory.accepts("abcdab")); + } + + public void testEquals() throws Throwable { + final Object foo = new Object(); + final Object bar = new Object(); + ElementPattern objectPattern = object().equalTo(foo); + assertTrue(objectPattern.accepts(foo)); + assertFalse(objectPattern.accepts(bar)); + + ElementPattern stringPattern = string().equalTo("foo"); + assertTrue(stringPattern.accepts("foo")); + assertFalse(stringPattern.accepts("bar")); + } + + + + public void testAll() throws Throwable { + ElementPattern pattern = collection(String.class).all(string().startsWith("abc")); + assertTrue(pattern.accepts(Arrays.asList("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "abcd"))); + assertFalse(pattern.accepts(Arrays.asList("abc", "bcd"))); + } + + public void testAtLeastOne() throws Throwable { + ElementPattern pattern = collection(String.class).atLeastOne(string().startsWith("abc")); + assertTrue(pattern.accepts(Arrays.asList("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "abcd"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "bcd"))); + assertFalse(pattern.accepts(Arrays.asList("bc", "bcd"))); + assertTrue(pattern.accepts(Arrays.asList("bc", "abc"))); + } + + public void testFilter() throws Throwable { + ElementPattern pattern = collection(String.class).filter(string().endsWith("x"), collection(String.class).all(string().startsWith("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "abcd"))); + assertFalse(pattern.accepts(Arrays.asList("bcx", "bcd"))); + assertTrue(pattern.accepts(Arrays.asList("abcx", "abc"))); + } + + public void testFirst() throws Throwable { + ElementPattern pattern = collection(String.class).first(string().startsWith("abc")); + assertFalse(pattern.accepts(Arrays.asList())); + assertTrue(pattern.accepts(Arrays.asList("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "abcd"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "bcd"))); + assertFalse(pattern.accepts(Arrays.asList("bc", "bcd"))); + assertFalse(pattern.accepts(Arrays.asList("bc", "abc"))); + } + + public void testLast() throws Throwable { + //collection(String.class) + + ElementPattern pattern = collection(String.class).last(string().startsWith("abc")); + assertFalse(pattern.accepts(Arrays.asList())); + assertTrue(pattern.accepts(Arrays.asList("abc"))); + assertTrue(pattern.accepts(Arrays.asList("abc", "abcd"))); + assertFalse(pattern.accepts(Arrays.asList("abc", "bcd"))); + assertFalse(pattern.accepts(Arrays.asList("bc", "bcd"))); + assertTrue(pattern.accepts(Arrays.asList("bc", "abc"))); + } + + public void testSize() throws Throwable { + final CollectionPattern filter = collection(String.class); + assertTrue(filter.size(0).accepts(Arrays.asList())); + assertFalse(filter.size(0).accepts(Arrays.asList("abc"))); + assertFalse(filter.size(0).accepts(Arrays.asList("abc", "abc"))); + + assertFalse(filter.size(1).accepts(Arrays.asList())); + assertTrue(filter.size(1).accepts(Arrays.asList("abc"))); + assertFalse(filter.size(1).accepts(Arrays.asList("abc", "abc"))); + + assertFalse(filter.size(2).accepts(Arrays.asList())); + assertFalse(filter.size(2).accepts(Arrays.asList("abc"))); + assertTrue(filter.size(2).accepts(Arrays.asList("abc", "abc"))); + } + + public void testEmpty() throws Throwable { + final CollectionPattern filter = collection(String.class); + assertTrue(filter.empty().accepts(Arrays.asList())); + assertFalse(filter.empty().accepts(Arrays.asList("abc"))); + assertFalse(filter.empty().accepts(Arrays.asList("abc", "abc"))); + + assertFalse(not(filter.empty()).accepts(Arrays.asList())); + assertTrue(not(filter.empty()).accepts(Arrays.asList("abc"))); + assertTrue(not(filter.empty()).accepts(Arrays.asList("abc", "abc"))); + } + + public void testSave() throws Throwable { + Key key = Key.create("abc"); + final ProcessingContext context = new ProcessingContext(); + assertFalse(string().contains("abc").save(key).accepts(null)); + assertNull(context.get(key)); + + assertFalse(string().contains("abc").save(key).accepts("def")); + assertNull(context.get(key)); + + final String s = "defabcdef"; + assertTrue(string().contains("abc").save(key).accepts(s, context)); + assertSame(s, context.get(key)); + } + + +} diff --git a/platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java b/platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java new file mode 100644 index 000000000000..8ba390ceee77 --- /dev/null +++ b/platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java @@ -0,0 +1,42 @@ +package com.intellij.psi; + +import junit.framework.TestCase; + +import java.util.Arrays; + +import com.intellij.psi.codeStyle.NameUtil; + +/** + * @author dsl + */ +public class PsiNameHelperTest extends TestCase { + public void testSplitIntoWords1() throws Exception { + assertSplitEquals(new String[]{"I", "Base"}, "IBase"); + } + + public void testSplitIntoWords2() throws Exception { + assertSplitEquals(new String[]{"Order", "Index"}, "OrderIndex"); + } + + public void testSplitIntoWords3() throws Exception { + assertSplitEquals(new String[]{"order", "Index"}, "orderIndex"); + } + + public void testSplitIntoWords4() throws Exception { + assertSplitEquals(new String[]{"Order", "Index"}, "Order_Index"); + } + + public void testSplitIntoWords5() throws Exception { + assertSplitEquals(new String[]{"ORDER", "INDEX"}, "ORDER_INDEX"); + } + + + public void testSplitIntoWords6() throws Exception { + assertSplitEquals(new String[]{"gg", "J"}, "ggJ"); + } + + private void assertSplitEquals(String[] expected, String name) { + final String[] result = NameUtil.splitNameIntoWords(name); + assertEquals(Arrays.asList(expected).toString(), Arrays.asList(result).toString()); + } +} diff --git a/platform/platform-tests/testSrc/com/intellij/ui/FileNameSplittingTest.java b/platform/platform-tests/testSrc/com/intellij/ui/FileNameSplittingTest.java new file mode 100644 index 000000000000..7ddf2bc6f856 --- /dev/null +++ b/platform/platform-tests/testSrc/com/intellij/ui/FileNameSplittingTest.java @@ -0,0 +1,122 @@ +package com.intellij.ui; + +import com.intellij.testFramework.PlatformTestUtil; +import com.intellij.util.ThrowableRunnable; +import com.intellij.util.ui.FilePathSplittingPolicy; +import junit.framework.TestCase; +import org.jetbrains.annotations.NonNls; + +import java.io.File; + +/** + * author: lesya + */ +public class FileNameSplittingTest extends TestCase { + private static final File FILE = new File("c:/dir1/dir2/dir3/dir4/file.txt"); + + private FilePathSplittingPolicy myPolicy; + + public void testSplitByLetter() { + myPolicy = FilePathSplittingPolicy.SPLIT_BY_LETTER; + @NonNls String[] expectedStrings = { + "t", + "xt", + "txt", + ".txt", + "e.txt", + "le.txt", + "ile.txt", + "file.txt", + ".file.txt", + "..file.txt", + "...file.txt", + "c...file.txt", + "c.../file.txt", + "c:.../file.txt", + "c:...4/file.txt", + "c:/...4/file.txt", + "c:/...r4/file.txt", + "c:/d...r4/file.txt", + "c:/d...ir4/file.txt", + "c:/di...ir4/file.txt", + "c:/di...dir4/file.txt", + "c:/dir...dir4/file.txt", + "c:/dir.../dir4/file.txt", + "c:/dir1.../dir4/file.txt", + "c:/dir1/...3/dir4/file.txt", + "c:/dir1/...r3/dir4/file.txt", + "c:/dir1/d...r3/dir4/file.txt", + "c:/dir1/d...ir3/dir4/file.txt", + "c:/dir1/di...ir3/dir4/file.txt", + "c:/dir1/dir2/dir3/dir4/file.txt" + }; + + for (String expectedString : expectedStrings) { + doTest(expectedString, expectedString.length()); + } + + } + + public void testSplitByFileSeparator(){ + myPolicy = FilePathSplittingPolicy.SPLIT_BY_SEPARATOR; + @NonNls String[] expectedStrings = { + "...", + "...", + "...", + "...", + "...", + "...", + "...", + "file.txt", + "file.txt", + "file.txt", + "...file.txt", + "...file.txt", + "c:...file.txt", + "c:.../file.txt", + "c:/.../file.txt", + "c:/.../file.txt", + "c:/.../file.txt", + "c:/.../file.txt", + "c:/...dir4/file.txt", + "c:/...dir4/file.txt", + "c:/...dir4/file.txt", + "c:/...dir4/file.txt", + "c:/dir1...dir4/file.txt", + "c:/dir1.../dir4/file.txt", + "c:/dir1/.../dir4/file.txt", + "c:/dir1/.../dir4/file.txt", + "c:/dir1/.../dir4/file.txt", + "c:/dir1/.../dir4/file.txt", + "c:/dir1/...dir3/dir4/file.txt", + "c:/dir1/...dir3/dir4/file.txt", + "c:/dir1/dir2/dir3/dir4/file.txt" + }; + for (int i = 0; i < expectedStrings.length; i++) { + int count = i + 1; + String expectedString = expectedStrings[i]; + assertTrue(expectedString, expectedString.length() <= count || i < 3); + doTest(expectedString, count); + } + + } + + public void testPerformance() { + myPolicy = FilePathSplittingPolicy.SPLIT_BY_SEPARATOR; + + PlatformTestUtil.startPerformanceTest("FileNameSplitting performance", 70, new ThrowableRunnable() { + @Override + public void run() throws Exception { + for (int i = 0; i < 100; i++) { + for (int j = 0; j < FILE.getPath().length(); j++) + myPolicy.getPresentableName(FILE, j); + } + } + }).cpuBound().assertTiming(); + } + + private void doTest(String expected, int count) { + assertEquals(expected.replace('/', File.separatorChar), + myPolicy.getPresentableName(FILE, count)); + } +}