| package com.google.gwt.dev.jjs.impl.gflow.cfg; |
| |
| import com.google.gwt.core.ext.UnableToCompleteException; |
| import com.google.gwt.dev.jjs.ast.JMethodBody; |
| import com.google.gwt.dev.jjs.ast.JProgram; |
| import com.google.gwt.dev.jjs.impl.JJSTestBase; |
| import com.google.gwt.dev.jjs.impl.gflow.cfg.CfgBuilder; |
| import com.google.gwt.dev.jjs.impl.gflow.cfg.CfgEdge; |
| import com.google.gwt.dev.jjs.impl.gflow.cfg.Cfg; |
| import com.google.gwt.dev.jjs.impl.gflow.cfg.CfgNode; |
| import com.google.gwt.dev.util.Strings; |
| |
| import java.util.List; |
| |
| /** |
| * Test class for CfgBuilfer. |
| */ |
| public class CfgBuilderTest extends JJSTestBase { |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| addSnippetClassDecl("static boolean b;"); |
| addSnippetClassDecl("static boolean b1;"); |
| addSnippetClassDecl("static boolean b2;"); |
| addSnippetClassDecl("static boolean b3;"); |
| addSnippetClassDecl("static int i;"); |
| addSnippetClassDecl("static int j;"); |
| addSnippetClassDecl("static int k;"); |
| addSnippetClassDecl("static int l;"); |
| addSnippetClassDecl("static int m;"); |
| addSnippetClassDecl("static class CheckedException extends Exception {}"); |
| addSnippetClassDecl( |
| "static class UncheckedException1 extends RuntimeException {}"); |
| addSnippetClassDecl( |
| "static class UncheckedException2 extends RuntimeException {}"); |
| addSnippetClassDecl("static RuntimeException runtimeException;"); |
| addSnippetClassDecl("static CheckedException checkedException;"); |
| addSnippetClassDecl("static UncheckedException1 uncheckedException1;"); |
| addSnippetClassDecl("static UncheckedException2 uncheckedException2;"); |
| |
| addSnippetClassDecl("static int[] ii;"); |
| addSnippetClassDecl("static int[] jj;"); |
| |
| addSnippetClassDecl("static void throwCheckedException() " + |
| "throws CheckedException {}"); |
| addSnippetClassDecl("static void throwUncheckedException() {}"); |
| addSnippetClassDecl("static void throwSeveralExceptions() " + |
| "throws CheckedException, UncheckedException1 {}"); |
| |
| addSnippetClassDecl("static class Foo { int i; int j; int k; }"); |
| addSnippetClassDecl("static Foo createFoo() {return null;}"); |
| } |
| |
| public void testConstantAssignment() throws Exception { |
| assertCfg("void", "i = 1;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "END"); |
| } |
| |
| public void testReferenceAssignment() throws Exception { |
| assertCfg("void", "i = j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(i, EntryPoint.j) -> [*]", |
| "END"); |
| } |
| |
| public void testModAssignment() throws Exception { |
| assertCfg("void", "i += 1;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "END"); |
| } |
| |
| public void testDeclarationWithInitializer() throws Exception { |
| assertCfg("void", "int i = 1;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "END"); |
| } |
| |
| public void testDeclarationWithInitializerRead() throws Exception { |
| assertCfg("void", "int i = j + k;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "READ(k) -> [*]", |
| "WRITE(i, EntryPoint.j + EntryPoint.k) -> [*]", |
| "END"); |
| } |
| |
| public void testDeclarationWithoutInitializer() throws Exception { |
| assertCfg("void", "int i;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "END"); |
| } |
| |
| public void testBinopAssignment() throws Exception { |
| assertCfg("void", "i = j + k;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "READ(k) -> [*]", |
| "WRITE(i, EntryPoint.j + EntryPoint.k) -> [*]", |
| "END"); |
| } |
| |
| public void testPostIncrement() throws Exception { |
| assertCfg("void", "i++;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "END"); |
| } |
| |
| public void testPreIncrement() throws Exception { |
| assertCfg("void", "++i;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "END"); |
| } |
| |
| public void testConditional() throws Exception { |
| assertCfg("void", "i = b1 ? j : k;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "READ(j) -> [2]", |
| "1: READ(k) -> [*]", |
| "2: WRITE(i, EntryPoint.b1 ? EntryPoint.j : EntryPoint.k) -> [*]", |
| "END"); |
| } |
| |
| public void testAnd() throws Exception { |
| assertCfg("void", "b3 = b1 && b2;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "READ(b2) -> [*]", |
| "1: WRITE(b3, EntryPoint.b1 && EntryPoint.b2) -> [*]", |
| "END"); |
| } |
| |
| public void testOr() throws Exception { |
| assertCfg("void", "b3 = b1 || b2;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [ELSE=*, THEN=1]", |
| "READ(b2) -> [*]", |
| "1: WRITE(b3, EntryPoint.b1 || EntryPoint.b2) -> [*]", |
| "END"); |
| } |
| |
| public void testMultipleExpressionStatements() throws Exception { |
| assertCfg("void", |
| "i = 1;", |
| "j = 2;", |
| "m = k = j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(k, EntryPoint.j) -> [*]", |
| "WRITE(m, EntryPoint.k = EntryPoint.j) -> [*]", |
| "END"); |
| } |
| |
| public void testIfStatement1() throws Exception { |
| assertCfg("void", |
| "if (i == 1) {", |
| " j = 2;", |
| "}", |
| "k = j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "1: STMT -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(k, EntryPoint.j) -> [*]", |
| "END"); |
| } |
| |
| public void testIfStatement2() throws Exception { |
| assertCfg("void", |
| "if ((i = 1) == 2) {", |
| " j = 2;", |
| "} else {", |
| " k = j;", |
| "}").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "COND ((EntryPoint.i = 1) == 2) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [2]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(k, EntryPoint.j) -> [*]", |
| "2: END"); |
| } |
| |
| public void testIfStatement3() throws Exception { |
| assertCfg("void", "if (b1 || b2) {j = 2;}").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [ELSE=*, THEN=1]", |
| "READ(b2) -> [*]", |
| "1: COND (EntryPoint.b1 || EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "2: END"); |
| } |
| |
| public void testWhileStatement() throws Exception { |
| assertCfg("void", "while (i == 1) {j = 2;} k = j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [1]", |
| "2: STMT -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(k, EntryPoint.j) -> [*]", |
| "END"); |
| } |
| |
| public void testDoStatement() throws Exception { |
| assertCfg("void", "do { j = 2; } while (i == 1);").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=1, ELSE=*]", |
| "END"); |
| } |
| |
| public void testDoStatementBreakNoLabel() throws Exception { |
| assertCfg("void", "do { if (b1) { break; } else { do { j = 2; } while (b2); } } while (i == 1);").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=3, ELSE=*]", |
| "READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=1, ELSE=*]", |
| "4: END"); |
| } |
| |
| public void testDoStatementContinueNoLabel() throws Exception { |
| assertCfg("void", "do { if (b1) { continue; } else { do { j = 2; } while (b2); } } while (i == 1);").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [1]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=3, ELSE=*]", |
| "READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=1, ELSE=*]", |
| "END"); |
| } |
| |
| public void testReturn1() throws Exception { |
| assertCfg("void", "return;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testReturn2() throws Exception { |
| assertCfg("boolean", "i = 1; return i == 2;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testReturn3() throws Exception { |
| assertCfg("boolean", |
| "i = 1;", |
| "if (i == 1) {", |
| " i = 2;", |
| " return true;", |
| "} else {", |
| " i = 3;", |
| " return false;", |
| "}").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 2) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 3) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "2: END"); |
| } |
| |
| public void testForStatement() throws Exception { |
| assertCfg("int", |
| "int j = 0;", |
| "for (int i = 0; i < 10; ++i) { j++; }", |
| "return j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 0) -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 0) -> [*]", |
| "1: READ(i) -> [*]", |
| "COND (i < 10) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "2: STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testEmptyForStatement() throws Exception { |
| assertCfg("void", |
| "for (;;) { j++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [1]", |
| "END"); |
| } |
| |
| public void testThrowWithoutCatch1() throws Exception { |
| assertCfg("void", "throw runtimeException;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(runtimeException) -> [*]", |
| "THROW -> [*]", |
| "END"); |
| } |
| |
| public void testThrowWithoutCatch2() throws Exception { |
| assertCfg("void", "if (b1) { throw runtimeException; } b1 = true;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(runtimeException) -> [*]", |
| "THROW -> [2]", |
| "1: STMT -> [*]", |
| "WRITE(b1, true) -> [*]", |
| "2: END" |
| ); |
| } |
| |
| public void testWhileContinueNoLabel() throws Exception { |
| assertCfg("void", "while (b1) { if (b2) { continue; } i++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [1]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "3: END"); |
| } |
| |
| public void testWhileContinueWithLabel1() throws Exception { |
| assertCfg("void", |
| "nextLoop: while(b3)", |
| " while (b1) {", |
| " if (b2) { continue; }", |
| " i++;" + |
| " }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b3) -> [*]", |
| "COND (EntryPoint.b3) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "2: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "3: STMT -> [*]", |
| "READWRITE(i, null) -> [2]", |
| "4: END"); |
| } |
| |
| |
| public void testWhileContinueWithLabel2() throws Exception { |
| assertCfg("void", |
| "nextLoop: while(b3)", |
| " while (b1) {", |
| " if (b2) { continue nextLoop; }", |
| " i++;", |
| " }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b3) -> [*]", |
| "COND (EntryPoint.b3) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "2: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [1]", |
| "3: STMT -> [*]", |
| "READWRITE(i, null) -> [2]", |
| "4: END"); |
| } |
| |
| public void testWhileContinueWithLabel3() throws Exception { |
| assertCfg("void", |
| "nextLoop: while (b1) {", |
| " if (b2) { continue; }", |
| " i++;", |
| "}").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [1]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "3: END"); |
| } |
| |
| public void testWhileBreakNoLabel() throws Exception { |
| assertCfg("void", "while (b1) { if (b2) { break; } i++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "3: END"); |
| } |
| |
| public void testWhileBreakNoLabel2() throws Exception { |
| assertCfg("void", "while (b1) { if (b2) { break; } else { while (i < 10) { i++; } } }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=4]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "3: READ(i) -> [*]", |
| "COND (EntryPoint.i < 10) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [3]", |
| "4: END"); |
| } |
| |
| public void testWhileBreakWithLabel1() throws Exception { |
| assertCfg("void", |
| "nextLoop: while(b3)", |
| " while (b1) {", |
| " if (b2) { break; }", |
| " i++;", |
| " }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b3) -> [*]", |
| "COND (EntryPoint.b3) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "2: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [1]", |
| "3: STMT -> [*]", |
| "READWRITE(i, null) -> [2]", |
| "4: END"); |
| } |
| |
| public void testWhileBreakWithLabel2() throws Exception { |
| assertCfg("void", |
| "nextLoop: while(b3)", |
| " while (b1) {", |
| " if (b2) { break nextLoop; }", |
| " i++;", |
| " }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b3) -> [*]", |
| "COND (EntryPoint.b3) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "2: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [4]", |
| "3: STMT -> [*]", |
| "READWRITE(i, null) -> [2]", |
| "4: END"); |
| } |
| |
| public void testWhileBreakWithLabel3() throws Exception { |
| assertCfg("void", |
| "nextLoop: while (b1) { if (b2) { break; } i++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b1) -> [*]", |
| "COND (EntryPoint.b1) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "3: END"); |
| } |
| |
| public void testForBreakNoLabel() throws Exception { |
| assertCfg("void", |
| "for(int i = 0; i < 10; i++) { if (b2) { break; } i++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 0) -> [*]", |
| "1: READ(i) -> [*]", |
| "COND (i < 10) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "3: END"); |
| } |
| |
| public void testForContinueNoLabel() throws Exception { |
| assertCfg("void", |
| "for(int i = 0; i < 10; i++) { if (b2) { continue; } i++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 0) -> [*]", |
| "1: READ(i) -> [*]", |
| "COND (i < 10) -> [THEN=*, ELSE=4]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "2: STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "4: END"); |
| } |
| |
| public void testForBreakNestedForWithLabel() throws Exception { |
| assertCfg("int", |
| "int j = 0; a: for(; ; ) { if (b2) { break a; } else { for (int i = 0; i < 1; i++) { j = i; } } } return j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 0) -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 0) -> [*]", |
| "3: READ(i) -> [*]", |
| "COND (i < 1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "WRITE(j, i) -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [3]", |
| "4: STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testForBreakNestedForNoLabel() throws Exception { |
| assertCfg("int", |
| "int j = 0; for(; ; ) { if (b2) { break; } else { for (int i = 0; i < 1; i++) { j = i; } } } return j;").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 0) -> [*]", |
| "STMT -> [*]", |
| "1: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b2) -> [*]", |
| "COND (EntryPoint.b2) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 0) -> [*]", |
| "3: READ(i) -> [*]", |
| "COND (i < 1) -> [THEN=*, ELSE=1]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "WRITE(j, i) -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [3]", |
| "4: STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testCatchThrowException1() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw checkedException;", |
| " k++;", |
| "} catch (CheckedException e) {", |
| " i++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(checkedException) -> [*]", |
| "THROW -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testCatchThrowUncatchedException() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw uncheckedException2;", |
| " k++;", |
| "} catch (UncheckedException1 e) {", |
| " i++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(uncheckedException2) -> [*]", |
| "THROW -> [3]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "2: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "3: END" |
| ); |
| } |
| |
| public void testCatchThrowSupertype() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw runtimeException;", |
| " k++;", |
| "} catch (UncheckedException1 e) {", |
| " i++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(runtimeException) -> [*]", |
| "THROW -> [2, 4]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "4: END" |
| ); |
| } |
| |
| public void testCatchSupertype() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw uncheckedException1;", |
| " k++;", |
| "} catch (RuntimeException e) {", |
| " i++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(uncheckedException1) -> [*]", |
| "THROW -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testCatchReturn() throws Exception { |
| assertCfg("void", |
| "try { try {", |
| " if (b) return;", |
| " k++;", |
| "} catch (RuntimeException e) {", |
| " i++;", |
| "} } catch (UncheckedException1 e) { j++; }").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "2: END" |
| ); |
| } |
| |
| public void testRethrow() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw uncheckedException1;", |
| " k++;", |
| "} catch (UncheckedException1 e) {", |
| " i++;", |
| " throw e;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(uncheckedException1) -> [*]", |
| "THROW -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "STMT -> [*]", |
| "READ(e) -> [*]", |
| "THROW -> [4]", |
| "3: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "4: END" |
| ); |
| } |
| |
| public void testCatchMethodCall1() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throwCheckedException();", |
| " k++;", |
| "} catch (CheckedException e) {", |
| " i++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "OPTTHROW(throwCheckedException()) -> [NOTHROW=*, 2, RE=4, E=4]", |
| "CALL(throwCheckedException) -> [*]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "4: END" |
| ); |
| } |
| |
| public void testCatchMethodCall2() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throwCheckedException();", |
| " k++;", |
| "} catch (CheckedException e) {", |
| " i++;", |
| "} catch (RuntimeException e) {", |
| " l++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "OPTTHROW(throwCheckedException()) -> [NOTHROW=*, 2, RE=3, E=5]", |
| "CALL(throwCheckedException) -> [*]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [4]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(l, null) -> [*]", |
| "4: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "5: END" |
| ); |
| } |
| |
| public void testCatchMethodCallUnchecked() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throwUncheckedException();", |
| " k++;", |
| "} catch (UncheckedException1 e) {", |
| " i++;", |
| "} catch (RuntimeException e) {", |
| " l++;", |
| "}", |
| "j++;").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "OPTTHROW(throwUncheckedException()) -> [NOTHROW=*, RE=2, RE=3, E=5]", |
| "CALL(throwUncheckedException) -> [*]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [4]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [4]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(l, null) -> [*]", |
| "4: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "5: END" |
| ); |
| } |
| |
| public void testFinallyReturn1() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) return;", |
| " j++;", |
| "} finally {", |
| " i++;", |
| "}").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*, *]", |
| "END" |
| ); |
| } |
| |
| public void testThrowFromFinally() throws Exception { |
| assertCfg("void", |
| "try {", |
| " return;", |
| "} finally {", |
| " throw runtimeException;", |
| "}").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(runtimeException) -> [*]", |
| "THROW -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testFinallyReturn2() throws Exception { |
| assertCfg("void", |
| "try {", |
| " return;", |
| "} finally {", |
| " i++;", |
| "}").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*, *]", |
| "END" |
| ); |
| } |
| |
| public void testFinallyReturn3() throws Exception { |
| assertCfg("void", |
| "try {", |
| "try {", |
| " if (b) return;", |
| " k++;", |
| "} finally {", |
| " i++;", |
| "} m++; } finally {", |
| " j++;", |
| "}").is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [*]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*, 3]", |
| "STMT -> [*]", |
| "READWRITE(m, null) -> [*]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [*, *]", |
| "END" |
| ); |
| } |
| |
| |
| public void testFinallyContinue() throws Exception { |
| assertCfg("void", |
| "while (b) {", |
| "try {", |
| " if (b) continue;", |
| "} finally {", |
| " i++;", |
| "} j++; }").is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=3]", |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=2]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*, 1]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [1]", |
| "3: END" |
| ); |
| } |
| |
| public void testCatchFinally() throws Exception { |
| assertCfg("void", |
| "try {", |
| " if (b) throw checkedException;", |
| " k++;", |
| "} catch (CheckedException e) {", |
| " i++;", |
| "} finally {", |
| " j++;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "TRY -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "READ(checkedException) -> [*]", |
| "THROW -> [2]", |
| "1: STMT -> [*]", |
| "READWRITE(k, null) -> [3]", |
| "2: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "3: BLOCK -> [*]", |
| "STMT -> [*]", |
| "READWRITE(j, null) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testFieldWrite() throws Exception { |
| assertCfg("void", |
| "Foo foo = createFoo();", |
| "foo.i = 1;" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "OPTTHROW(createFoo()) -> [NOTHROW=*, RE=1, E=1]", |
| "CALL(createFoo) -> [*]", |
| "WRITE(foo, EntryPoint.createFoo()) -> [*]", |
| "STMT -> [*]", |
| "READ(foo) -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "1: END" |
| ); |
| } |
| |
| public void testFieldUnary() throws Exception { |
| assertCfg("void", |
| "Foo foo = createFoo();", |
| "++foo.i;" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "OPTTHROW(createFoo()) -> [NOTHROW=*, RE=1, E=1]", |
| "CALL(createFoo) -> [*]", |
| "WRITE(foo, EntryPoint.createFoo()) -> [*]", |
| "STMT -> [*]", |
| "READ(foo) -> [*]", |
| "READWRITE(i, null) -> [*]", |
| "1: END" |
| ); |
| } |
| |
| public void testArrayRead() throws Exception { |
| assertCfg("void", |
| "i = ii[j];" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(ii) -> [*]", |
| "READ(j) -> [*]", |
| "WRITE(i, EntryPoint.ii[EntryPoint.j]) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testArrayWrite() throws Exception { |
| assertCfg("void", |
| "ii[i] = j;" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "READ(ii) -> [*]", |
| "READ(i) -> [*]", |
| "WRITE(EntryPoint.ii[EntryPoint.i], EntryPoint.j) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testArrayUnary() throws Exception { |
| assertCfg("void", |
| "++ii[i];" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(ii) -> [*]", |
| "READ(i) -> [*]", |
| "READWRITE(EntryPoint.ii[EntryPoint.i], null) -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testSwitch() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " case 1: ", |
| " return;", |
| " case 2: ", |
| " case 3: ", |
| " j = 1;", |
| " break;", |
| " case 4: ", |
| " j = 2;", |
| " default:", |
| " j = 4;", |
| " case 5: ", |
| " j = 3;", |
| " break;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [7]", |
| "1: STMT -> [*]", |
| "COND (EntryPoint.i == 2) -> [ELSE=*, THEN=2]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 3) -> [THEN=*, ELSE=3]", |
| "2: STMT -> [*]", |
| "WRITE(j, 1) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [7]", |
| "3: STMT -> [*]", |
| "COND (EntryPoint.i == 4) -> [THEN=*, ELSE=5]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "4: STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 4) -> [6]", |
| "5: STMT -> [*]", |
| "COND (EntryPoint.i == 5) -> [THEN=*, ELSE=4]", |
| "6: STMT -> [*]", |
| "WRITE(j, 3) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "7: END" |
| ); |
| } |
| |
| public void testSwitch_FallThrough() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " case 1: ", |
| " j = 1;", |
| " case 2: ", |
| " j = 2;", |
| " case 3: ", |
| " j = 3;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "WRITE(j, 1) -> [2]", |
| "1: STMT -> [*]", |
| "COND (EntryPoint.i == 2) -> [THEN=*, ELSE=3]", |
| "2: STMT -> [*]", |
| "WRITE(j, 2) -> [4]", |
| "3: STMT -> [*]", |
| "COND (EntryPoint.i == 3) -> [THEN=*, ELSE=5]", |
| "4: STMT -> [*]", |
| "WRITE(j, 3) -> [*]", |
| "5: END"); |
| } |
| |
| public void testSwitch_FirstDefault() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " default: j = 1; return;", |
| " case 1: j = 2; return;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 1) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "2: STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "3: END" |
| ); |
| } |
| |
| public void testSwitch_Empty() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "END" |
| ); |
| } |
| |
| public void testSwitch_OnlyDefault() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " default: j = 0; return;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 0) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "END" |
| ); |
| } |
| public void testNestedSwitch() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " case 1: ", |
| " switch (j) {", |
| " case 0: k = 1; break;", |
| " case 1: k = 2; break;", |
| " }", |
| " break;", |
| " case 2: ", |
| " switch (j) {", |
| " case 0: k = 3; break;", |
| " case 1: k = 4; break;", |
| " }", |
| " break;", |
| " case 3: ", |
| " switch (j) {", |
| " case 0: k = 5; break;", |
| " case 1: k = 6; break;", |
| " }", |
| " break;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=3]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.j == 0) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "WRITE(k, 1) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "COND (EntryPoint.j == 1) -> [THEN=*, ELSE=2]", |
| "STMT -> [*]", |
| "WRITE(k, 2) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "2: STMT -> [*]", |
| "GOTO -> [9]", |
| "3: STMT -> [*]", |
| "COND (EntryPoint.i == 2) -> [THEN=*, ELSE=6]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.j == 0) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "WRITE(k, 3) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [5]", |
| "4: STMT -> [*]", |
| "COND (EntryPoint.j == 1) -> [THEN=*, ELSE=5]", |
| "STMT -> [*]", |
| "WRITE(k, 4) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "5: STMT -> [*]", |
| "GOTO -> [9]", |
| "6: STMT -> [*]", |
| "COND (EntryPoint.i == 3) -> [THEN=*, ELSE=9]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.j == 0) -> [THEN=*, ELSE=7]", |
| "STMT -> [*]", |
| "WRITE(k, 5) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [8]", |
| "7: STMT -> [*]", |
| "COND (EntryPoint.j == 1) -> [THEN=*, ELSE=8]", |
| "STMT -> [*]", |
| "WRITE(k, 6) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "8: STMT -> [*]", |
| "GOTO -> [*]", |
| "9: END" |
| ); |
| } |
| |
| public void testSwitchWithLoopAndBreak() throws Exception { |
| assertCfg("void", |
| "switch(i) {", |
| " case 1: ", |
| " i = 1;" + |
| " break;", |
| " case 2: ", |
| " while (b) { i = 2; break; }", |
| " j = 3;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "1: STMT -> [*]", |
| "COND (EntryPoint.i == 2) -> [THEN=*, ELSE=3]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 2) -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "2: STMT -> [*]", |
| "WRITE(j, 3) -> [*]", |
| "3: END" |
| ); |
| } |
| |
| public void testBreakStatement1() throws Exception { |
| assertCfg("void", |
| "lbl: {", |
| " break lbl;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testBreakStatement2() throws Exception { |
| assertCfg("void", |
| "lbl: break lbl;" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "END"); |
| } |
| |
| public void testBreakStatement3() throws Exception { |
| assertCfg("void", |
| "lbl: {", |
| " i = 1;", |
| " if (b) break lbl;", |
| " i = 2;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [2]", |
| "1: STMT -> [*]", |
| "WRITE(i, 2) -> [*]", |
| "2: END"); |
| } |
| |
| public void testBreakStatement4() throws Exception { |
| assertCfg("void", |
| "lbl1: {", |
| " i = 1;", |
| " lbl2: {", |
| " j = 1;", |
| " if (b) break lbl1;", |
| " j = 2;", |
| " if (b) break lbl2;", |
| " }", |
| " i = 2;", |
| "}" |
| ).is( |
| "BLOCK -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(i, 1) -> [*]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "WRITE(j, 1) -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=1]", |
| "STMT -> [*]", |
| "GOTO -> [3]", |
| "1: STMT -> [*]", |
| "WRITE(j, 2) -> [*]", |
| "STMT -> [*]", |
| "READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=2]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "2: STMT -> [*]", |
| "WRITE(i, 2) -> [*]", |
| "3: END"); |
| } |
| |
| public void testBreakLoopAndSwitch() throws Exception { |
| assertCfg("void", |
| "loop: while (b) {", |
| " switch (i) {", |
| " case 1: ", |
| " if (j == 1) {", |
| " break loop;", |
| " }", |
| " break;", |
| " default: ", |
| " return;", |
| " case 2: ", |
| " break loop;", |
| " case 3: ", |
| " break;", |
| " }", |
| " i++;", |
| "}", |
| "k++;" |
| ).is( |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "1: READ(b) -> [*]", |
| "COND (EntryPoint.b) -> [THEN=*, ELSE=7]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "READ(i) -> [*]", |
| "GOTO -> [*]", |
| "STMT -> [*]", |
| "COND (EntryPoint.i == 1) -> [THEN=*, ELSE=4]", |
| "STMT -> [*]", |
| "READ(j) -> [*]", |
| "COND (EntryPoint.j == 1) -> [THEN=*, ELSE=2]", |
| "BLOCK -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [7]", |
| "2: STMT -> [*]", |
| "GOTO -> [6]", |
| "3: STMT -> [*]", |
| "STMT -> [*]", |
| "GOTO -> [8]", |
| "4: STMT -> [*]", |
| "COND (EntryPoint.i == 2) -> [THEN=*, ELSE=5]", |
| "STMT -> [*]", |
| "GOTO -> [7]", |
| "5: STMT -> [*]", |
| "COND (EntryPoint.i == 3) -> [THEN=*, ELSE=3]", |
| "STMT -> [*]", |
| "GOTO -> [*]", |
| "6: STMT -> [*]", |
| "READWRITE(i, null) -> [1]", |
| "7: STMT -> [*]", |
| "READWRITE(k, null) -> [*]", |
| "8: END"); |
| } |
| |
| private CfgBuilderResult assertCfg(String returnType, String ...codeSnippet) |
| throws UnableToCompleteException { |
| JProgram program = compileSnippet(returnType, |
| Strings.join(codeSnippet, "\n")); |
| JMethodBody body = (JMethodBody) findMainMethod(program).getBody(); |
| Cfg cfgGraph = CfgBuilder.build(program, body.getBlock()); |
| return new CfgBuilderResult(cfgGraph); |
| } |
| |
| static class CfgBuilderResult { |
| private final Cfg cfg; |
| |
| public CfgBuilderResult(Cfg cfgGraph) { |
| assertNotNull("Can't build cfg", cfgGraph); |
| this.cfg = cfgGraph; |
| |
| validateGraph(); |
| } |
| |
| private void validateGraph() { |
| for (CfgNode<?> node : cfg.getNodes()) { |
| List<CfgEdge> incomingEdges = cfg.getInEdges(node); |
| for (CfgEdge e : incomingEdges) { |
| CfgNode<?> start = e.getStart(); |
| if (cfg.getGraphInEdges().contains(e)) { |
| assertNull(start); |
| continue; |
| } |
| assertNotNull("No start in edge " + e.getRole() + " to " + node, |
| start); |
| assertTrue(start + " doesn't have outgoing edge to " + node, |
| cfg.getOutEdges(start).contains(e)); |
| } |
| |
| List<CfgEdge> outcomingEdges = cfg.getOutEdges(node); |
| for (CfgEdge e : outcomingEdges) { |
| CfgNode<?> end = e.getEnd(); |
| assertNotNull("No end in edge " + e.getRole() + " from " + node, end); |
| assertTrue(end + " doesn't have incoming edge from " + node, |
| cfg.getInEdges(end).contains(e)); |
| } |
| } |
| } |
| |
| public void is(String... expected) { |
| assertEquals(Strings.join(expected, "\n"), cfg.print()); |
| } |
| } |
| } |
