diff --git a/include/ceres/codegen/internal/expression.h b/include/ceres/codegen/internal/expression.h
index 7d93a4d..808d741 100644
--- a/include/ceres/codegen/internal/expression.h
+++ b/include/ceres/codegen/internal/expression.h
@@ -249,6 +249,7 @@
 // ExpressionGraph (see expression_graph.h).
 class Expression {
  public:
+  // Creates a NOP expression.
   Expression() = default;
 
   Expression(ExpressionType type,
diff --git a/include/ceres/codegen/internal/expression_graph.h b/include/ceres/codegen/internal/expression_graph.h
index 30b5a78..331a2d9 100644
--- a/include/ceres/codegen/internal/expression_graph.h
+++ b/include/ceres/codegen/internal/expression_graph.h
@@ -53,6 +53,9 @@
   bool DependsOn(ExpressionId A, ExpressionId B) const;
 
   bool operator==(const ExpressionGraph& other) const;
+  bool operator!=(const ExpressionGraph& other) const {
+    return !(*this == other);
+  }
 
   Expression& ExpressionForId(ExpressionId id) { return expressions_[id]; }
   const Expression& ExpressionForId(ExpressionId id) const {
diff --git a/internal/ceres/CMakeLists.txt b/internal/ceres/CMakeLists.txt
index 0733f47..af13f35 100644
--- a/internal/ceres/CMakeLists.txt
+++ b/internal/ceres/CMakeLists.txt
@@ -504,33 +504,7 @@
   add_subdirectory(generated_bundle_adjustment_tests)
 
   if(CODE_GENERATION)
-  # Testing the AutoDiffCodegen system is more complicated, because function- and
-  # constructor calls have side-effects. In C++ the evaluation order and
-  # the elision of copies is implementation defined. Between different compilers,
-  # some expression might be evaluated in a different order or some copies might be
-  # removed.
-  #
-  # Therefore, we run tests that expect a particular compiler behaviour only on gcc.
-  #
-  # The semantic tests, which check the correctness by executing the generated code
-  # are still run on all platforms.
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-      set(CXX_FLAGS_OLD ${CMAKE_CXX_FLAGS})
-      # From the man page:
-      #   The C++ standard allows an implementation to omit creating a
-      #   temporary which is only used to initialize another object of the
-      #   same type.  Specifying -fno-elide-constructors disables that
-      #   optimization, and forces G++ to call the copy constructor in all cases.
-      # We use this flag to get the same results between different versions of
-      # gcc and different optimization levels. Without this flag, testing would
-      # be very painfull and might break when a new compiler version is released.
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-elide-constructors")
-      ceres_test(expression)
-      ceres_test(code_generator)
-      ceres_test(conditional_expressions)
-      ceres_test(expression_graph)
-      set(CMAKE_CXX_FLAGS ${CXX_FLAGS_OLD})
-  endif()
+    add_subdirectory(codegen)
   endif()
 
 endif (BUILD_TESTING AND GFLAGS)
diff --git a/internal/ceres/codegen/CMakeLists.txt b/internal/ceres/codegen/CMakeLists.txt
new file mode 100644
index 0000000..7362aef
--- /dev/null
+++ b/internal/ceres/codegen/CMakeLists.txt
@@ -0,0 +1,57 @@
+# Ceres Solver - A fast non-linear least squares minimizer
+# Copyright 2019 Google Inc. All rights reserved.
+# http://ceres-solver.org/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of Google Inc. nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: darius.rueckert@fau.de (Darius Rueckert)
+#
+# Testing the AutoDiffCodegen system is more complicated, because function- and
+# constructor calls have side-effects. In C++ the evaluation order and
+# the elision of copies is implementation defined. Between different compilers,
+# some expression might be evaluated in a different order or some copies might be
+# removed.
+#
+# Therefore, we run tests that expect a particular compiler behaviour only on gcc.
+#
+# The semantic tests, which check the correctness by executing the generated code
+# are still run on all platforms.
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(CXX_FLAGS_OLD ${CMAKE_CXX_FLAGS})
+    # From the man page:
+    #   The C++ standard allows an implementation to omit creating a
+    #   temporary which is only used to initialize another object of the
+    #   same type.  Specifying -fno-elide-constructors disables that
+    #   optimization, and forces G++ to call the copy constructor in all cases.
+    # We use this flag to get the same results between different versions of
+    # gcc and different optimization levels. Without this flag, testing would
+    # be very painfull and might break when a new compiler version is released.
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-elide-constructors")
+    ceres_test(expression)
+    ceres_test(expression_graph)
+    ceres_test(expression_ref)
+    ceres_test(code_generator)
+    set(CMAKE_CXX_FLAGS ${CXX_FLAGS_OLD})
+endif()
diff --git a/internal/ceres/code_generator_test.cc b/internal/ceres/codegen/code_generator_test.cc
similarity index 90%
rename from internal/ceres/code_generator_test.cc
rename to internal/ceres/codegen/code_generator_test.cc
index 2ac7ee3..f974b1a 100644
--- a/internal/ceres/code_generator_test.cc
+++ b/internal/ceres/codegen/code_generator_test.cc
@@ -97,7 +97,6 @@
 }
 
 TEST(CodeGenerator, OUTPUT_ASSIGNMENT) {
-  double local_variable = 5.0;
   StartRecordingExpressions();
   T a = 1;
   T b = 0;
@@ -139,8 +138,8 @@
 
 TEST(CodeGenerator, BINARY_ARITHMETIC_SIMPLE) {
   StartRecordingExpressions();
-  T a = T(0);
-  T b = T(1);
+  T a = T(1);
+  T b = T(2);
   T r1 = a + b;
   T r2 = a - b;
   T r3 = a * b;
@@ -153,8 +152,8 @@
                                             "  double v_3;",
                                             "  double v_4;",
                                             "  double v_5;",
-                                            "  v_0 = 0;",
-                                            "  v_1 = 1;",
+                                            "  v_0 = 1;",
+                                            "  v_1 = 2;",
                                             "  v_2 = v_0 + v_1;",
                                             "  v_3 = v_0 - v_1;",
                                             "  v_4 = v_0 * v_1;",
@@ -163,17 +162,40 @@
   GenerateAndCheck(graph, expected_code);
 }
 
+TEST(CodeGenerator, BINARY_ARITHMETIC_NESTED) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  T r1 = b - a * (a + b) / a;
+  auto graph = StopRecordingExpressions();
+  std::vector<std::string> expected_code = {"{",
+                                            "  double v_0;",
+                                            "  double v_1;",
+                                            "  double v_2;",
+                                            "  double v_3;",
+                                            "  double v_4;",
+                                            "  double v_5;",
+                                            "  v_0 = 1;",
+                                            "  v_1 = 2;",
+                                            "  v_2 = v_0 + v_1;",
+                                            "  v_3 = v_0 * v_2;",
+                                            "  v_4 = v_3 / v_0;",
+                                            "  v_5 = v_1 - v_4;",
+                                            "}"};
+  GenerateAndCheck(graph, expected_code);
+}
+
 TEST(CodeGenerator, BINARY_ARITHMETIC_COMPOUND) {
   // For each binary compound arithmetic operation, two lines are generated:
   //    - The actual operation assigning to a new temporary variable
   //    - An assignment from the temporary to the lhs
   StartRecordingExpressions();
-  T a = T(0);
-  T b = T(1);
-  b += a;
-  b -= a;
-  b *= a;
-  b /= a;
+  T a = T(1);
+  T b = T(2);
+  a += b;
+  a -= b;
+  a *= b;
+  a /= b;
   auto graph = StopRecordingExpressions();
   std::vector<std::string> expected_code = {"{",
                                             "  double v_0;",
@@ -182,16 +204,16 @@
                                             "  double v_4;",
                                             "  double v_6;",
                                             "  double v_8;",
-                                            "  v_0 = 0;",
-                                            "  v_1 = 1;",
-                                            "  v_2 = v_1 + v_0;",
-                                            "  v_1 = v_2;",
-                                            "  v_4 = v_1 - v_0;",
-                                            "  v_1 = v_4;",
-                                            "  v_6 = v_1 * v_0;",
-                                            "  v_1 = v_6;",
-                                            "  v_8 = v_1 / v_0;",
-                                            "  v_1 = v_8;",
+                                            "  v_0 = 1;",
+                                            "  v_1 = 2;",
+                                            "  v_2 = v_0 + v_1;",
+                                            "  v_0 = v_2;",
+                                            "  v_4 = v_0 - v_1;",
+                                            "  v_0 = v_4;",
+                                            "  v_6 = v_0 * v_1;",
+                                            "  v_0 = v_6;",
+                                            "  v_8 = v_0 / v_1;",
+                                            "  v_0 = v_8;",
                                             "}"};
   GenerateAndCheck(graph, expected_code);
 }
diff --git a/internal/ceres/codegen/expression_graph_test.cc b/internal/ceres/codegen/expression_graph_test.cc
new file mode 100644
index 0000000..b08a9b3
--- /dev/null
+++ b/internal/ceres/codegen/expression_graph_test.cc
@@ -0,0 +1,182 @@
+// Ceres Solver - A fast non-linear least squares minimizer
+// Copyright 2019 Google Inc. All rights reserved.
+// http://code.google.com/p/ceres-solver/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors may be
+//   used to endorse or promote products derived from this software without
+//   specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: darius.rueckert@fau.de (Darius Rueckert)
+//
+// This file tests the ExpressionGraph class. This test depends on the
+// correctness of Expression.
+//
+#include "ceres/codegen/internal/expression.h"
+#include "ceres/codegen/internal/expression_graph.h"
+
+#include "gtest/gtest.h"
+
+namespace ceres {
+namespace internal {
+
+TEST(ExpressionGraph, Size) {
+  ExpressionGraph graph;
+  EXPECT_EQ(graph.Size(), 0);
+  // Insert 3 NOPs
+  graph.InsertBack(Expression());
+  graph.InsertBack(Expression());
+  graph.InsertBack(Expression());
+  EXPECT_EQ(graph.Size(), 3);
+}
+
+TEST(ExpressionGraph, Recording) {
+  EXPECT_EQ(GetCurrentExpressionGraph(), nullptr);
+  StartRecordingExpressions();
+  EXPECT_NE(GetCurrentExpressionGraph(), nullptr);
+  auto graph = StopRecordingExpressions();
+  EXPECT_EQ(graph, ExpressionGraph());
+  EXPECT_EQ(GetCurrentExpressionGraph(), nullptr);
+}
+
+TEST(ExpressionGraph, InsertBackControl) {
+  // Control expression are inserted to the back without any modifications.
+  auto expr1 = Expression::CreateIf(ExpressionId(0));
+  auto expr2 = Expression::CreateElse();
+  auto expr3 = Expression::CreateEndIf();
+
+  ExpressionGraph graph;
+  graph.InsertBack(expr1);
+  graph.InsertBack(expr2);
+  graph.InsertBack(expr3);
+
+  EXPECT_EQ(graph.Size(), 3);
+  EXPECT_EQ(graph.ExpressionForId(0), expr1);
+  EXPECT_EQ(graph.ExpressionForId(1), expr2);
+  EXPECT_EQ(graph.ExpressionForId(2), expr3);
+}
+
+TEST(ExpressionGraph, InsertBackNewVariable) {
+  // If an arithmetic expression with lhs=kinvalidValue is inserted in the back,
+  // then a new variable name is created and set to the lhs_id.
+  auto expr1 = Expression::CreateCompileTimeConstant(42);
+  auto expr2 = Expression::CreateCompileTimeConstant(10);
+  auto expr3 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(0), ExpressionId(1));
+
+  ExpressionGraph graph;
+  graph.InsertBack(expr1);
+  graph.InsertBack(expr2);
+  graph.InsertBack(expr3);
+  EXPECT_EQ(graph.Size(), 3);
+
+  // The ExpressionGraph has a copy of the inserted expression with the correct
+  // lhs_ids. We set them here manually for comparision.
+  expr1.set_lhs_id(0);
+  expr2.set_lhs_id(1);
+  expr3.set_lhs_id(2);
+  EXPECT_EQ(graph.ExpressionForId(0), expr1);
+  EXPECT_EQ(graph.ExpressionForId(1), expr2);
+  EXPECT_EQ(graph.ExpressionForId(2), expr3);
+}
+
+TEST(ExpressionGraph, InsertBackExistingVariable) {
+  auto expr1 = Expression::CreateCompileTimeConstant(42);
+  auto expr2 = Expression::CreateCompileTimeConstant(10);
+  auto expr3 = Expression::CreateAssignment(1, 0);
+
+  ExpressionGraph graph;
+  graph.InsertBack(expr1);
+  graph.InsertBack(expr2);
+  graph.InsertBack(expr3);
+  EXPECT_EQ(graph.Size(), 3);
+
+  expr1.set_lhs_id(0);
+  expr2.set_lhs_id(1);
+  expr3.set_lhs_id(1);
+  EXPECT_EQ(graph.ExpressionForId(0), expr1);
+  EXPECT_EQ(graph.ExpressionForId(1), expr2);
+  EXPECT_EQ(graph.ExpressionForId(2), expr3);
+}
+
+TEST(ExpressionGraph, DependsOn) {
+  ExpressionGraph graph;
+  graph.InsertBack(Expression::CreateCompileTimeConstant(42));
+  graph.InsertBack(Expression::CreateCompileTimeConstant(10));
+  graph.InsertBack(Expression::CreateBinaryArithmetic(
+      "+", ExpressionId(0), ExpressionId(1)));
+  graph.InsertBack(Expression::CreateBinaryArithmetic(
+      "+", ExpressionId(2), ExpressionId(0)));
+
+  // Code:
+  // v_0 = 42
+  // v_1 = 10
+  // v_2 = v_0 + v_1
+  // v_3 = v_2 + v_0
+
+  // Direct dependencies dependency check
+  ASSERT_TRUE(graph.DependsOn(2, 0));
+  ASSERT_TRUE(graph.DependsOn(2, 1));
+  ASSERT_TRUE(graph.DependsOn(3, 2));
+  ASSERT_TRUE(graph.DependsOn(3, 0));
+  ASSERT_FALSE(graph.DependsOn(1, 0));
+  ASSERT_FALSE(graph.DependsOn(1, 1));
+  ASSERT_FALSE(graph.DependsOn(2, 3));
+
+  // Recursive test
+  ASSERT_TRUE(graph.DependsOn(3, 1));
+}
+
+TEST(ExpressionGraph, InsertExpression_UpdateReferences) {
+  // This test checks if references to shifted expressions are updated
+  // accordingly.
+  ExpressionGraph graph;
+  graph.InsertBack(Expression::CreateCompileTimeConstant(42));
+  graph.InsertBack(Expression::CreateCompileTimeConstant(10));
+  graph.InsertBack(Expression::CreateBinaryArithmetic(
+      "+", ExpressionId(0), ExpressionId(1)));
+  // Code:
+  // v_0 = 42
+  // v_1 = 10
+  // v_2 = v_0 + v_1
+
+  // Insert another compile time constant at the beginning
+  graph.Insert(0, Expression::CreateCompileTimeConstant(5));
+  // This should shift all indices like this:
+  // v_0 = 5
+  // v_1 = 42
+  // v_2 = 10
+  // v_3 = v_1 + v_2
+
+  // Test by inserting it in the correct order
+  ExpressionGraph ref;
+  ref.InsertBack(Expression::CreateCompileTimeConstant(5));
+  ref.InsertBack(Expression::CreateCompileTimeConstant(42));
+  ref.InsertBack(Expression::CreateCompileTimeConstant(10));
+  ref.InsertBack(Expression::CreateBinaryArithmetic(
+      "+", ExpressionId(1), ExpressionId(2)));
+  EXPECT_EQ(graph.Size(), ref.Size());
+  EXPECT_EQ(graph, ref);
+}
+
+}  // namespace internal
+}  // namespace ceres
diff --git a/internal/ceres/codegen/expression_ref_test.cc b/internal/ceres/codegen/expression_ref_test.cc
new file mode 100644
index 0000000..aeb9d2b
--- /dev/null
+++ b/internal/ceres/codegen/expression_ref_test.cc
@@ -0,0 +1,387 @@
+// Ceres Solver - A fast non-linear least squares minimizer
+// Copyright 2019 Google Inc. All rights reserved.
+// http://code.google.com/p/ceres-solver/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors may be
+//   used to endorse or promote products derived from this software without
+//   specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: darius.rueckert@fau.de (Darius Rueckert)
+//
+// This file tests the ExpressionRef class. This test depends on the
+// correctness of Expression and ExpressionGraph.
+//
+#define CERES_CODEGEN
+
+#include "ceres/codegen/internal/expression_graph.h"
+#include "ceres/codegen/internal/expression_ref.h"
+#include "gtest/gtest.h"
+
+namespace ceres {
+namespace internal {
+
+using T = ExpressionRef;
+
+TEST(ExpressionRef, COMPILE_TIME_CONSTANT) {
+  StartRecordingExpressions();
+  T a = T(0);
+  T b = T(123.5);
+  T c = T(1 + 1);
+  T d;  // Uninitialized variables should not generate code!
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(0));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(123.5));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, INPUT_ASSIGNMENT) {
+  double local_variable = 5.0;
+  StartRecordingExpressions();
+  T a = CERES_LOCAL_VARIABLE(T, local_variable);
+  T b = MakeParameter("parameters[0][0]");
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateInputAssignment("local_variable"));
+  reference.InsertBack(Expression::CreateInputAssignment("parameters[0][0]"));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, OUTPUT_ASSIGNMENT) {
+  StartRecordingExpressions();
+  T a = 1;
+  T b = 0;
+  MakeOutput(a, "residual[0]");
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(0));
+  reference.InsertBack(Expression::CreateOutputAssignment(0, "residual[0]"));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, Assignment) {
+  StartRecordingExpressions();
+  T a = 1;
+  T b = 2;
+  b = a;
+  auto graph = StopRecordingExpressions();
+  EXPECT_EQ(graph.Size(), 3);
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateAssignment(1, 0));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, AssignmentCreate) {
+  StartRecordingExpressions();
+  T a = 2;
+  T b = a;
+  auto graph = StopRecordingExpressions();
+  EXPECT_EQ(graph.Size(), 2);
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateAssignment(kInvalidExpressionId, 0));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, MoveAssignmentCreate) {
+  StartRecordingExpressions();
+  T a = 2;
+  T b = std::move(a);
+  auto graph = StopRecordingExpressions();
+  EXPECT_EQ(graph.Size(), 1);
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, MoveAssignment) {
+  StartRecordingExpressions();
+  T a = 1;
+  T b = 2;
+  b = std::move(a);
+  auto graph = StopRecordingExpressions();
+  EXPECT_EQ(graph.Size(), 3);
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateAssignment(1, 0));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, BINARY_ARITHMETIC_SIMPLE) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  T r1 = a + b;
+  T r2 = a - b;
+  T r3 = a * b;
+  T r4 = a / b;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("+", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("-", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("*", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("/", 0, 1));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(ExpressionRef, BINARY_ARITHMETIC_NESTED) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  T r1 = b - a * (a + b) / a;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("+", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("*", 0, 2));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("/", 3, 0));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("-", 1, 4));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, BINARY_ARITHMETIC_COMPOUND) {
+  // For each binary compound arithmetic operation, two lines are generated:
+  //    - The actual operation assigning to a new temporary variable
+  //    - An assignment from the temporary to the lhs
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  a += b;
+  a -= b;
+  a *= b;
+  a /= b;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("+", 0, 1));
+  reference.InsertBack(Expression::CreateAssignment(0, 2));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("-", 0, 1));
+  reference.InsertBack(Expression::CreateAssignment(0, 4));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("*", 0, 1));
+  reference.InsertBack(Expression::CreateAssignment(0, 6));
+  reference.InsertBack(Expression::CreateBinaryArithmetic("/", 0, 1));
+  reference.InsertBack(Expression::CreateAssignment(0, 8));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, UNARY_ARITHMETIC) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T r1 = -a;
+  T r2 = +a;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateUnaryArithmetic("-", 0));
+  reference.InsertBack(Expression::CreateUnaryArithmetic("+", 0));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, BINARY_COMPARISON) {
+  using BOOL = ComparisonExpressionRef;
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  BOOL r1 = a < b;
+  BOOL r2 = a <= b;
+  BOOL r3 = a > b;
+  BOOL r4 = a >= b;
+  BOOL r5 = a == b;
+  BOOL r6 = a != b;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryCompare("<", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("<=", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare(">", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare(">=", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("==", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("!=", 0, 1));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, LOGICAL_OPERATORS) {
+  using BOOL = ComparisonExpressionRef;
+  // Tests binary logical operators &&, || and the unary logical operator !
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  BOOL r1 = a < b;
+  BOOL r2 = a <= b;
+  BOOL r3 = r1 && r2;
+  BOOL r4 = r1 || r2;
+  BOOL r5 = !r1;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryCompare("<", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("<=", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("&&", 2, 3));
+  reference.InsertBack(Expression::CreateBinaryCompare("||", 2, 3));
+  reference.InsertBack(Expression::CreateLogicalNegation(2));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, FUNCTION_CALL) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  abs(a);
+  acos(a);
+  asin(a);
+  atan(a);
+  cbrt(a);
+  ceil(a);
+  cos(a);
+  cosh(a);
+  exp(a);
+  exp2(a);
+  floor(a);
+  log(a);
+  log2(a);
+  sin(a);
+  sinh(a);
+  sqrt(a);
+  tan(a);
+  tanh(a);
+  atan2(a, b);
+  pow(a, b);
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateFunctionCall("abs", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("acos", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("asin", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("atan", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("cbrt", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("ceil", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("cos", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("cosh", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("exp", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("exp2", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("floor", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("log", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("log2", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("sin", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("sinh", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("sqrt", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("tan", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("tanh", {0}));
+  reference.InsertBack(Expression::CreateFunctionCall("atan2", {0, 1}));
+  reference.InsertBack(Expression::CreateFunctionCall("pow", {0, 1}));
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, IF) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  auto r1 = a < b;
+  CERES_IF(r1) {}
+  CERES_ENDIF;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryCompare("<", 0, 1));
+  reference.InsertBack(Expression::CreateIf(2));
+  reference.InsertBack(Expression::CreateEndIf());
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, IF_ELSE) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  auto r1 = a < b;
+  CERES_IF(r1) {}
+  CERES_ELSE {}
+  CERES_ENDIF;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryCompare("<", 0, 1));
+  reference.InsertBack(Expression::CreateIf(2));
+  reference.InsertBack(Expression::CreateElse());
+  reference.InsertBack(Expression::CreateEndIf());
+  EXPECT_EQ(reference, graph);
+}
+
+TEST(CodeGenerator, IF_NESTED) {
+  StartRecordingExpressions();
+  T a = T(1);
+  T b = T(2);
+  auto r1 = a < b;
+  auto r2 = a == b;
+  CERES_IF(r1) {
+    CERES_IF(r2) {}
+    CERES_ENDIF;
+  }
+  CERES_ELSE {}
+  CERES_ENDIF;
+  auto graph = StopRecordingExpressions();
+
+  ExpressionGraph reference;
+  reference.InsertBack(Expression::CreateCompileTimeConstant(1));
+  reference.InsertBack(Expression::CreateCompileTimeConstant(2));
+  reference.InsertBack(Expression::CreateBinaryCompare("<", 0, 1));
+  reference.InsertBack(Expression::CreateBinaryCompare("==", 0, 1));
+  reference.InsertBack(Expression::CreateIf(2));
+  reference.InsertBack(Expression::CreateIf(3));
+  reference.InsertBack(Expression::CreateEndIf());
+  reference.InsertBack(Expression::CreateElse());
+  reference.InsertBack(Expression::CreateEndIf());
+  EXPECT_EQ(reference, graph);
+}
+
+}  // namespace internal
+}  // namespace ceres
diff --git a/internal/ceres/expression_test.cc b/internal/ceres/codegen/expression_test.cc
similarity index 63%
rename from internal/ceres/expression_test.cc
rename to internal/ceres/codegen/expression_test.cc
index cab196b..395bbaf 100644
--- a/internal/ceres/expression_test.cc
+++ b/internal/ceres/codegen/expression_test.cc
@@ -28,11 +28,10 @@
 //
 // Author: darius.rueckert@fau.de (Darius Rueckert)
 //
-#define CERES_CODEGEN
-
-#include "ceres/codegen/internal/expression_graph.h"
-#include "ceres/codegen/internal/expression_ref.h"
-#include "ceres/jet.h"
+// This file tests the Expression class. For each member function one test is
+// included here.
+//
+#include "ceres/codegen/internal/expression.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -168,135 +167,61 @@
   ASSERT_FALSE(expr1.IsReplaceableBy(expr3));
 }
 
+TEST(Expression, Replace) {
+  auto expr1 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(5));
+  expr1.set_lhs_id(13);
+
+  auto expr2 =
+      Expression::CreateAssignment(kInvalidExpressionId, ExpressionId(7));
+
+  // We replace the arithmetic expr1 by an assignment from the variable 7. This
+  // is the typical usecase in subexpression elimination.
+  expr1.Replace(expr2);
+
+  // expr1 should now be an assignment from 7 to 13
+  EXPECT_EQ(expr1, Expression(ExpressionType::ASSIGNMENT, 13, {7}, "", 0));
+}
+
 TEST(Expression, DirectlyDependsOn) {
-  using T = ExpressionRef;
+  auto expr1 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(5));
 
-  StartRecordingExpressions();
+  ASSERT_TRUE(expr1.DirectlyDependsOn(ExpressionId(3)));
+  ASSERT_TRUE(expr1.DirectlyDependsOn(ExpressionId(5)));
+  ASSERT_FALSE(expr1.DirectlyDependsOn(ExpressionId(kInvalidExpressionId)));
+  ASSERT_FALSE(expr1.DirectlyDependsOn(ExpressionId(42)));
+}
+TEST(Expression, MakeNop) {
+  auto expr1 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(5));
 
-  T unused(6);
-  T a(2), b(3);
-  T c = a + b;
-  T d = c + a;
+  expr1.MakeNop();
 
-  auto graph = StopRecordingExpressions();
-
-  ASSERT_FALSE(graph.ExpressionForId(a.id).DirectlyDependsOn(unused.id));
-  ASSERT_TRUE(graph.ExpressionForId(c.id).DirectlyDependsOn(a.id));
-  ASSERT_TRUE(graph.ExpressionForId(c.id).DirectlyDependsOn(b.id));
-  ASSERT_TRUE(graph.ExpressionForId(d.id).DirectlyDependsOn(a.id));
-  ASSERT_FALSE(graph.ExpressionForId(d.id).DirectlyDependsOn(b.id));
-  ASSERT_TRUE(graph.ExpressionForId(d.id).DirectlyDependsOn(c.id));
+  EXPECT_EQ(expr1,
+            Expression(ExpressionType::NOP, kInvalidExpressionId, {}, "", 0));
 }
 
-TEST(Expression, Ternary) {
-  using T = ExpressionRef;
+TEST(Expression, IsSemanticallyEquivalentTo) {
+  // Create 2 identical expression
+  auto expr1 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(5));
 
-  StartRecordingExpressions();
-  T a(2);                   // 0
-  T b(3);                   // 1
-  auto c = a < b;           // 2
-  T d = Ternary(c, a, b);   // 3
-  MakeOutput(d, "result");  // 4
-  auto graph = StopRecordingExpressions();
+  auto expr2 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(5));
 
-  EXPECT_EQ(graph.Size(), 5);
+  ASSERT_TRUE(expr1.IsSemanticallyEquivalentTo(expr1));
+  ASSERT_TRUE(expr1.IsSemanticallyEquivalentTo(expr2));
 
-  // Expected code
-  //   v_0 = 2;
-  //   v_1 = 3;
-  //   v_2 = v_0 < v_1;
-  //   v_3 = Ternary(v_2, v_0, v_1);
-  //   result = v_3;
+  auto expr3 =
+      Expression::CreateBinaryArithmetic("+", ExpressionId(3), ExpressionId(8));
 
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   0,      {},        "",  2});
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   1,      {},        "",  3});
-  reference.InsertBack({     ExpressionType::BINARY_COMPARISON,   2,   {0,1},       "<",  0});
-  reference.InsertBack({         ExpressionType::FUNCTION_CALL,   3, {2,0,1}, "Ternary",  0});
-  reference.InsertBack({     ExpressionType::OUTPUT_ASSIGNMENT,   4,     {3},  "result",  0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-}
+  ASSERT_TRUE(expr1.IsSemanticallyEquivalentTo(expr3));
 
-TEST(Expression, Assignment) {
-  using T = ExpressionRef;
+  auto expr4 =
+      Expression::CreateBinaryArithmetic("-", ExpressionId(3), ExpressionId(5));
 
-  StartRecordingExpressions();
-  T a = 1;
-  T b = 2;
-  b = a;
-  auto graph = StopRecordingExpressions();
-
-  EXPECT_EQ(graph.Size(), 3);
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   0,       {},        "",  1});
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   1,       {},        "",  2});
-  reference.InsertBack({            ExpressionType::ASSIGNMENT,   1,      {0},        "",  0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-}
-
-TEST(Expression, AssignmentCreate) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-  T a = 2;
-  T b = a;
-  auto graph = StopRecordingExpressions();
-
-  EXPECT_EQ(graph.Size(), 2);
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   0,       {},        "",  2});
-  reference.InsertBack({            ExpressionType::ASSIGNMENT,   1,      {0},        "",  0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-}
-
-TEST(Expression, MoveAssignmentCreate) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-  T a = 1;
-  T b = std::move(a);
-  auto graph = StopRecordingExpressions();
-
-  EXPECT_EQ(graph.Size(), 1);
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   0,      {},        "",  1});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-}
-
-TEST(Expression, MoveAssignment) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-  T a = 1;
-  T b = 2;
-  b = std::move(a);
-  auto graph = StopRecordingExpressions();
-
-  EXPECT_EQ(graph.Size(), 3);
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   0,       {},        "",  1});
-  reference.InsertBack({ ExpressionType::COMPILE_TIME_CONSTANT,   1,       {},        "",  2});
-  reference.InsertBack({            ExpressionType::ASSIGNMENT,   1,      {0},        "",  0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
+  ASSERT_FALSE(expr1.IsSemanticallyEquivalentTo(expr4));
 }
 
 }  // namespace internal
