001package daikon.test; 002 003import static org.junit.Assert.assertEquals; 004 005import daikon.PptName; 006import daikon.tools.jtb.*; 007import java.io.IOException; 008import java.io.InputStream; 009import java.io.UncheckedIOException; 010import java.util.ArrayList; 011import java.util.List; 012import jtb.*; 013import jtb.syntaxtree.*; 014import jtb.visitor.*; 015import junit.framework.*; 016import org.junit.Test; 017 018/** 019 * Tests functionality of some methods in daikon.tools.jtb.Ast. 020 * 021 * <p>TODO implement and test handling of "..." construct. 022 */ 023public final class TestAst { 024 025 public static class MethodDeclarationHarvester extends DepthFirstVisitor { 026 List<MethodDeclaration> decls = new ArrayList<>(); 027 028 @Override 029 public void visit(MethodDeclaration m) { 030 031 decls.add(m); 032 033 m.f0.accept(this); 034 m.f1.accept(this); 035 m.f2.accept(this); 036 m.f3.accept(this); 037 m.f4.accept(this); 038 } 039 } 040 041 public static class ClassOrInterfaceDeclarationHarvester extends DepthFirstVisitor { 042 List<ClassOrInterfaceDeclaration> decls = new ArrayList<>(); 043 044 @Override 045 public void visit(ClassOrInterfaceDeclaration m) { 046 decls.add(m); 047 m.f0.accept(this); 048 m.f1.accept(this); 049 m.f2.accept(this); 050 m.f3.accept(this); 051 m.f4.accept(this); 052 m.f5.accept(this); 053 } 054 } 055 056 private void checkMatch(String pptNameString, MethodDeclaration decl, PptNameMatcher matcher) { 057 058 PptName pptName = new PptName(pptNameString); 059 boolean result = matcher.matches(pptName, decl); 060 if (result == false) { 061 // Format so we can print an error message. 062 decl.accept(new TreeFormatter()); 063 String declString = Ast.format(decl); 064 throw new Error( 065 String.join( 066 System.lineSeparator(), 067 "pptName: " + pptName, 068 "doesn't match method declaration:", 069 "----------", 070 declString, 071 "----------")); 072 } 073 } 074 075 @Test 076 public void test_Ast_Ppt_Match() { 077 078 CompilationUnit compilationUnit; 079 080 // Parse the file "GenericTestClass.java" (under same dir as this class) 081 try (InputStream sourceIn = this.getClass().getResourceAsStream("GenericTestClass.java")) { 082 if (sourceIn == null) { 083 throw new Error("Couldn't find file GenericTestClass.java"); 084 } 085 JavaParser parser = new JavaParser(sourceIn); 086 087 try { 088 compilationUnit = parser.CompilationUnit(); 089 } catch (ParseException e) { 090 throw new Error(e); 091 } 092 } catch (IOException e) { 093 throw new UncheckedIOException(e); 094 } 095 096 // Test class declarations 097 098 // Pick off class declarations 099 ClassOrInterfaceDeclarationHarvester classDeclarationHarvester = 100 new ClassOrInterfaceDeclarationHarvester(); 101 102 compilationUnit.accept(classDeclarationHarvester); 103 List<ClassOrInterfaceDeclaration> classDecls = classDeclarationHarvester.decls; 104 105 { 106 String expected = "daikon.test.GenericTestClass"; 107 assertEquals(expected, Ast.getClassName(classDecls.get(0))); 108 } 109 // Illegal in Java 6 110 // { 111 // assertEquals("daikon.test.GenericTestClass.Simple", Ast.getClassName(classDecls.get(1))); 112 // } 113 114 // Test method declarations 115 116 // Pick off method declarations 117 MethodDeclarationHarvester methodDeclarationHarvester = new MethodDeclarationHarvester(); 118 119 compilationUnit.accept(methodDeclarationHarvester); 120 121 List<MethodDeclaration> methodDecls = methodDeclarationHarvester.decls; 122 123 PptNameMatcher matcher = new PptNameMatcher(compilationUnit); 124 125 MethodDeclaration decl; 126 127 decl = methodDecls.get(0); 128 assertEquals("foo1", decl.f2.f0.tokenImage); 129 checkMatch("daikon.test.GenericTestClass.foo1():::ENTER", decl, matcher); 130 checkMatch("daikon.test.GenericTestClass.foo1():::EXIT10", decl, matcher); 131 132 decl = methodDecls.get(1); 133 assertEquals("foo2", decl.f2.f0.tokenImage); 134 checkMatch("daikon.test.GenericTestClass.foo2():::ENTER", decl, matcher); 135 checkMatch("daikon.test.GenericTestClass.foo2():::EXIT12", decl, matcher); 136 137 decl = methodDecls.get(2); 138 assertEquals("foo3", decl.f2.f0.tokenImage); 139 checkMatch("daikon.test.GenericTestClass.foo3():::ENTER", decl, matcher); 140 checkMatch("daikon.test.GenericTestClass.foo3():::EXIT14", decl, matcher); 141 142 decl = methodDecls.get(3); 143 assertEquals("foo4", decl.f2.f0.tokenImage); 144 checkMatch("daikon.test.GenericTestClass.foo4():::ENTER", decl, matcher); 145 checkMatch("daikon.test.GenericTestClass.foo4():::EXIT16", decl, matcher); 146 147 decl = methodDecls.get(4); 148 assertEquals("foo5", decl.f2.f0.tokenImage); 149 checkMatch("daikon.test.GenericTestClass.foo5():::ENTER", decl, matcher); 150 checkMatch("daikon.test.GenericTestClass.foo5():::EXIT18", decl, matcher); 151 152 decl = methodDecls.get(5); 153 assertEquals("foo55", decl.f2.f0.tokenImage); 154 checkMatch("daikon.test.GenericTestClass.foo55():::ENTER", decl, matcher); 155 checkMatch("daikon.test.GenericTestClass.foo55():::EXIT20", decl, matcher); 156 157 decl = methodDecls.get(6); 158 assertEquals("foo6", decl.f2.f0.tokenImage); 159 checkMatch("daikon.test.GenericTestClass.foo6(java.util.List):::ENTER", decl, matcher); 160 checkMatch("daikon.test.GenericTestClass.foo6(java.util.List):::EXIT22", decl, matcher); 161 162 decl = methodDecls.get(7); 163 assertEquals("foo7", decl.f2.f0.tokenImage); 164 checkMatch("daikon.test.GenericTestClass.foo7(java.util.List):::ENTER", decl, matcher); 165 checkMatch("daikon.test.GenericTestClass.foo7(java.util.List):::EXIT24", decl, matcher); 166 167 decl = methodDecls.get(8); 168 assertEquals("foo8", decl.f2.f0.tokenImage); 169 checkMatch("daikon.test.GenericTestClass.foo8(java.lang.Object):::ENTER", decl, matcher); 170 checkMatch("daikon.test.GenericTestClass.foo8(java.lang.Object):::EXIT26", decl, matcher); 171 172 decl = methodDecls.get(9); 173 assertEquals("foo9", decl.f2.f0.tokenImage); 174 checkMatch("daikon.test.GenericTestClass.foo9(java.lang.String):::ENTER", decl, matcher); 175 checkMatch("daikon.test.GenericTestClass.foo9(java.lang.String):::EXIT28", decl, matcher); 176 177 decl = methodDecls.get(10); 178 assertEquals("foo10", decl.f2.f0.tokenImage); 179 checkMatch("daikon.test.GenericTestClass.foo10(java.lang.Object):::ENTER", decl, matcher); 180 checkMatch("daikon.test.GenericTestClass.foo10(java.lang.Object):::EXIT30", decl, matcher); 181 182 decl = methodDecls.get(11); 183 assertEquals("foo11", decl.f2.f0.tokenImage); 184 checkMatch( 185 "daikon.test.GenericTestClass.foo11(java.lang.Comparable, java.lang.Object):::ENTER", 186 decl, 187 matcher); 188 checkMatch( 189 "daikon.test.GenericTestClass.foo11(java.lang.Comparable, java.lang.Object):::EXIT32", 190 decl, 191 matcher); 192 193 decl = methodDecls.get(12); 194 assertEquals("foo115", decl.f2.f0.tokenImage); 195 checkMatch( 196 "daikon.test.GenericTestClass.foo115(java.lang.Comparable, java.lang.String):::ENTER", 197 decl, 198 matcher); 199 checkMatch( 200 "daikon.test.GenericTestClass.foo115(java.lang.Comparable, java.lang.String):::EXIT35", 201 decl, 202 matcher); 203 204 decl = methodDecls.get(13); 205 assertEquals("foo12", decl.f2.f0.tokenImage); 206 checkMatch( 207 "daikon.test.GenericTestClass.foo12(java.lang.Object, java.util.List):::ENTER", 208 decl, 209 matcher); 210 checkMatch( 211 "daikon.test.GenericTestClass.foo12(java.lang.Object, java.util.List):::EXIT37", 212 decl, 213 matcher); 214 215 decl = methodDecls.get(14); 216 assertEquals("foo13", decl.f2.f0.tokenImage); 217 checkMatch( 218 "daikon.test.GenericTestClass.foo13(java.lang.Object, java.util.List):::ENTER", 219 decl, 220 matcher); 221 checkMatch( 222 "daikon.test.GenericTestClass.foo13(java.lang.Object, java.util.List):::EXIT39", 223 decl, 224 matcher); 225 226 decl = methodDecls.get(15); 227 assertEquals("foo14", decl.f2.f0.tokenImage); 228 checkMatch("daikon.test.GenericTestClass.foo14(java.lang.Object):::ENTER", decl, matcher); 229 checkMatch("daikon.test.GenericTestClass.foo14(java.lang.Object):::EXIT41", decl, matcher); 230 231 decl = methodDecls.get(16); 232 assertEquals("foo15", decl.f2.f0.tokenImage); 233 checkMatch("daikon.test.GenericTestClass.foo15(java.lang.String):::ENTER", decl, matcher); 234 checkMatch("daikon.test.GenericTestClass.foo15(java.lang.String):::EXIT43", decl, matcher); 235 236 decl = methodDecls.get(17); 237 assertEquals("foo16", decl.f2.f0.tokenImage); 238 checkMatch("daikon.test.GenericTestClass.foo16(java.lang.Object):::ENTER", decl, matcher); 239 checkMatch("daikon.test.GenericTestClass.foo16(java.lang.Object):::EXIT45", decl, matcher); 240 241 decl = methodDecls.get(18); 242 assertEquals("foo17", decl.f2.f0.tokenImage); 243 checkMatch("daikon.test.GenericTestClass.foo17(java.lang.Object[]):::ENTER", decl, matcher); 244 checkMatch("daikon.test.GenericTestClass.foo17(java.lang.Object[]):::EXIT47", decl, matcher); 245 246 decl = methodDecls.get(19); 247 assertEquals("foo18", decl.f2.f0.tokenImage); 248 checkMatch("daikon.test.GenericTestClass.foo18(java.lang.Object[][]):::ENTER", decl, matcher); 249 checkMatch("daikon.test.GenericTestClass.foo18(java.lang.Object[][]):::EXIT49", decl, matcher); 250 251 decl = methodDecls.get(20); 252 assertEquals("foo19", decl.f2.f0.tokenImage); 253 checkMatch( 254 "daikon.test.GenericTestClass.foo19(java.lang.Comparable[], java.lang.Object[]):::ENTER", 255 decl, 256 matcher); 257 checkMatch( 258 "daikon.test.GenericTestClass.foo19(java.lang.Comparable[], java.lang.Object[]):::EXIT51", 259 decl, 260 matcher); 261 262 decl = methodDecls.get(21); 263 assertEquals("foo20", decl.f2.f0.tokenImage); 264 checkMatch( 265 "daikon.test.GenericTestClass.foo20" 266 + "(java.lang.Comparable[][][], java.lang.Object[][]):::ENTER", 267 decl, 268 matcher); 269 checkMatch( 270 "daikon.test.GenericTestClass.foo20" 271 + "(java.lang.Comparable[][][], java.lang.Object[][]):::EXIT53", 272 decl, 273 matcher); 274 275 // Illegal in Java 6 276 // 277 // decl = methodDecls.get(22); 278 // assertEquals("foo1", decl.f2.f0.tokenImage); 279 // checkMatch("daikon.test.GenericTestClass.Simple.foo1(java.util.Map.Entry):::ENTER", decl, 280 // matcher); 281 // checkMatch("daikon.test.GenericTestClass.Simple.foo1(java.util.Map.Entry):::EXIT12", decl, 282 // matcher); 283 // 284 // decl = methodDecls.get(23); 285 // assertEquals("foo2", decl.f2.f0.tokenImage); 286 // checkMatch("daikon.test.GenericTestClass.Simple.foo2(java.util.Map.Entry):::ENTER", decl, 287 // matcher); 288 // checkMatch("daikon.test.GenericTestClass.Simple.foo2(java.util.Map.Entry):::EXIT14", decl, 289 // matcher); 290 291 } 292}