diff --git a/doc/scoot/Makefile b/doc/scoot/Makefile
new file mode 100644
index 0000000..14ad2a0
--- /dev/null
+++ b/doc/scoot/Makefile
@@ -0,0 +1,8 @@
+language_subset.pdf: *.tex refs.bib
+	pdflatex language_subset
+	bibtex language_subset
+	pdflatex language_subset
+	pdflatex language_subset
+
+clean:
+	rm -f *.aux *.bbl *.blg *.log *.toc *.dvi *.out *.tdo *.gx.table *.gx.gnuplot language_subset.ps language_subset.pdf *~
diff --git a/doc/scoot/javita.tex b/doc/scoot/javita.tex
new file mode 100644
index 0000000..a5c19aa
--- /dev/null
+++ b/doc/scoot/javita.tex
@@ -0,0 +1,452 @@
+\documentclass{report}
+
+\usepackage{syntax}
+\usepackage{xspace}
+\usepackage{mathpartir}
+\usepackage{url}
+
+\newcommand{\minijava}{MiniJava\xspace}
+\newcommand{\javita}{Javita\xspace}
+
+\begin{document}
+\title{Javita}
+
+\maketitle
+
+% jimple - grammar for classes?
+
+
+\section{\javita - Java subset handled in Cuanto}
+We informally define \javita, a subset of Java inspired by \minijava
+(a grammar for \minijava is available here \label{sec:minijava}).
+
+We define a different subset of Java than \minijava that has less
+language syntax restrictions. The \minijava syntax restrictions are
+not important when using soot as frontend (we already have parsing and
+typechecking).
+
+The \javita fragment contains:
+\begin{itemize}
+\item Integer and Boolean variables;
+\item Operations on Integer variables (sum, difference,
+  multiplication, division, modulo);
+\item Operations on Boolean variables (and, or, negation, xor, ...); 
+\item Control flow: Sequences, for loops, while loops, do while loops;
+\item Declare static methods, with Integer and Boolean return values
+  and parameters;
+\item Call to static methods;
+\item Declaration of classes with static (Integer or Boolean) fields.
+\end{itemize} 
+
+The rest of the Java language is outside the fragment:
+\begin{itemize}
+\item No variables of type different from Boolean or Integer;
+\item No dynamic memory allocation (no arrays, no creation of new objects);;
+\item No calls to methods on objects, no dynamic dispatch;
+\item No handling of exception;
+\item No declaration of non-static fields, no inheritance, no
+  implementation of interfaces, no generics types.
+\end{itemize}
+
+\bibliographystyle{plain}
+\bibliography{refs}
+
+\appendix
+
+\section{Jimple grammar}
+\begin{grammar}
+<jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
+
+<local_declarations> ::= <local_declaration> <local_declarations>
+
+<stmts> ::= <label> ":" <stmt> ";" <stmts> \alt  <stmt> ";" <smts>
+
+<exception_ranges> ::= <exception_range> <exception_ranges>
+
+<local_declaration> ::= <type> <name> ";"
+
+<identity_stmts> ::= <identity_stmt> <identity_stmts>
+
+<stmt> ::= <breakpoint_stmt> \alt <assign_stmt> \alt <enter_monitor_stmt>
+<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt <throw_stmt>
+
+<breakpoint_stmt> ::= "breakpoint"
+
+<assign_stmt> ::= <variable> "=" <rvalue>
+
+<identity_stmt> ::= <local> ":=" <identity_value>
+
+<enter_monitor_stmt> ::= "entermonitor" <immediate>
+
+<exit_monitor_stmt> ::= "exitmonitor" <immediate>
+
+<goto_stmt> ::= "goto" <label>
+
+<if_stmt> ::= "if" <condition> "then" <label>
+
+<invoke_stmt> ::= <invoke_expr>
+
+<lookup_switch_stmt> ::= "lookupswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <nop_stmt> ::= "nop"
+
+<ret_stmt> ::= "ret" <local>
+
+<return_stmt> ::= "return" <immediate>
+
+<return_void_stmt> ::= "return" 
+
+<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" <immediate>
+
+<cases> ::= <case> <cases>
+
+<case> ::= "case " <int_constant> ": <goto> " <label>
+
+<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt <gt_expr>
+
+<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> <next_next_stmt_address> \alt <static_field_ref>
+
+<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt <this_ref>
+
+<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt <local>
+
+<immediate> ::= <constant> \alt <local>
+
+<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt <unop_expr>
+
+<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt <xor_expr>
+
+<add_expr> ::= <immediate> "+"<immediate>
+
+<and_expr> ::= <immediate> "&"<immediate>
+
+<cmp_expr> ::= <immediate> "cmp"<immediate>
+
+<cmpg_expr> ::= <immediate> "cmpg"<immediate>
+
+<cmpl_expr> ::= <immediate> "cmpl"<immediate>
+
+<div_expr> ::= <immediate> "/"<immediate>
+
+<eq_expr> ::= <immediate> "=="<immediate>
+
+<ge_expr> ::= <immediate> ">="<immediate>
+
+<gt_expr> ::= <immediate> ">"<immediate>
+
+<le_expr> ::= <immediate> "<="<immediate>
+
+<lt_expr> ::= <immediate> "<"<immediate>
+
+<mul_expr> ::= <immediate> "*"<immediate>
+
+<ne_expr> ::= <immediate> "!="<immediate>
+
+<or_expr> ::= <immediate> "\alt"<immediate>
+
+<rem_expr> ::= <immediate> "%"<immediate>
+
+<shl_expr> ::= <immediate> "<<"<immediate>
+
+<shr_expr> ::= <immediate> ">>"<immediate>
+
+<sub_expr> ::= <immediate> "-"<immediate>
+
+<ushr_expr> ::= <immediate> "ushr"<immediate>
+
+<xor_expr> ::= <immediate> "xor"<immediate>
+
+<cast_expr> ::= "(" <type> ")"<immediate>
+
+<instance_of_expr> ::= <immediate> "instanceof" <ref_type>
+
+<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> <virtual_invoke_expr>
+
+<static_invoke_expr> ::= "staticinvoke" "[" <method_signature> "](" <immediate_list> ")"
+
+<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ".[" + <method_signature> "]" "(" <immediate_list> ")"
+
+<special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<immediate_list> ::= <immediate> \alt <immediate> <immediate_next_list>
+
+<immediate_next_list> ::= "," <immediate> <immediate_next_list>
+
+<new_array_expr> ::= "new" <type> "[" <immediate> "]"
+
+<new_expr> ::= "new" <ref_type> "()"
+
+<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims <empty_dims>
+
+<sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<next_sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<empty_dims> ::= "[]" <empty_dims> 
+
+<unop_expr> ::= <length_expr> | <neg_expr>
+
+<length_expr> ::= "length" <immediate>
+
+<neg_expr> ::= "-" <immediate>
+
+<array_ref> ::= <immediate> "[" <immediate> "]";
+
+<instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
+
+<static_field_ref> ::= "[" <field_signature> "]";
+
+<method_signature> ::= <identifier> "(" <type_list> "):" <type>;
+
+<field_signature> ::= <identifier> ":" <type>
+
+<type_list> ::= <type> <type_next_list>
+
+<type_next_list> ::= "," <type> <type_next_list>
+
+<caught_exception_ref> ::= "@caughtexception"
+
+<parameter_ref> ::= "@parameter" <int_constant>
+
+<this_ref> ::= "@this"
+
+<label> ::= <identifier>
+
+<local> ::= <identifier>
+
+<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt <null_constant>
+
+<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> <stmt_address_type> \alt <void_type>
+
+<exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" <label>;
+
+\end{grammar}
+\section{\minijava}
+\label{sec:minijava}
+
+\minijava language~\cite{miniJavaSyntax}
+
+MiniJava features:
+\begin{itemize}
+\item Integer and Boolean primitive types
+\item Integer array types (I don't see array of arrays)
+\item Classes without method overloading (no interfaces, generics, \ldots)
+\item Restricted control flow and expressions (no exception handling)
+\end{itemize}
+
+\begin{grammar}
+<Program>	::=	<MainClass> ( <ClassDeclaration> )*
+
+<MainClass>	::=	"class" <Identifier> "{" "public" "static" "void" "main" "(" "String" "[" "]" <Identifier> ")" "{" <Statement> "}" "}"
+
+<ClassDeclaration>	::=	"class" <Identifier> ( "extends" <Identifier> )? "{" ( <VarDeclaration> )* ( <MethodDeclaration> )* "}"
+
+<VarDeclaration>	::=	<Type> <Identifier> ";"
+
+<MethodDeclaration>	::=	"public" <Type> <Identifier> "(" ( <Type> <Identifier> ( "," <Type> <Identifier> )* )? ")" "{" ( <VarDeclaration> )* ( <Statement> )* "return" <Expression> ";" "}"
+
+<Type>	::=	"int" "[" "]"
+\alt	"boolean"
+\alt	"int"
+\alt	Identifier
+
+<Statement>	::=	"{" ( <Statement> )* "}"
+\alt	"if" "(" <Expression> ")" <Statement> "else" <Statement>
+\alt	"while" "(" Expression ")" <Statement>
+\alt	"System.out.println" "(" <Expression> ")" ";"
+\alt	<Identifier> "=" <Expression> ";"
+\alt	<Identifier> "[" <Expression> "]" "=" <Expression> ";"
+
+<Expression>	::=	<Expression> <Expression>
+\alt <Expression> "<" <Expression>
+\alt <Expression> "+" <Expression>
+\alt <Expression>  "-" <Expression>
+\alt <Expression> "*" <Expression>
+\alt	<Expression> "[" <Expression> "]"
+\alt	<Expression> "." "length"
+\alt	<Expression> "." <Identifier> "(" ( <Expression> ( "," <Expression> )* )? ")"
+\alt	<INTEGER_LITERAL>
+\alt	"true"
+\alt	"false"
+\alt	<Identifier>
+\alt	"this"
+\alt	"new" "int" "[" Expression "]"
+\alt	"new" <Identifier> "(" ")"
+\alt	"!" <Expression>
+\alt	"(" <Expression> ")"
+<Identifier>	::=	<IDENTIFIER>
+\end{grammar}
+
+\section{Jimple Syntax - Method Body}
+\label{sec:jimple}
+Full Jimple syntax for a single method ~\cite{Vallee-Rai98jimple:simplifying}
+
+\begin{grammar}
+<jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
+
+<local_declarations> ::= <local_declaration> <local_declarations>
+
+<stmts> ::= <label> ":" <stmt> ";" <stmts> \alt  <stmt> ";" <smts>
+
+<exception_ranges> ::= <exception_range> <exception_ranges>
+
+<local_declaration> ::= <type> <name> ";"
+
+<identity_stmts> ::= <identity_stmt> <identity_stmts>
+
+<stmt> ::= <breakpoint_stmt> \alt <assign_stmt> \alt <enter_monitor_stmt>
+<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt <throw_stmt>
+
+<breakpoint_stmt> ::= "breakpoint"
+
+<assign_stmt> ::= <variable> "=" <rvalue>
+
+<identity_stmt> ::= <local> ":=" <identity_value>
+
+<enter_monitor_stmt> ::= "entermonitor" <immediate>
+
+<exit_monitor_stmt> ::= "exitmonitor" <immediate>
+
+<goto_stmt> ::= "goto" <label>
+
+<if_stmt> ::= "if" <condition> "then" <label>
+
+<invoke_stmt> ::= <invoke_expr>
+
+<lookup_switch_stmt> ::= "lookupswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <nop_stmt> ::= "nop"
+
+<ret_stmt> ::= "ret" <local>
+
+<return_stmt> ::= "return" <immediate>
+
+<return_void_stmt> ::= "return" 
+
+<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" <immediate>
+
+<cases> ::= <case> <cases>
+
+<case> ::= "case " <int_constant> ": <goto> " <label>
+
+<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt <gt_expr>
+
+<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> <next_next_stmt_address> \alt <static_field_ref>
+
+<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt <this_ref>
+
+<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt <local>
+
+<immediate> ::= <constant> \alt <local>
+
+<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt <unop_expr>
+
+<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt <xor_expr>
+
+<add_expr> ::= <immediate> "+"<immediate>
+
+<and_expr> ::= <immediate> "&"<immediate>
+
+<cmp_expr> ::= <immediate> "cmp"<immediate>
+
+<cmpg_expr> ::= <immediate> "cmpg"<immediate>
+
+<cmpl_expr> ::= <immediate> "cmpl"<immediate>
+
+<div_expr> ::= <immediate> "/"<immediate>
+
+<eq_expr> ::= <immediate> "=="<immediate>
+
+<ge_expr> ::= <immediate> ">="<immediate>
+
+<gt_expr> ::= <immediate> ">"<immediate>
+
+<le_expr> ::= <immediate> "<="<immediate>
+
+<lt_expr> ::= <immediate> "<"<immediate>
+
+<mul_expr> ::= <immediate> "*"<immediate>
+
+<ne_expr> ::= <immediate> "!="<immediate>
+
+<or_expr> ::= <immediate> "\alt"<immediate>
+
+<rem_expr> ::= <immediate> "%"<immediate>
+
+<shl_expr> ::= <immediate> "<<"<immediate>
+
+<shr_expr> ::= <immediate> ">>"<immediate>
+
+<sub_expr> ::= <immediate> "-"<immediate>
+
+<ushr_expr> ::= <immediate> "ushr"<immediate>
+
+<xor_expr> ::= <immediate> "xor"<immediate>
+
+<cast_expr> ::= "(" <type> ")"<immediate>
+
+<instance_of_expr> ::= <immediate> "instanceof" <ref_type>
+
+<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> <virtual_invoke_expr>
+
+<static_invoke_expr> ::= "staticinvoke" "[" <method_signature> "](" <immediate_list> ")"
+
+<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ".[" + <method_signature> "]" "(" <immediate_list> ")"
+
+<special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<immediate_list> ::= <immediate> \alt <immediate> <immediate_next_list>
+
+<immediate_next_list> ::= "," <immediate> <immediate_next_list>
+
+<new_array_expr> ::= "new" <type> "[" <immediate> "]"
+
+<new_expr> ::= "new" <ref_type> "()"
+
+<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims <empty_dims>
+
+<sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<next_sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<empty_dims> ::= "[]" <empty_dims> 
+
+<unop_expr> ::= <length_expr> | <neg_expr>
+
+<length_expr> ::= "length" <immediate>
+
+<neg_expr> ::= "-" <immediate>
+
+<array_ref> ::= <immediate> "[" <immediate> "]";
+
+<instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
+
+<static_field_ref> ::= "[" <field_signature> "]";
+
+<method_signature> ::= <identifier> "(" <type_list> "):" <type>;
+
+<field_signature> ::= <identifier> ":" <type>
+
+<type_list> ::= <type> <type_next_list>
+
+<type_next_list> ::= "," <type> <type_next_list>
+
+<caught_exception_ref> ::= "@caughtexception"
+
+<parameter_ref> ::= "@parameter" <int_constant>
+
+<this_ref> ::= "@this"
+
+<label> ::= <identifier>
+
+<local> ::= <identifier>
+
+<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt <null_constant>
+
+<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> <stmt_address_type> \alt <void_type>
+
+<exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" <label>;
+
+\end{grammar}
+
+\end{document}
diff --git a/doc/scoot/refs.bib b/doc/scoot/refs.bib
new file mode 100644
index 0000000..9b72214
--- /dev/null
+++ b/doc/scoot/refs.bib
@@ -0,0 +1,28 @@
+@Misc{MiniJavaSyntax,
+  key =       {MiniJavaSyntax},
+  author =    {Joao Cangussu, Jens Palsberg and Vidyut Samanta},
+  title =     {MiniJava Syntax},
+  OPThowpublished = {},
+  OPTmonth =     {},
+  OPTyear =      {},
+  note =      {\url{http://www.cambridge.org/resources/052182060X/MCIIJ2e/grammar.htm}},
+  OPTannote =    {}
+}
+
+@Misc{MiniJavaTypes,
+  key =       {MiniJavaTypeSystem},
+  author =    {Joao Cangussu, Jens Palsberg and Vidyut Samanta},
+  title =     {MiniJava  type system},
+  OPThowpublished = {},
+  OPTmonth =     {},
+  OPTyear =      {},
+  note =      {\url{http://web.cs.ucla.edu/~palsberg/course/cs132/MiniJava-typesystem.pdf}},
+  OPTannote =    {}
+}
+
+
+@MISC{Vallee-Rai98jimple:simplifying,
+    author = {Raja Vallee-Rai and Laurie J. Hendren},
+    title = {Jimple: Simplifying Java Bytecode for Analyses and Transformations},
+    year = {1998}
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java b/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java
new file mode 100644
index 0000000..3a0c113
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java
@@ -0,0 +1,7 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ */
+public class ClassDeclaration {
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
new file mode 100644
index 0000000..128f679
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
@@ -0,0 +1,179 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ *
+ * Test the different control flow supported in Javita subset.
+ *
+ * By convention, the execution of all the public static method must
+ * return true.
+ */
+public class ControlFlow {
+  private static int classField1 = 0;
+
+  public static boolean sequence1() {
+    int a = 2;
+    int b = 3;
+    int c = 0;
+
+    c = a + b;
+    a += b;
+
+    return c == a;
+  }
+
+  public static boolean if1() {
+    int a = 2;
+    int b = 2;
+    boolean result = false;
+
+    if (a == b) {
+      result = true;
+    }
+
+    return result;
+  }
+
+  public static boolean if2() {
+    int a = 2;
+    int b = 2;
+    boolean result = false;
+
+    if (a != b) {
+      result = false;
+    }
+    else {
+      if (a != b) {
+        result = false;
+      } else {
+        result = true;
+      }
+    }
+
+    return result;
+  }
+  
+  public static boolean switch1() {
+    // Test the table switch
+    int var = 2;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2:
+      result = true;
+      break;
+    default:
+      result = false;
+      break;
+    }
+
+    return result;
+  }
+
+  public static boolean switch2() {
+    // Test the lookup switch
+    int var = 100;
+    boolean result = false;
+
+    switch (var) {
+    case 1: break;
+    case 10: break;
+    case 100:
+      result = true;
+      break;
+    case 1000: break;
+    default:
+      result = false;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean switch3() {
+    // Test break
+    int var = 2;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2:
+    case 3:
+      result = true;
+      break;
+    default:
+      result = false;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean switch4() {
+    // Test default
+    int var = 65;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2: break;
+    default:
+      result = true;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean testWhile() {
+    int var = 0;
+    while (var < 100) {
+      var += 1;
+    }
+
+    return var == 100;
+  }
+
+  public static boolean testDoWhile() {
+    int var = 0;
+
+    do {
+      var += 1;
+    } while (var < 100);
+
+    return var == 100;
+  }
+
+  public static boolean testFor() {
+    int var = 200;
+
+    for (var = 0; var < 100; var++) {
+    }
+
+    return var == 100;
+  }
+
+  public static boolean testReadClassField() {
+    return classField1 == 0;
+  }
+
+  public static boolean testWriteClassField() {
+    classField1 = 25;
+    return classField1 == 25;
+  }
+
+  public static int sum(int a, int b) {
+    return a + b;
+  }
+
+  public static boolean testMethodCall() {
+    int a = 3;
+    int b = 2;
+    int result;
+
+    result = ControlFlow.sum(a, b);
+
+    return result == 5;
+  }
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
new file mode 100644
index 0000000..a2b5ef7
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
@@ -0,0 +1,58 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ *
+ * 
+ */
+public class Expressions {
+
+  // TODO: do we want the bitwise operators for integers?
+  public static boolean testBool1() {return true && true;}
+  public static boolean testBool2() {return true && false;}
+  public static boolean testBool3() {return false && true;}
+  public static boolean testBool4() {return false && false;}
+
+  public static boolean testBool5() {return true || true;}
+  public static boolean testBool6() {return true || false;}
+  public static boolean testBool7() {return false || true;}
+  public static boolean testBool8() {return false || false;}
+
+  public static boolean testBool9() {return ! true;}
+  public static boolean testBool10() {return ! false;}
+
+  public static int testExpr1() {return 1 + 2;} // 3
+  public static int testExpr2() {return 1 + 2 + 10;} // 13
+  public static int testExpr3() {return 2 - 1;} // 1
+  public static int testExpr4() {return 2 * 3;} // 6
+  public static int testExpr5() {return 10 / 2;} // 5
+  public static int testExpr6() {return 10 % 4;} // 2
+  public static int testExpr7() {return 3 * 1 + 2;} // 5
+  public static int testExpr8() {return 3 * (1 + 2);} // 9
+  public static int testExpr9() {return 6 / 3 + 2;} // 4
+  public static int testExpr10() {return 6 / (3 + 2);} // 1
+  public static int testExpr11() {return 3 * 2 + 2 / 3;} // 6
+  public static int testExpr12() {return 4 * 3 / 4;} // 3
+  public static int testExpr13() {return (3 / 4);} // 0
+
+  /**
+   * Test comparison operators: <=, >=, <, >, !=, == 
+   */ 
+  public static boolean testComparisons1() {return 0 <= 0;}  // true
+  public static boolean testComparisons2() {return 0 <= 1;}  // true
+  public static boolean testComparisons3() {return 2 <= 0;}  // faslse
+  public static boolean testComparisons4() {return 0 >= 0;}  // true
+  public static boolean testComparisons5() {return 1 >= 0;}  // true
+  public static boolean testComparisons6() {return 0 >= 2;}  // faslse
+  public static boolean testComparisons7() {return 0 < 0;}   // false
+  public static boolean testComparisons8() {return 0 < 1;}   // true
+  public static boolean testComparisons9() {return 2 < 0;}   // faslse
+  public static boolean testComparisons10() {return 0 > 0;}  // false
+  public static boolean testComparisons11() {return 1 > 0;}  // true
+  public static boolean testComparisons12() {return 0 > 2;}  // faslse
+  public static boolean testComparisons13() {return 0 == 0;} // true
+  public static boolean testComparisons14() {return 0 == 1;} // false
+  public static boolean testComparisons15() {return 0 != 0;} // false
+  public static boolean testComparisons16() {return 0 != 1;} // true
+
+}
diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
new file mode 100644
index 0000000..9dec094
--- /dev/null
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -0,0 +1,109 @@
+package edu.colorado.plv.cuanto.javita
+
+import edu.colorado.plv.cuanto.CuantoSpec
+
+/**
+  * @author Sergio Mover
+  */
+class TestJavitaSemantic extends CuantoSpec {
+  import edu.colorado.plv.cuanto.javita.{Expressions, ControlFlow}
+
+  val mcString = "Method call"
+  val resString = "Result"
+
+  def runMethods[A](table : org.scalatest.prop.TableFor2[() => A, A]) : Unit = {
+    it should s"Compute correct result" in {
+      forAll (table) { (e, n) => {
+        (e()) should equal (n)
+      }}
+    }
+  }
+
+  behavior of "Arithmetic operators"
+  val exprTests = Table(
+    (mcString, resString),
+    (Expressions.testExpr1 _,3),
+    (Expressions.testExpr2 _, 13),
+    (Expressions.testExpr3 _, 1),
+    (Expressions.testExpr4 _, 6),
+    (Expressions.testExpr5 _, 5),
+    (Expressions.testExpr6 _, 2),
+    (Expressions.testExpr7 _, 5),
+    (Expressions.testExpr8 _, 9),
+    (Expressions.testExpr9 _, 4),
+    (Expressions.testExpr10 _, 1),
+    (Expressions.testExpr11 _, 6),
+    (Expressions.testExpr12 _, 3),
+    (Expressions.testExpr13 _, 0)
+  )
+  runMethods(exprTests)
+
+  behavior of "Boolean operators"
+  val boolTests = Table(
+    (mcString, resString),
+    (Expressions.testBool1 _, true),
+    (Expressions.testBool2 _, false),
+    (Expressions.testBool3 _, false),
+    (Expressions.testBool4 _, false),
+    (Expressions.testBool5 _, true),
+    (Expressions.testBool6 _, true),
+    (Expressions.testBool7 _, true),
+    (Expressions.testBool8 _, false),
+    (Expressions.testBool9 _, false),
+    (Expressions.testBool10 _, true)
+  )
+  runMethods(boolTests)
+
+  behavior of "Comparison operators"
+  val compTests = Table(
+    (mcString, resString),
+    (Expressions.testComparisons1 _, true),
+    (Expressions.testComparisons2 _, true),
+    (Expressions.testComparisons3 _, false),
+    (Expressions.testComparisons4 _, true),
+    (Expressions.testComparisons5 _, true),
+    (Expressions.testComparisons6 _, false),
+    (Expressions.testComparisons7 _, false),
+    (Expressions.testComparisons8 _, true),
+    (Expressions.testComparisons9 _, false),
+    (Expressions.testComparisons10 _, false),
+    (Expressions.testComparisons11 _, true),
+    (Expressions.testComparisons12 _, false),
+    (Expressions.testComparisons13 _, true),
+    (Expressions.testComparisons14 _, false),
+    (Expressions.testComparisons15 _, false),
+    (Expressions.testComparisons16 _, true)
+  )
+  runMethods(compTests)
+
+  behavior of "Control flow"
+  val cfTests = Table(
+    (mcString, resString),
+    (ControlFlow.sequence1 _, true),
+    (ControlFlow.if1 _, true),
+    (ControlFlow.if2 _, true),
+    (ControlFlow.switch1 _, true),
+    (ControlFlow.switch2 _, true),
+    (ControlFlow.switch3 _, true),
+    (ControlFlow.switch4 _, true),
+    (ControlFlow.testWhile _, true),
+    (ControlFlow.testDoWhile _, true),
+    (ControlFlow.testFor _, true)
+  )
+  runMethods(cfTests)
+
+  behavior of "Access fields"
+  val fieldsTests = Table(
+    (mcString, resString),
+    (ControlFlow.testReadClassField _, true),
+    (ControlFlow.testWriteClassField _, true)
+  )
+  runMethods(fieldsTests)
+
+  behavior of "Static method call"
+  val methodCallsTests = Table(
+    (mcString, resString),
+    (ControlFlow.testMethodCall _, true)
+  )
+  runMethods(methodCallsTests)
+}