diff --git a/internal/ceres/conditional_expressions_test.cc b/internal/ceres/conditional_expressions_test.cc
deleted file mode 100644
index 9c499ea..0000000
--- a/internal/ceres/conditional_expressions_test.cc
+++ /dev/null
@@ -1,132 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2019 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: darius.rueckert@fau.de (Darius Rueckert)
-//
-
-#define CERES_CODEGEN
-
-#include "ceres/codegen/internal/expression_graph.h"
-#include "ceres/codegen/internal/expression_ref.h"
-#include "gtest/gtest.h"
-
-namespace ceres {
-namespace internal {
-
-TEST(Expression, ConditionalMinimal) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-  T a(2);
-  T b(3);
-  auto c = a < b;
-  CERES_IF(c) {}
-  CERES_ELSE {}
-  CERES_ENDIF
-  auto graph = StopRecordingExpressions();
-
-  // Expected code
-  //   v_0 = 2;
-  //   v_1 = 3;
-  //   v_2 = v_0 < v_1;
-  //   if(v_2);
-  //   else
-  //   endif
-
-  EXPECT_EQ(graph.Size(), 6);
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id, Type, Lhs, Value, Name, Arguments...
-  reference.InsertBack({ExpressionType::COMPILE_TIME_CONSTANT,   0,  {}     ,    "", 2});
-  reference.InsertBack({ExpressionType::COMPILE_TIME_CONSTANT,   1,  {}     ,    "", 3});
-  reference.InsertBack({    ExpressionType::BINARY_COMPARISON,   2,  {0, 1} ,   "<", 0});
-  reference.InsertBack({                   ExpressionType::IF,  -1,  {2}    ,    "", 0});
-  reference.InsertBack({                 ExpressionType::ELSE,  -1,  {}     ,    "", 0});
-  reference.InsertBack({                ExpressionType::ENDIF,  -1,  {}     ,    "", 0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-}
-
-TEST(Expression, ConditionalAssignment) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-
-  T result;
-  T a(2);
-  T b(3);
-  auto c = a < b;
-  CERES_IF(c) { result = a + b; }
-  CERES_ELSE { result = a - b; }
-  CERES_ENDIF
-  result += a;
-  auto graph = StopRecordingExpressions();
-
-  // Expected code
-  //   v_0 = 2;
-  //   v_1 = 3;
-  //   v_2 = v_0 < v_1;
-  //   if(v_2);
-  //     v_4 = v_0 + v_1;
-  //   else
-  //     v_6 = v_0 - v_1;
-  //     v_4 = v_6
-  //   endif
-  //   v_9 = v_4 + v_0;
-  //   v_4 = v_9;
-
-  ExpressionGraph reference;
-  // clang-format off
-  // Id,   Type,                  Lhs, Value, Name, Arguments...
-  reference.InsertBack({ExpressionType::COMPILE_TIME_CONSTANT,    0,   {}    ,   "",   2});
-  reference.InsertBack({ExpressionType::COMPILE_TIME_CONSTANT,    1,   {}    ,   "",   3});
-  reference.InsertBack({    ExpressionType::BINARY_COMPARISON,    2,   {0, 1},  "<",   0});
-  reference.InsertBack({                   ExpressionType::IF,   -1,   {2}   ,   "",   0});
-  reference.InsertBack({    ExpressionType::BINARY_ARITHMETIC,    4,   {0, 1},  "+",   0});
-  reference.InsertBack({                 ExpressionType::ELSE,   -1,   {}    ,   "",   0});
-  reference.InsertBack({    ExpressionType::BINARY_ARITHMETIC,    6,   {0, 1},  "-",   0});
-  reference.InsertBack({           ExpressionType::ASSIGNMENT,    4,   {6}   ,   "",   0});
-  reference.InsertBack({                ExpressionType::ENDIF,   -1,   {}    ,   "",   0});
-  reference.InsertBack({    ExpressionType::BINARY_ARITHMETIC,    9,   {4, 0},  "+",   0});
-  reference.InsertBack({           ExpressionType::ASSIGNMENT,    4,   {9}   ,   "",   0});
-  // clang-format on
-  EXPECT_EQ(reference, graph);
-
-  // Variables after execution:
-  //
-  // a      <=> v_0
-  // b      <=> v_1
-  // result <=> v_4
-  EXPECT_EQ(a.id, 0);
-  EXPECT_EQ(b.id, 1);
-  EXPECT_EQ(result.id, 4);
-}
-
-}  // namespace internal
-}  // namespace ceres
diff --git a/internal/ceres/expression.cc b/internal/ceres/expression.cc
index ca92eaf..27e15cb 100644
--- a/internal/ceres/expression.cc
+++ b/internal/ceres/expression.cc
@@ -142,8 +142,8 @@
 }
 
 void Expression::MakeNop() {
-  type_ = ExpressionType::NOP;
-  arguments_.clear();
+  // The default constructor creates a NOP expression!
+  *this = Expression();
 }
 
 bool Expression::operator==(const Expression& other) const {
diff --git a/internal/ceres/expression_graph.cc b/internal/ceres/expression_graph.cc
index c0761af..d9b33e9 100644
--- a/internal/ceres/expression_graph.cc
+++ b/internal/ceres/expression_graph.cc
@@ -108,8 +108,17 @@
     expressions_[id + 1] = expression;
   }
 
