001 package org.hackystat.sensorbase.uripattern; 002 003 import static org.junit.Assert.assertEquals; 004 import static org.junit.Assert.assertFalse; 005 import static org.junit.Assert.assertNotSame; 006 import static org.junit.Assert.assertTrue; 007 008 import org.junit.Test; 009 010 011 /** 012 * Test suite for UriPatterns. 013 * 014 * @author Philip Johnson, (Cedric) Qin Zhang 015 */ 016 public class TestUriPattern { 017 018 private String class1 = "file://C:/dir/Class1.java"; 019 private String starStarJava = "**/*.java"; 020 private String beanShell = "/home/jira/beanshell"; 021 022 023 /** 024 * Tests match of compound pattern. 025 */ 026 @Test 027 public void testCompoundPattern() { 028 UriPattern p = new UriPattern("(**) - (file://**/Test*)"); 029 assertTrue("01", p.matches("file://C:/Class1.java")); 030 assertFalse("02", p.matches("file://C:/dir/TestClass1.java")); 031 032 p = new UriPattern(" (**) -(**/Test*) "); 033 assertTrue("03", p.matches(class1)); 034 assertFalse("04", p.matches("file://C:/dir/TestClass1.java")); 035 036 p = new UriPattern(" (**/*.java) + (**/*.c) "); 037 assertTrue("05", p.matches(class1)); 038 assertTrue("06", p.matches("file://C:/dir/Class1.c")); 039 assertFalse("07", p.matches("file://C:/dir/Class1.perl")); 040 041 p = new UriPattern(" (**/*.java) + (**/*.c) - (**/Test*.java)"); 042 assertTrue("08", p.matches(class1)); 043 assertTrue("09", p.matches("file://C:/dir/Class1.c")); 044 assertFalse("10", p.matches("file://C:/dir/Class1.perl")); 045 assertFalse("11", p.matches("file://C:/dir/TestClass1.java")); 046 047 p = new UriPattern(" (**) - (**/*.c) - (**/*.java)"); 048 assertFalse("12", p.matches(class1)); 049 assertFalse("13", p.matches("file://C:/dir/Class1.c")); 050 assertTrue("14", p.matches("file://C:/dir/Class1.perl")); 051 } 052 053 054 055 /** 056 * Test case for other functions in the class. 057 */ 058 @Test 059 public void testOthers() { 060 UriPattern pattern1a = new UriPattern(starStarJava); 061 UriPattern pattern1b = new UriPattern(starStarJava); 062 063 UriPattern pattern0 = new UriPattern("*.c"); 064 065 assertEquals("15", pattern1a, pattern1b); 066 assertFalse("16", pattern1a.equals(pattern0)); 067 assertFalse("17", pattern1b.equals(pattern0)); 068 069 assertEquals("18", pattern1a.hashCode(), pattern1b.hashCode()); 070 071 assertEquals("19", pattern1a.compareTo(pattern1b), 0); 072 assertNotSame("20", pattern1a.compareTo(pattern0), 0); 073 assertNotSame("21", pattern1b.compareTo(pattern0), 0); 074 075 assertEquals("22", new UriPattern("**"), new UriPattern(null)); 076 } 077 078 /** 079 * Tests matching of file names starting with backslash. 080 */ 081 @Test 082 public void testIakyzoIssueData() { 083 UriPattern p = new UriPattern("/home/**"); 084 assertTrue("23", p.matches(beanShell)); 085 p = new UriPattern("/**/jira/**"); 086 assertTrue("24", p.matches(beanShell)); 087 //This is where things fails in PatternMatcherImpl, fix it in PatternMatcher. 088 p = new UriPattern("**"); 089 assertTrue("25", p.matches(beanShell)); 090 p = new UriPattern("**/jira/**"); 091 assertTrue("26", p.matches(beanShell)); 092 } 093 094 /** 095 * Tests equals operation. 096 */ 097 @Test 098 public void testEquals() { 099 UriPattern p1 = new UriPattern(starStarJava); 100 UriPattern p2 = new UriPattern(starStarJava); 101 assertEquals("27", p1, p2); 102 assertEquals("28", 0, p1.compareTo(p2)); 103 assertEquals("29", 0, p2.compareTo(p1)); 104 assertEquals("30", p1.hashCode(), p2.hashCode()); 105 106 p1 = new UriPattern("**"); 107 p2 = new UriPattern(null); 108 assertEquals("31", p1, p2); 109 assertEquals("32", 0, p1.compareTo(p2)); 110 assertEquals("33", 0, p2.compareTo(p1)); 111 assertEquals("34", p1.hashCode(), p2.hashCode()); 112 113 p1 = new UriPattern("dir1/dir2/File.java"); 114 p2 = new UriPattern("dir1/dir2/File.java"); 115 assertEquals("35", p1, p2); 116 assertEquals("36", 0, p1.compareTo(p2)); 117 assertEquals("37", 0, p2.compareTo(p1)); 118 assertEquals("38", p1.hashCode(), p2.hashCode()); 119 } 120 121 /** 122 * Tests equals(), comparesTo(), and hashCode() implementation. 123 */ 124 @Test 125 public void testEqualsAndComparison() { 126 String[] patterns = new String[]{ 127 starStarJava, starStarJava, 128 "**", 129 starStarJava, "/home/A.java", starStarJava, "A.java" 130 }; 131 for (int i = 0; i < patterns.length; i++) { 132 for (int j = 0; j < patterns.length; j++) { 133 String s1 = patterns[i]; 134 String s2 = patterns[j]; 135 UriPattern p1 = new UriPattern(s1); 136 UriPattern p2 = new UriPattern(s2); 137 //System.out.println(s1 + ", " + s2); 138 //test equals 139 if (s1.equals(s2)) { 140 assertEquals("39", p1, p2); 141 assertEquals("40", p2, p1); 142 assertEquals("41", p1.hashCode(), p2.hashCode()); 143 assertEquals("42", 0, p1.compareTo(p2)); 144 assertEquals("43", 0, p2.compareTo(p1)); 145 } 146 //test comparesTo 147 int result = p1.compareTo(p2); 148 if (result == 0) { 149 assertEquals("44", p1, p2); 150 assertEquals("45", p2, p1); 151 assertEquals("46", 0, p2.compareTo(p1)); 152 assertEquals("47", p1.hashCode(), p2.hashCode()); 153 } 154 else if (result > 0) { 155 assertFalse("48", p1.equals(p2)); 156 assertFalse("49", p2.equals(p1)); 157 assertTrue("50", p2.compareTo(p1) < 0); 158 } 159 else { 160 assertFalse("51", p1.equals(p2)); 161 assertFalse("52", p2.equals(p1)); 162 assertTrue("53", p2.compareTo(p1) > 0); 163 } 164 } 165 } 166 } 167 168 /** 169 * Tests the optimized match() method for workspaces that detects "top-level" UriPatterns 170 * and determines whether they match the workspace or not without going to the underlying 171 * Ant-based parser. This results in significantly improved performance in certain 172 * DailyProjectData subclasses such as DailyProjectFileMetric. 173 */ 174 @Test 175 public void testWorkspaceOptimizationHack() { 176 UriPattern UriPattern1 = new UriPattern("hackyFoo/**"); 177 UriPattern UriPattern2 = new UriPattern("/foo/**"); 178 UriPattern UriPattern3 = new UriPattern("hackyFoo/**/foo.java"); 179 UriPattern UriPattern4 = new UriPattern("*/**"); 180 UriPattern UriPattern5 = new UriPattern("**"); 181 assertTrue("Testing isTopLevel hackyFoo/**", UriPattern1.isTopLevel()); 182 assertTrue("Testing isTopLevel /foo/**", UriPattern2.isTopLevel()); 183 assertFalse("Testing isTopLevel hackyFoo/foo", UriPattern3.isTopLevel()); 184 assertFalse("Testing isTopLevel */**", UriPattern4.isTopLevel()); 185 assertFalse("Testing isTopLevel **", UriPattern5.isTopLevel()); 186 187 // Check that our top-level UriPattern does the right thing. 188 assertTrue("Testing matches2() 1", UriPattern1.matches("hackyFoo/bar/baz")); 189 assertTrue("Testing matches2() 2", UriPattern1.matches("hackyFoo/bar/baz")); 190 assertTrue("Testing matches2() 3", UriPattern1.matches("hackyFoo")); 191 assertFalse("Testing ~matches2() 4", UriPattern1.matches("hackyFood/bar/baz")); 192 assertFalse("Testing ~matches2() 5", UriPattern1.matches("hacky")); 193 assertFalse("Testing ~matches2() 6", UriPattern1.matches("bar")); 194 195 // Now check that a non-top-level UriPattern also does the right thing. 196 assertTrue("Testing matches2() 6", UriPattern2.matches("/foo")); 197 assertTrue("Testing matches2() 7", UriPattern3.matches("hackyFoo/bar/foo.java")); 198 UriPattern UriPattern6 = new UriPattern("hackyApp_TelemetryControlCenter/**"); 199 assertFalse("Testing field error", 200 UriPattern6.matches("hackySdt_Cli/src/overview.html/")); 201 } 202 }