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());
    }
  }
}