-  // Insert new expression at the correct place
-  expressions_[location] = expression;
+  if (expression.IsControlExpression() ||
+      expression.lhs_id() != kInvalidExpressionId) {
+    // Insert new expression at the correct place
+    expressions_[location] = expression;
+  } else {
+    // Arithmetic expression with invalid lhs
+    // -> Set lhs to location
+    Expression copy = expression;
+    copy.set_lhs_id(location);
+    expressions_[location] = copy;
+  }
 }
 
 ExpressionId ExpressionGraph::InsertBack(const Expression& expression) {
diff --git a/internal/ceres/expression_graph_test.cc b/internal/ceres/expression_graph_test.cc
deleted file mode 100644
index 65b019c..0000000
--- a/internal/ceres/expression_graph_test.cc
+++ /dev/null
@@ -1,160 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2019 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: darius.rueckert@fau.de (Darius Rueckert)
-//
-// Test expression creation and logic.
-
-#include "ceres/codegen/internal/expression_graph.h"
-#include "ceres/codegen/internal/expression_ref.h"
-
-#include "gtest/gtest.h"
-
-namespace ceres {
-namespace internal {
-
-TEST(ExpressionGraph, Creation) {
-  using T = ExpressionRef;
-  ExpressionGraph graph;
-
-  StartRecordingExpressions();
-  graph = StopRecordingExpressions();
-  EXPECT_EQ(graph.Size(), 0);
-
-  StartRecordingExpressions();
-  T a(1);
-  T b(2);
-  T c = a + b;
-  graph = StopRecordingExpressions();
-  EXPECT_EQ(graph.Size(), 3);
-}
-
-TEST(ExpressionGraph, Dependencies) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-
-  T unused(6);
-  T a(2), b(3);
-  T c = a + b;
-  T d = c + a;
-
-  auto tree = StopRecordingExpressions();
-
-  // Recursive dependency check
-  ASSERT_TRUE(tree.DependsOn(d.id, c.id));
-  ASSERT_TRUE(tree.DependsOn(d.id, a.id));
-  ASSERT_TRUE(tree.DependsOn(d.id, b.id));
-  ASSERT_FALSE(tree.DependsOn(d.id, unused.id));
-}
-
-TEST(ExpressionGraph, InsertExpression_UpdateReferences) {
-  // This test checks if references to shifted expressions are updated
-  // accordingly.
-  using T = ExpressionRef;
-  StartRecordingExpressions();
-  T a(2);       // 0
-  T b(3);       // 1
-  T c = a + b;  // 2
-  auto graph = StopRecordingExpressions();
-
-  // Test if 'a' and 'c' are actually at location 0 and 2
-  auto& a_expr = graph.ExpressionForId(0);
-  EXPECT_EQ(a_expr.type(), ExpressionType::COMPILE_TIME_CONSTANT);
-  EXPECT_EQ(a_expr.value(), 2);
-
-  // At this point 'c' should have 0 and 1 as arguments.
-  auto& c_expr = graph.ExpressionForId(2);
-  EXPECT_EQ(c_expr.type(), ExpressionType::BINARY_ARITHMETIC);
-  EXPECT_EQ(c_expr.arguments()[0], 0);
-  EXPECT_EQ(c_expr.arguments()[1], 1);
-
-  // We insert at the beginning, which shifts everything by one spot.
-  graph.Insert(0, {ExpressionType::COMPILE_TIME_CONSTANT, 0, {}, "", 10.2});
-
-  // Test if 'a' and 'c' are actually at location 1 and 3
-  auto& a_expr2 = graph.ExpressionForId(1);
-  EXPECT_EQ(a_expr2.type(), ExpressionType::COMPILE_TIME_CONSTANT);
-  EXPECT_EQ(a_expr2.value(), 2);
-
-  // At this point 'c' should have 1 and 2 as arguments.
-  auto& c_expr2 = graph.ExpressionForId(3);
-  EXPECT_EQ(c_expr2.type(), ExpressionType::BINARY_ARITHMETIC);
-  EXPECT_EQ(c_expr2.arguments()[0], 1);
-  EXPECT_EQ(c_expr2.arguments()[1], 2);
-}
-
-TEST(ExpressionGraph, InsertExpression) {
-  using T = ExpressionRef;
-
-  StartRecordingExpressions();
-
-  {
-    T a(2);                   // 0
-    T b(3);                   // 1
-    T five = 5;               // 2
-    T tmp = a + five;         // 3
-    a = tmp;                  // 4
-    T c = a + b;              // 5
-    T d = a * b;              // 6
-    T e = c + d;              // 7
-    MakeOutput(e, "result");  // 8
-  }
-  auto reference = StopRecordingExpressions();
-  EXPECT_EQ(reference.Size(), 9);
-
-  StartRecordingExpressions();
-
-  {
-    // The expressions 2,3,4 from above are missing.
-    T a(2);                   // 0
-    T b(3);                   // 1
-    T c = a + b;              // 2
-    T d = a * b;              // 3
-    T e = c + d;              // 4
-    MakeOutput(e, "result");  // 5
-  }
-
-  auto graph1 = StopRecordingExpressions();
-  EXPECT_EQ(graph1.Size(), 6);
-  ASSERT_FALSE(reference == graph1);
-
-  // We manually insert the 3 missing expressions
-  // clang-format off
-  graph1.Insert(2,{ ExpressionType::COMPILE_TIME_CONSTANT, 2,     {},   "",  5});
-  graph1.Insert(3,{     ExpressionType::BINARY_ARITHMETIC, 3, {0, 2},  "+",  0});
-  graph1.Insert(4,{            ExpressionType::ASSIGNMENT, 0,    {3},   "",  0});
-  // clang-format on
-
-  // Now the graphs are identical!
-  EXPECT_EQ(graph1.Size(), 9);
-  ASSERT_TRUE(reference == graph1);
-}
-
-}  // namespace internal
-}  // namespace ceres