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    }