diff --git a/poincare/test/complex.cpp b/poincare/test/complex.cpp
index c55ed67f3..738e3ad6d 100644
--- a/poincare/test/complex.cpp
+++ b/poincare/test/complex.cpp
@@ -14,6 +14,8 @@ constexpr Expression::ComplexFormat Polar = Expression::ComplexFormat::Polar;
 
 template<typename T>
 void assert_cartesian_complex_converts_to(T a, T b, const char * result, Expression::FloatDisplayMode mode = Scientific, Expression::ComplexFormat format = Cartesian, int significantDigits = 7, int bufferSize = 13+13+7+1) {
+  quiz_print(result);
+
   int tagSize = 8;
   unsigned char tag = 'X';
   char * taggedBuffer = new char[bufferSize+2*tagSize];
diff --git a/poincare/test/function.cpp b/poincare/test/function.cpp
index 60e93ffdd..75fda3a59 100644
--- a/poincare/test/function.cpp
+++ b/poincare/test/function.cpp
@@ -8,143 +8,44 @@
 using namespace Poincare;
 
 QUIZ_CASE(poincare_parse_function) {
-  Expression * e = Expression::parse("abs(-1)");
-  assert(e->type() == Expression::Type::AbsoluteValue);
-  delete e;
-
-  char argText[10] = {'a', 'r', 'g', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
-  e = Expression::parse(argText);
-  assert(e->type() == Expression::Type::ComplexArgument);
-  delete e;
-
-  e = Expression::parse("binomial(10, 4)");
-  assert(e->type() == Expression::Type::BinomialCoefficient);
-  delete e;
-
-  e = Expression::parse("ceil(0.2)");
-  assert(e->type() == Expression::Type::Ceiling);
-  delete e;
-
-  e = Expression::parse("diff(2*x, 2)");
-  assert(e->type() == Expression::Type::Derivative);
-  delete e;
-
+  assert_parsed_expression_type("abs(-1)", Expression::Type::AbsoluteValue);
+  assert_parsed_expression_type("arg(2+I)", Expression::Type::ComplexArgument);
+  assert_parsed_expression_type("binomial(10, 4)", Expression::Type::BinomialCoefficient);
+  assert_parsed_expression_type("ceil(0.2)", Expression::Type::Ceiling);
+  assert_parsed_expression_type("diff(2*x, 2)", Expression::Type::Derivative);
 #if MATRICES_ARE_DEFINED
-  e = Expression::parse("dim([[2]])");
-  assert(e->type() == Expression::Type::MatrixDimension);
-  delete e;
-
-  e = Expression::parse("det([[1,2,3][4,5,6][7,8,9]])");
-  assert(e->type() == Expression::Type::Determinant);
-  delete e;
+  assert_parsed_expression_type("dim([[2]])", Expression::Type::MatrixDimension);
+  assert_parsed_expression_type("det([[1,2,3][4,5,6][7,8,9]])", Expression::Type::Determinant);
 #endif
-
-  e = Expression::parse("confidence(0.1, 100)");
-  assert(e->type() == Expression::Type::ConfidenceInterval);
-  delete e;
-
-  e = Expression::parse("conj(2)");
-  assert(e->type() == Expression::Type::Conjugate);
-  delete e;
-
-  e = Expression::parse("floor(2.3)");
-  assert(e->type() == Expression::Type::Floor);
-  delete e;
-
-  e = Expression::parse("frac(2.3)");
-  assert(e->type() == Expression::Type::FracPart);
-  delete e;
-
-  e = Expression::parse("gcd(2,3)");
-  assert(e->type() == Expression::Type::GreatCommonDivisor);
-  delete e;
-
-  char imText[10] = {'i', 'm', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
-  e = Expression::parse(imText);
-  assert(e->type() == Expression::Type::ImaginaryPart);
-  delete e;
-
-  e = Expression::parse("int(x, 2, 3)");
-  assert(e->type() == Expression::Type::Integral);
-  delete e;
-
+  assert_parsed_expression_type("confidence(0.1, 100)", Expression::Type::ConfidenceInterval);
+  assert_parsed_expression_type("conj(2)", Expression::Type::Conjugate);
+  assert_parsed_expression_type("floor(2.3)", Expression::Type::Floor);
+  assert_parsed_expression_type("frac(2.3)", Expression::Type::FracPart);
+  assert_parsed_expression_type("gcd(2,3)", Expression::Type::GreatCommonDivisor);
+  assert_parsed_expression_type("im(2+I)", Expression::Type::ImaginaryPart);
+  assert_parsed_expression_type("int(x, 2, 3)", Expression::Type::Integral);
 #if MATRICES_ARE_DEFINED
-  e = Expression::parse("inverse([[1,2,3][4,5,6][7,8,9]])");
-  assert(e->type() == Expression::Type::MatrixInverse);
-  delete e;
+  assert_parsed_expression_type("inverse([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixInverse);
 #endif
-
-  e = Expression::parse("lcm(2,3)");
-  assert(e->type() == Expression::Type::LeastCommonMultiple);
-  delete e;
-
-  e = Expression::parse("ln(2)");
-  assert(e->type() == Expression::Type::NaperianLogarithm);
-  delete e;
-
-  e = Expression::parse("log(2)");
-  assert(e->type() == Expression::Type::Logarithm);
-  delete e;
-
-  e = Expression::parse("permute(10, 4)");
-  assert(e->type() == Expression::Type::PermuteCoefficient);
-  delete e;
-
-  e = Expression::parse("prediction(0.1, 100)");
-  assert(e->type() == Expression::Type::ConfidenceInterval);
-  delete e;
-
-  e = Expression::parse("prediction95(0.1, 100)");
-  assert(e->type() == Expression::Type::PredictionInterval);
-  delete e;
-
-  e = Expression::parse("product(n, 4, 10)");
-  assert(e->type() == Expression::Type::Product);
-  delete e;
-
-  e = Expression::parse("quo(29, 10)");
-  assert(e->type() == Expression::Type::DivisionQuotient);
-  delete e;
-
-  char reText[10] = {'r', 'e', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
-  e = Expression::parse(reText);
-  assert(e->type() == Expression::Type::ReelPart);
-  delete e;
-
-  e = Expression::parse("rem(29, 10)");
-  assert(e->type() == Expression::Type::DivisionRemainder);
-  delete e;
-
-  e = Expression::parse("root(2,3)");
-  assert(e->type() == Expression::Type::NthRoot);
-  delete e;
-
-  char text[5] = {Ion::Charset::Root, '(', '2', ')', 0};
-  e = Expression::parse(text);
-  assert(e->type() == Expression::Type::SquareRoot);
-  delete e;
-
-  e = Expression::parse("round(2,3)");
-  assert(e->type() == Expression::Type::Round);
-  delete e;
-
-  e = Expression::parse("sum(n, 4, 10)");
-  assert(e->type() == Expression::Type::Sum);
-  delete e;
-
+  assert_parsed_expression_type("lcm(2,3)", Expression::Type::LeastCommonMultiple);
+  assert_parsed_expression_type("ln(2)", Expression::Type::NaperianLogarithm);
+  assert_parsed_expression_type("log(2)", Expression::Type::Logarithm);
+  assert_parsed_expression_type("permute(10, 4)", Expression::Type::PermuteCoefficient);
+  assert_parsed_expression_type("prediction(0.1, 100)", Expression::Type::ConfidenceInterval);
+  assert_parsed_expression_type("prediction95(0.1, 100)", Expression::Type::PredictionInterval);
+  assert_parsed_expression_type("product(n, 4, 10)", Expression::Type::Product);
+  assert_parsed_expression_type("quo(29, 10)", Expression::Type::DivisionQuotient);
+  assert_parsed_expression_type("re(2+I)", Expression::Type::ReelPart);
+  assert_parsed_expression_type("rem(29, 10)", Expression::Type::DivisionRemainder);
+  assert_parsed_expression_type("root(2,3)", Expression::Type::NthRoot);
+  assert_parsed_expression_type("R(2)", Expression::Type::SquareRoot);
+  assert_parsed_expression_type("round(2,3)", Expression::Type::Round);
+  assert_parsed_expression_type("sum(n, 4, 10)", Expression::Type::Sum);
 #if MATRICES_ARE_DEFINED
-  e = Expression::parse("trace([[1,2,3][4,5,6][7,8,9]])");
-  assert(e->type() == Expression::Type::MatrixTrace);
-  delete e;
-
-  e = Expression::parse("transpose([[1,2,3][4,5,6][7,8,9]])");
-  assert(e->type() == Expression::Type::MatrixTranspose);
-  delete e;
+  assert_parsed_expression_type("trace([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTrace);
+  assert_parsed_expression_type("transpose([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTranspose);
 #endif
-
-  e = Expression::parse("6!");
-  assert(e->type() == Expression::Type::Factorial);
-  delete e;
+  assert_parsed_expression_type("6!", Expression::Type::Factorial);
 }
 
 
diff --git a/poincare/test/helper.cpp b/poincare/test/helper.cpp
index 5cc022de9..b93679667 100644
--- a/poincare/test/helper.cpp
+++ b/poincare/test/helper.cpp
@@ -8,30 +8,45 @@
 
 using namespace Poincare;
 
-template<typename T>
-void assert_parsed_expression_evaluates_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
+static Expression * parse_expression(const char * expression) {
+  quiz_print(expression);
   char buffer[200];
-  strlcpy(buffer, expression, 200);
-  for (size_t i=0; i<strlen(buffer); i++) {
-    if (buffer[i] == 'E') {
-      buffer[i] = Ion::Charset::Exponent;
-    }
-    if (buffer[i] == 'X') {
-      buffer[i] = Ion::Charset::Exponential;
-    }
-    if (buffer[i] == 'I') {
-      buffer[i] = Ion::Charset::IComplex;
-    }
-    if (buffer[i] == 'R') {
-      buffer[i] = Ion::Charset::Root;
-    }
-    if (buffer[i] == 'P') {
-      buffer[i] = Ion::Charset::SmallPi;
+  strlcpy(buffer, expression, sizeof(buffer));
+  for (char *c = buffer; *c; c++) {
+    switch (*c) {
+      case 'E': *c = Ion::Charset::Exponent; break;
+      case 'X': *c = Ion::Charset::Exponential; break;
+      case 'I': *c = Ion::Charset::IComplex; break;
+      case 'R': *c = Ion::Charset::Root; break;
+      case 'P': *c = Ion::Charset::SmallPi; break;
     }
   }
+  Expression * result = Expression::parse(buffer);
+  assert(result);
+  return result;
+}
+
+void assert_parsed_expression_type(const char * expression, Poincare::Expression::Type type) {
+  Expression * e = parse_expression(expression);
+  assert(e->type() == type);
+  delete e;
+}
+
+void assert_parsed_simplified_expression_type(const char * expression, Poincare::Expression::Type type) {
+  Expression * e = parse_expression(expression);
+  Expression * e2 = e->simplify();
+  assert(e2);
+  assert(e2->type() == type);
+  delete e;
+  delete e2;
+}
+
+template<typename T>
+void assert_parsed_expression_evaluates_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
   GlobalContext globalContext;
-  Expression * a = Expression::parse(buffer);
+  Expression * a = parse_expression(expression);
   Evaluation<T> * m = a->evaluate<T>(globalContext, angleUnit);
+  assert(m);
   assert(m->numberOfRows() == numberOfRows);
   assert(m->numberOfColumns() == numberOfColumns);
   for (int i = 0; i < m->numberOfOperands(); i++) {
diff --git a/poincare/test/helper.h b/poincare/test/helper.h
index e661c7596..39d3376f3 100644
--- a/poincare/test/helper.h
+++ b/poincare/test/helper.h
@@ -3,6 +3,8 @@
 constexpr Poincare::Expression::AngleUnit Degree = Poincare::Expression::AngleUnit::Degree;
 constexpr Poincare::Expression::AngleUnit Radian = Poincare::Expression::AngleUnit::Radian;
 
+void assert_parsed_expression_type(const char * expression, Poincare::Expression::Type type);
+void assert_parsed_simplified_expression_type(const char * expression, Poincare::Expression::Type type);
 template<typename T>
 void assert_parsed_expression_evaluates_to(const char * expression, Poincare::Complex<T> * results, int numberOfRows, int numberOfColumns = 1, Poincare::Expression::AngleUnit angleUnit = Degree);
 template<typename T>
diff --git a/poincare/test/symbol.cpp b/poincare/test/symbol.cpp
index 46748d97c..36222cf3a 100644
--- a/poincare/test/symbol.cpp
+++ b/poincare/test/symbol.cpp
@@ -8,29 +8,11 @@
 using namespace Poincare;
 
 QUIZ_CASE(poincare_parse_symbol) {
-  char piText[2] = {Ion::Charset::SmallPi, 0};
-  Expression * e = Expression::parse(piText);
-  assert(e->type() == Expression::Type::Symbol);
-  delete e;
-
-  char eText[2] = {Ion::Charset::Exponential, 0};
-  e = Expression::parse(eText);
-  assert(e->type() == Expression::Type::Symbol);
-  delete e;
-
-  char iText[10] = {Ion::Charset::IComplex, 0};
-  e = Expression::parse(iText);
-  assert(e->type() == Expression::Type::Complex);
-  delete e;
-
-  char floatText[10] = {'1', '.', '2', Ion::Charset::Exponent, '3', 0};
-  e = Expression::parse(floatText);
-  assert(e->type() == Expression::Type::Complex);
-  delete e;
-
-  e = Expression::parse("ans");
-  assert(e->type() == Expression::Type::Symbol);
-  delete e;
+  assert_parsed_expression_type("P", Expression::Type::Symbol);
+  assert_parsed_expression_type("X", Expression::Type::Symbol);
+  assert_parsed_expression_type("I", Expression::Type::Complex);
+  assert_parsed_expression_type("1.2E3", Expression::Type::Complex);
+  assert_parsed_expression_type("ans", Expression::Type::Symbol);
 }
 
 
diff --git a/poincare/test/trigo.cpp b/poincare/test/trigo.cpp
index fa1c14fd4..24f146bb8 100644
--- a/poincare/test/trigo.cpp
+++ b/poincare/test/trigo.cpp
@@ -7,90 +7,18 @@
 using namespace Poincare;
 
 QUIZ_CASE(poincare_parse_trigo) {
-  {
-    Expression * e = Expression::parse("sin(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::Sine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("cos(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::Cosine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("tan(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::Tangent);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("cosh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicCosine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("sinh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicSine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("tanh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicTangent);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("acos(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::ArcCosine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("asin(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::ArcSine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("atan(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::ArcTangent);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("acosh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicArcCosine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("asinh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicArcSine);
-    delete e;
-    delete e2;
-  }
-  {
-    Expression * e = Expression::parse("atanh(0)");
-    Expression * e2 = e->simplify();
-    assert(e2->type() == Expression::Type::HyperbolicArcTangent);
-    delete e;
-    delete e2;
-  }
+  assert_parsed_simplified_expression_type("sin(0)", Expression::Type::Sine);
+  assert_parsed_simplified_expression_type("cos(0)", Expression::Type::Cosine);
+  assert_parsed_simplified_expression_type("tan(0)", Expression::Type::Tangent);
+  assert_parsed_simplified_expression_type("cosh(0)", Expression::Type::HyperbolicCosine);
+  assert_parsed_simplified_expression_type("sinh(0)", Expression::Type::HyperbolicSine);
+  assert_parsed_simplified_expression_type("tanh(0)", Expression::Type::HyperbolicTangent);
+  assert_parsed_simplified_expression_type("acos(0)", Expression::Type::ArcCosine);
+  assert_parsed_simplified_expression_type("asin(0)", Expression::Type::ArcSine);
+  assert_parsed_simplified_expression_type("atan(0)", Expression::Type::ArcTangent);
+  assert_parsed_simplified_expression_type("acosh(0)", Expression::Type::HyperbolicArcCosine);
+  assert_parsed_simplified_expression_type("asinh(0)", Expression::Type::HyperbolicArcSine);
+  assert_parsed_simplified_expression_type("atanh(0)", Expression::Type::HyperbolicArcTangent);
 }
 
 QUIZ_CASE(poincare_trigo_evaluate) {
diff --git a/quiz/include/quiz.h b/quiz/include/quiz.h
index 52aae759f..6db98207c 100644
--- a/quiz/include/quiz.h
+++ b/quiz/include/quiz.h
@@ -14,6 +14,7 @@ extern "C" {
 #endif
 
 void quiz_assert_true(bool condition);
+void quiz_print(const char * message);
 
 #ifdef __cplusplus
 }
diff --git a/quiz/src/runner.cpp b/quiz/src/runner.cpp
index 701e587cb..b55caeb98 100644
--- a/quiz/src/runner.cpp
+++ b/quiz/src/runner.cpp
@@ -1,9 +1,10 @@
+#include "quiz.h"
 #include "symbols.h"
 #include <string.h>
 #include <kandinsky.h>
 #include <ion.h>
 
-void print(const char * message) {
+void quiz_print(const char * message) {
 #if QUIZ_USE_CONSOLE
   Ion::Console::writeLine(message);
 #else
@@ -23,11 +24,11 @@ void ion_app() {
   int i = 0;
   while (quiz_cases[i] != NULL) {
     QuizCase c = quiz_cases[i];
+    quiz_print(quiz_case_names[i]);
     c();
-    print(quiz_case_names[i]);
     i++;
   }
-  print("ALL TESTS FINISHED");
+  quiz_print("ALL TESTS FINISHED");
 #if !QUIZ_USE_CONSOLE
   while (1) {
     Ion::msleep(1000);