[quiz] Turn all assert in quiz_assert

2026-01-18 16:27:34 +01:00 · 2018-08-28 10:40:52 +02:00
parent d3296be915
commit a1bcbe28e6
29 changed files with 261 additions and 261 deletions
--- a/apps/calculation/test/calculation_store.cpp
+++ b/apps/calculation/test/calculation_store.cpp
@@ -8,18 +8,18 @@ using namespace Calculation;

 void assert_store_is(CalculationStore * store, const char * result[10]) {
  for (int i = 0; i < store->numberOfCalculations(); i++) {
-    assert(strcmp(store->calculationAtIndex(i)->inputText(), result[i]) == 0);
+    quiz_assert(strcmp(store->calculationAtIndex(i)->inputText(), result[i]) == 0);
  }
 }

 QUIZ_CASE(calculation_store) {
  GlobalContext globalContext;
  CalculationStore store;
-  assert(CalculationStore::k_maxNumberOfCalculations == 10);
+  quiz_assert(CalculationStore::k_maxNumberOfCalculations == 10);
  for (int i = 0; i < CalculationStore::k_maxNumberOfCalculations; i++) {
    char text[2] = {(char)(i+'0'), 0};
    store.push(text, &globalContext);
-    assert(store.numberOfCalculations() == i+1);
+    quiz_assert(store.numberOfCalculations() == i+1);
  }
  /* Store is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} */
  const char * result[10] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
@@ -40,7 +40,7 @@ QUIZ_CASE(calculation_store) {
  for (int i = 5; i < CalculationStore::k_maxNumberOfCalculations; i++) {
    char text[3] = {(char)(i+'0'), 0};
    store.push(text, &globalContext);
-    assert(store.numberOfCalculations() == i+1);
+    quiz_assert(store.numberOfCalculations() == i+1);
  }
  /* Store is now {0, 2, 4, 6, 8, 5, 6, 7, 8, 9} */
  const char * result3[10] = {"1", "3", "5", "7", "9", "5", "6", "7", "8", "9"};
@@ -50,11 +50,11 @@ QUIZ_CASE(calculation_store) {
  store.push("1+3/4", &globalContext);
  store.push("ans+2/3", &globalContext);
  ::Calculation::Calculation * lastCalculation = store.calculationAtIndex(1);
-  assert(lastCalculation->shouldOnlyDisplayApproximateOutput(&globalContext) == false);
-  assert(strcmp(lastCalculation->exactOutputText(),"29/12") == 0);
+  quiz_assert(lastCalculation->shouldOnlyDisplayApproximateOutput(&globalContext) == false);
+  quiz_assert(strcmp(lastCalculation->exactOutputText(),"29/12") == 0);

  store.push("ans+0.22", &globalContext);
  lastCalculation = store.calculationAtIndex(2);
-  assert(lastCalculation->shouldOnlyDisplayApproximateOutput(&globalContext) == true);
-  assert(strcmp(lastCalculation->approximateOutputText(),"2.6366666666667") == 0);
+  quiz_assert(lastCalculation->shouldOnlyDisplayApproximateOutput(&globalContext) == true);
+  quiz_assert(strcmp(lastCalculation->approximateOutputText(),"2.6366666666667") == 0);
 }
--- a/apps/probability/test/erf_inv.cpp
+++ b/apps/probability/test/erf_inv.cpp
@@ -6,13 +6,13 @@
 #include "../law/erf_inv.h"

 QUIZ_CASE(erf_inv) {
-  assert(erfInv(0.0) == 0.0);
-  assert(std::isinf(erfInv(1.0))  && erfInv(1.0) > 0.0);
-  assert(std::isinf(erfInv(-1.0)) && erfInv(-1.0) < 0.0);
-  assert(std::fabs(erfInv(0.5) - 0.476936276204469873381418353643130559808969749059470644703) < DBL_EPSILON);
-  assert(std::fabs(erfInv(0.25) - 0.225312055012178104725014013952277554782118447807246757600) < DBL_EPSILON);
-  assert(std::fabs(erfInv(0.999999) - 3.458910737279500022150927635957569519915669808042886747076) < 10E-6);
-  assert(std::fabs(erfInv(0.123456) - 0.109850294001424923867673480939041914394684494884310054922) < DBL_EPSILON);
+  quiz_assert(erfInv(0.0) == 0.0);
+  quiz_assert(std::isinf(erfInv(1.0))  && erfInv(1.0) > 0.0);
+  quiz_assert(std::isinf(erfInv(-1.0)) && erfInv(-1.0) < 0.0);
+  quiz_assert(std::fabs(erfInv(0.5) - 0.476936276204469873381418353643130559808969749059470644703) < DBL_EPSILON);
+  quiz_assert(std::fabs(erfInv(0.25) - 0.225312055012178104725014013952277554782118447807246757600) < DBL_EPSILON);
+  quiz_assert(std::fabs(erfInv(0.999999) - 3.458910737279500022150927635957569519915669808042886747076) < 10E-6);
+  quiz_assert(std::fabs(erfInv(0.123456) - 0.109850294001424923867673480939041914394684494884310054922) < DBL_EPSILON);

 }

--- a/apps/regression/test/model.cpp
+++ b/apps/regression/test/model.cpp
@@ -30,7 +30,7 @@ void assert_regression_is(double * xi, double * yi, int numberOfPoints, Model::T
  // Comapre the coefficients
  int numberOfCoefs = store.modelForSeries(series)->numberOfCoefficients();
  for (int i = 0; i < numberOfCoefs; i++) {
-    assert(std::fabs(coefficients[i] - trueCoefficients[i]) < precision);
+    quiz_assert(std::fabs(coefficients[i] - trueCoefficients[i]) < precision);
  }
 }

--- a/apps/sequence/test/sequence.cpp
+++ b/apps/sequence/test/sequence.cpp
@@ -18,7 +18,7 @@ void check_sequences_defined_by(double result[2][10], Sequence::Type typeU, cons
  Sequence * v = nullptr;
  if (definitionU) {
    u = static_cast<Sequence *>(store.addEmptyModel());
-    assert(u->name()[0] == 'u');
+    quiz_assert(u->name()[0] == 'u');
    u->setType(typeU);
    u->setContent(definitionU);
    if (conditionU1) {
@@ -35,7 +35,7 @@ void check_sequences_defined_by(double result[2][10], Sequence::Type typeU, cons
      store.removeModel(tempU);
      v = store.modelAtIndex(0);
    } else {
-      assert(store.numberOfModels() == 1);
+      quiz_assert(store.numberOfModels() == 1);
      v = static_cast<Sequence *>(store.addEmptyModel());
    }
    v->setType(typeV);
@@ -50,11 +50,11 @@ void check_sequences_defined_by(double result[2][10], Sequence::Type typeU, cons
  for (int j = 0; j < 10; j++) {
    if (u && u->isDefined()) {
      double un = u->evaluateAtAbscissa((double)j, &sequenceContext);
-      assert((std::isnan(un) && std::isnan(result[0][j])) || (un == result[0][j]));
+      quiz_assert((std::isnan(un) && std::isnan(result[0][j])) || (un == result[0][j]));
    }
    if (v && v->isDefined()) {
      double vn = v->evaluateAtAbscissa((double)j, &sequenceContext);
-      assert((std::isnan(vn) && std::isnan(result[1][j])) || (vn == result[1][j]));
+      quiz_assert((std::isnan(vn) && std::isnan(result[1][j])) || (vn == result[1][j]));
    }
  }
 }
--- a/apps/solver/test/equation_store.cpp
+++ b/apps/solver/test/equation_store.cpp
@@ -22,27 +22,27 @@ void assert_equation_system_exact_solve_to(const char * equations[], EquationSto
    e->setContent(buffer);
  }
  EquationStore::Error err = equationStore.exactSolve(&globalContext);
-  assert(err == error);
+  quiz_assert(err == error);
  if (err != EquationStore::Error::NoError) {
    return;
  }
-  assert(equationStore.type() == type);
-  assert(equationStore.numberOfSolutions() == numberOfSolutions);
+  quiz_assert(equationStore.type() == type);
+  quiz_assert(equationStore.numberOfSolutions() == numberOfSolutions);
  if (numberOfSolutions == INT_MAX) {
    return;
  }
  if (type == EquationStore::Type::LinearSystem) {
    for (int i = 0; i < numberOfSolutions; i++) {
-      assert(equationStore.variableAtIndex(i) == variables[i]);
+      quiz_assert(equationStore.variableAtIndex(i) == variables[i]);
    }
  } else {
-    assert(equationStore.variableAtIndex(0) == variables[0]);
+    quiz_assert(equationStore.variableAtIndex(0) == variables[0]);
  }
  int n = type == EquationStore::Type::PolynomialMonovariable ? numberOfSolutions+1 : numberOfSolutions; // Check Delta for PolynomialMonovariable
  for (int i = 0; i < n; i++) {
    equationStore.exactSolutionLayoutAtIndex(i, true)->serialize(buffer, 200);
    translate_in_ASCII_chars(buffer);
-    assert(strcmp(buffer, solutions[i]) == 0);
+    quiz_assert(strcmp(buffer, solutions[i]) == 0);
  }
 }

@@ -55,16 +55,16 @@ void assert_equation_approximate_solve_to(const char * equations, double xMin, d
  translate_in_special_chars(buffer);
  e->setContent(buffer);
  EquationStore::Error err = equationStore.exactSolve(&globalContext);
-  assert(err == EquationStore::Error::RequireApproximateSolution);
+  quiz_assert(err == EquationStore::Error::RequireApproximateSolution);
  equationStore.setIntervalBound(0, xMin);
  equationStore.setIntervalBound(1, xMax);
  equationStore.approximateSolve(&globalContext);
-  assert(equationStore.numberOfSolutions() == numberOfSolutions);
-  assert(equationStore.variableAtIndex(0) == variable);
+  quiz_assert(equationStore.numberOfSolutions() == numberOfSolutions);
+  quiz_assert(equationStore.variableAtIndex(0) == variable);
  for (int i = 0; i < numberOfSolutions; i++) {
-    assert(std::fabs(equationStore.approximateSolutionAtIndex(i) - solutions[i]) < 1E-5);
+    quiz_assert(std::fabs(equationStore.approximateSolutionAtIndex(i) - solutions[i]) < 1E-5);
  }
-  assert(equationStore.haveMoreApproximationSolutions(&globalContext) == hasMoreSolutions);
+  quiz_assert(equationStore.haveMoreApproximationSolutions(&globalContext) == hasMoreSolutions);
 }

 QUIZ_CASE(equation_solve) {
--- a/ion/test/crc32.cpp
+++ b/ion/test/crc32.cpp
@@ -4,7 +4,7 @@

 QUIZ_CASE(ion_crc32) {
  uint32_t input[] = { 0x48656C6C, 0x6F2C2077 };
-  assert(Ion::crc32(input, 1) == 0x93591FFD);
-  assert(Ion::crc32(input, 2) == 0x72EAD3FB);
+  quiz_assert(Ion::crc32(input, 1) == 0x93591FFD);
+  quiz_assert(Ion::crc32(input, 2) == 0x72EAD3FB);
 }

--- a/ion/test/events.cpp
+++ b/ion/test/events.cpp
@@ -8,15 +8,15 @@ using namespace Ion::Events;
 QUIZ_CASE(ion_events_from_keyboard) {
  /* Ensure all events generated from the keyboard are properly defined */
  for (Key k : ValidKeys) {
-    assert(Event(k, false, false).isDefined());
-    assert(Event(k, true, false).isDefined());
-    assert(Event(k, false, true).isDefined());
-    assert(Event(k, true, true).isDefined());
+    quiz_assert(Event(k, false, false).isDefined());
+    quiz_assert(Event(k, true, false).isDefined());
+    quiz_assert(Event(k, false, true).isDefined());
+    quiz_assert(Event(k, true, true).isDefined());
  }

  // Test some fallbacks
-  assert(Event(Key::I5, false, false) == EXE);
-  assert(Event(Key::I5, true, false) == EXE);
-  assert(Event(Key::I5, false, true) == EXE);
-  assert(Event(Key::I5, true, true) == EXE);
+  quiz_assert(Event(Key::I5, false, false) == EXE);
+  quiz_assert(Event(Key::I5, true, false) == EXE);
+  quiz_assert(Event(Key::I5, false, true) == EXE);
+  quiz_assert(Event(Key::I5, true, true) == EXE);
 }
--- a/ion/test/keyboard.cpp
+++ b/ion/test/keyboard.cpp
@@ -7,7 +7,7 @@ using namespace Ion::Keyboard;
 QUIZ_CASE(ion_keyboard) {
  for (Key k : ValidKeys) {
    for (Key l : ValidKeys) {
-      assert(State(k).keyDown(l) == (k == l));
+      quiz_assert(State(k).keyDown(l) == (k == l));
    }
  }
 }
--- a/kandinsky/test/color.cpp
+++ b/kandinsky/test/color.cpp
@@ -3,24 +3,24 @@
 #include <assert.h>

 QUIZ_CASE(kandinsky_color_rgb) {
-  assert(sizeof(KDColor) == 2); // We really want KDColor to be packed
+  quiz_assert(sizeof(KDColor) == 2); // We really want KDColor to be packed

-  assert(KDColor::RGB24(0xFF0000) == 0xF800);
-  assert(KDColor::RGB24(0x00FF00) == 0x07E0);
-  assert(KDColor::RGB24(0x0000FF) == 0x1F);
+  quiz_assert(KDColor::RGB24(0xFF0000) == 0xF800);
+  quiz_assert(KDColor::RGB24(0x00FF00) == 0x07E0);
+  quiz_assert(KDColor::RGB24(0x0000FF) == 0x1F);
  /* R = 0x12 = 0b 0001 0010. 5 most important bits are 00010.
   * G = 0x34 = 0b 0011 0100. 6 most important bits are 001101.
   * B = 0x56 = 0b 0101 0110. 5 most important bits are 01010.
   * KDColor = 0b 00010 001101 01010
   *         = 0b 0001 0001 1010 1010
   *         = 0x    1    1 A    A */
-  assert(KDColor::RGB24(0x123456) == 0x11AA);
+  quiz_assert(KDColor::RGB24(0x123456) == 0x11AA);
 }

 QUIZ_CASE(kandinsky_color_blend) {
  KDColor midGray = KDColor::RGB24(0x7F7F7F);
  KDColor res = KDColor::blend(KDColorWhite, KDColorBlack, 0xFF);
-  assert(res == KDColorWhite);
-  assert(KDColor::blend(KDColorWhite, KDColorBlack, 0) == KDColorBlack);
-  assert(KDColor::blend(KDColorWhite, KDColorBlack, 0x7F) == midGray);
+  quiz_assert(res == KDColorWhite);
+  quiz_assert(KDColor::blend(KDColorWhite, KDColorBlack, 0) == KDColorBlack);
+  quiz_assert(KDColor::blend(KDColorWhite, KDColorBlack, 0x7F) == midGray);
 }
--- a/kandinsky/test/rect.cpp
+++ b/kandinsky/test/rect.cpp
@@ -5,20 +5,20 @@
 QUIZ_CASE(kandinsky_rect_intersect) {
  KDRect a(-5,-5, 10, 10);
  KDRect b(0, 0, 10, 10);
-  assert(a.intersects(b));
-  assert(b.intersects(a));
+  quiz_assert(a.intersects(b));
+  quiz_assert(b.intersects(a));
  KDRect c = a.intersectedWith(b);
  KDRect result(0, 0, 5, 5);
-  assert(c == result);
+  quiz_assert(c == result);
  c = b.intersectedWith(a);
-  assert(c == result);
+  quiz_assert(c == result);
 }

 QUIZ_CASE(kandinsky_rect_union) {
  KDRect a(-5, -5, 10, 10);
  KDRect b(0, 0, 10, 10);
  KDRect c = a.unionedWith(b);
-  assert(c == KDRect(-5, -5, 15, 15));
+  quiz_assert(c == KDRect(-5, -5, 15, 15));
 }

 QUIZ_CASE(kandinsky_rect_empty_union) {
@@ -27,13 +27,13 @@ QUIZ_CASE(kandinsky_rect_empty_union) {
  KDRect c(-2, -1, 0, 1);

  KDRect t = a.unionedWith(b);
-  assert(t == a);
+  quiz_assert(t == a);

  t = b.unionedWith(a);
-  assert(t == a);
+  quiz_assert(t == a);

  t = a.unionedWith(c);
-  assert(t == a);
+  quiz_assert(t == a);
 }

 QUIZ_CASE(kandinsky_rect_difference) {
@@ -45,35 +45,35 @@ QUIZ_CASE(kandinsky_rect_difference) {
  KDRect f(2, -4, 3, 3);

  KDRect t = e.differencedWith(a);
-  assert(t == e);
+  quiz_assert(t == e);

  t = a.differencedWith(e);
-  assert(t == KDRectZero);
+  quiz_assert(t == KDRectZero);

  t = f.differencedWith(d);
-  assert(t == f);
+  quiz_assert(t == f);

  t = f.differencedWith(e);
-  assert(t == f);
+  quiz_assert(t == f);

  t = b.differencedWith(e);
-  assert(t == b);
+  quiz_assert(t == b);

  t = c.differencedWith(f);
-  assert(t == KDRect(3, -1, 1, 4));
+  quiz_assert(t == KDRect(3, -1, 1, 4));

  t = c.differencedWith(a);
-  assert(t == c);
+  quiz_assert(t == c);

  t = c.differencedWith(e);
-  assert(t == KDRect(3, -2, 1, 1));
+  quiz_assert(t == KDRect(3, -2, 1, 1));

  t = a.differencedWith(b);
-  assert(t == KDRect(0, 0, 10, 2));
+  quiz_assert(t == KDRect(0, 0, 10, 2));

  t = a.differencedWith(c);
-  assert(t == a);
+  quiz_assert(t == a);

  t = a.differencedWith(d);
-  assert(t == KDRect(-1, 0, 8, 2));
+  quiz_assert(t == KDRect(-1, 0, 8, 2));
 }
--- a/liba/test/aeabi.c
+++ b/liba/test/aeabi.c
@@ -6,37 +6,37 @@ long long __aeabi_llsl(long long value, int shift);
 long long __aeabi_llsr(long long value, int shift);

 QUIZ_CASE(liba_llsl) {
-  assert(__aeabi_llsl((uint64_t)1, 1) == (uint64_t)0x2);
-  assert(__aeabi_llsl((uint64_t)1, 2) == (uint64_t)0x4);
-  assert(__aeabi_llsl((uint64_t)1, 10) == (uint64_t)0x400);
-  assert(__aeabi_llsl((uint64_t)1, 20) == (uint64_t)0x100000);
-  assert(__aeabi_llsl((uint64_t)1, 30) == (uint64_t)0x40000000);
-  assert(__aeabi_llsl((uint64_t)1, 31) == (uint64_t)0x80000000);
-  assert(__aeabi_llsl((uint64_t)1, 32) == (uint64_t)0x100000000);
-  assert(__aeabi_llsl((uint64_t)1, 33) == (uint64_t)0x200000000);
-  assert(__aeabi_llsl((uint64_t)1, 40) == (uint64_t)0x10000000000);
-  assert(__aeabi_llsl((uint64_t)1, 50) == (uint64_t)0x4000000000000);
-  assert(__aeabi_llsl((uint64_t)1, 60) == (uint64_t)0x1000000000000000);
-  assert(__aeabi_llsl((uint64_t)1, 61) == (uint64_t)0x2000000000000000);
-  assert(__aeabi_llsl((uint64_t)1, 62) == (uint64_t)0x4000000000000000);
-  assert(__aeabi_llsl((uint64_t)1, 63) == (uint64_t)0x8000000000000000);
-  assert(__aeabi_llsl((uint64_t)1, 64) == (uint64_t)0);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 1) == (uint64_t)0x2);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 2) == (uint64_t)0x4);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 10) == (uint64_t)0x400);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 20) == (uint64_t)0x100000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 30) == (uint64_t)0x40000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 31) == (uint64_t)0x80000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 32) == (uint64_t)0x100000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 33) == (uint64_t)0x200000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 40) == (uint64_t)0x10000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 50) == (uint64_t)0x4000000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 60) == (uint64_t)0x1000000000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 61) == (uint64_t)0x2000000000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 62) == (uint64_t)0x4000000000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 63) == (uint64_t)0x8000000000000000);
+  quiz_assert(__aeabi_llsl((uint64_t)1, 64) == (uint64_t)0);
 }

 QUIZ_CASE(liba_llsr) {
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 1) == (uint64_t)0x4000000000000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 2) == (uint64_t)0x2000000000000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 10) == (uint64_t)0x20000000000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 20) == (uint64_t)0x80000000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 30) == (uint64_t)0x200000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 31) == (uint64_t)0x100000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 32) == (uint64_t)0x80000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 33) == (uint64_t)0x40000000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 40) == (uint64_t)0x800000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 50) == (uint64_t)0x2000);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 60) == (uint64_t)0x8);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 61) == (uint64_t)0x4);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 62) == (uint64_t)0x2);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 63) == (uint64_t)0x1);
-  assert(__aeabi_llsr((uint64_t)0x8000000000000000, 64) == (uint64_t)0);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 1) == (uint64_t)0x4000000000000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 2) == (uint64_t)0x2000000000000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 10) == (uint64_t)0x20000000000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 20) == (uint64_t)0x80000000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 30) == (uint64_t)0x200000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 31) == (uint64_t)0x100000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 32) == (uint64_t)0x80000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 33) == (uint64_t)0x40000000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 40) == (uint64_t)0x800000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 50) == (uint64_t)0x2000);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 60) == (uint64_t)0x8);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 61) == (uint64_t)0x4);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 62) == (uint64_t)0x2);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 63) == (uint64_t)0x1);
+  quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 64) == (uint64_t)0);
 }
--- a/liba/test/double.c
+++ b/liba/test/double.c
@@ -2,17 +2,17 @@
 #include <assert.h>

 QUIZ_CASE(double_arithmetic) {
-  assert((float)1.123456789101112 == 1.123456789101112f);
-  assert((double)1.12345f - 1.12345< 0.0000001);
-  assert(3.12+2.00001 - 5.12001 < 0.0000000001);
-  assert(1e106+1e104 - 1.01e106 < 0.0000000001);
-  assert(1e-106+1e-104 - 1.01e104 < 0.0000000001);
-  assert(3.12345678901234567890/2.0000000000000001 - 1.56172839450617276136 < 0.0000000001);
-  assert(1.09876e206/2.45678e207 - 0.04472358127304846180773 < 0.0000000001);
-  assert(3.12345678901234567890*2.0000000000000001 - 6.24691357802469167014 < 0.0000000001);
-  assert(1.09876e106*2.45678e107 - 2.6994115928e213 < 0.0000000001);
-  assert(-3.12345678901234567890+2.0000000000000001 == -1.1234567890123457);
-  assert(-1e36+1e34 + 9.9e35 < 0.0000000001);
-  assert(3.12345678901234567890-2.0000000000000001 == 1.1234567890123457);
-  assert(1e36-1e34 - 9.9e35 < 0.0000000001);
+  quiz_assert((float)1.123456789101112 == 1.123456789101112f);
+  quiz_assert((double)1.12345f - 1.12345< 0.0000001);
+  quiz_assert(3.12+2.00001 - 5.12001 < 0.0000000001);
+  quiz_assert(1e106+1e104 - 1.01e106 < 0.0000000001);
+  quiz_assert(1e-106+1e-104 - 1.01e104 < 0.0000000001);
+  quiz_assert(3.12345678901234567890/2.0000000000000001 - 1.56172839450617276136 < 0.0000000001);
+  quiz_assert(1.09876e206/2.45678e207 - 0.04472358127304846180773 < 0.0000000001);
+  quiz_assert(3.12345678901234567890*2.0000000000000001 - 6.24691357802469167014 < 0.0000000001);
+  quiz_assert(1.09876e106*2.45678e107 - 2.6994115928e213 < 0.0000000001);
+  quiz_assert(-3.12345678901234567890+2.0000000000000001 == -1.1234567890123457);
+  quiz_assert(-1e36+1e34 + 9.9e35 < 0.0000000001);
+  quiz_assert(3.12345678901234567890-2.0000000000000001 == 1.1234567890123457);
+  quiz_assert(1e36-1e34 - 9.9e35 < 0.0000000001);
 }
--- a/liba/test/ieee754.c
+++ b/liba/test/ieee754.c
@@ -4,18 +4,18 @@
 #include <private/ieee754.h>

 QUIZ_CASE(liba_ieee754) {
-  assert(ieee754man32(123.456f) == 7793017);
-  assert(ieee754exp32(123.456f) == 133);
-  assert(ieee754man32(555.555f) == 713605);
-  assert(ieee754exp32(555.555f) == 136);
-  assert(ieee754man32(0.007f) == 6643778);
-  assert(ieee754exp32(0.007f) == 119);
-  assert(ieee754man64(123.456) == 0b1110110111010010111100011010100111111011111001110111);
-  assert(ieee754exp64(123.456) == 0b10000000101);
-  assert(ieee754man64(555.555) == 0b0001010111000111000010100011110101110000101000111101);
-  assert(ieee754exp64(555.555) == 0b10000001000);
-  assert(ieee754man64(0.007) == 0b1100101011000000100000110001001001101110100101111001);
-  assert(ieee754exp64(0.007) == 0b01111110111);
-  assert(isinf(INFINITY));
-  assert(isinf((double)INFINITY));
+  quiz_assert(ieee754man32(123.456f) == 7793017);
+  quiz_assert(ieee754exp32(123.456f) == 133);
+  quiz_assert(ieee754man32(555.555f) == 713605);
+  quiz_assert(ieee754exp32(555.555f) == 136);
+  quiz_assert(ieee754man32(0.007f) == 6643778);
+  quiz_assert(ieee754exp32(0.007f) == 119);
+  quiz_assert(ieee754man64(123.456) == 0b1110110111010010111100011010100111111011111001110111);
+  quiz_assert(ieee754exp64(123.456) == 0b10000000101);
+  quiz_assert(ieee754man64(555.555) == 0b0001010111000111000010100011110101110000101000111101);
+  quiz_assert(ieee754exp64(555.555) == 0b10000001000);
+  quiz_assert(ieee754man64(0.007) == 0b1100101011000000100000110001001001101110100101111001);
+  quiz_assert(ieee754exp64(0.007) == 0b01111110111);
+  quiz_assert(isinf(INFINITY));
+  quiz_assert(isinf((double)INFINITY));
 }
--- a/liba/test/long.c
+++ b/liba/test/long.c
@@ -3,14 +3,14 @@
 #include <assert.h>

 void assert_int64t_approximatively_equals_int64t(int64_t i, int64_t j) {
-  assert(i-j < 1000000);
-  assert(j-i < 1000000);
+  quiz_assert(i-j < 1000000);
+  quiz_assert(j-i < 1000000);
 }

 QUIZ_CASE(long_arithmetic) {
  int64_t i = 123456789101112;
-  assert((float)i == 1.23456789101112e14f);
-  assert((double)i == 1.23456789101112e14);
+  quiz_assert((float)i == 1.23456789101112e14f);
+  quiz_assert((double)i == 1.23456789101112e14);
  float f = 123456789101112.12345f;
  assert_int64t_approximatively_equals_int64t((int64_t)f, 123456789101112);
  double d = 123456789101112.12345f;
--- a/liba/test/setjmp.c
+++ b/liba/test/setjmp.c
@@ -10,5 +10,5 @@ QUIZ_CASE(set_jmp_long_jmp) {
  }
  int newres = (0 == res) ? res : res + 1;
  longjmp(env, newres);
-  assert(false);
+  quiz_assert(false);
 }
--- a/liba/test/stddef.c
+++ b/liba/test/stddef.c
@@ -4,10 +4,10 @@
 #include "helpers.h"

 QUIZ_CASE(liba_stddef) {
-  assert(NULL == 0);
+  quiz_assert(NULL == 0);

  assert_unsigned(size_t);
-  assert(sizeof(size_t) == __SIZEOF_SIZE_T__);
+  quiz_assert(sizeof(size_t) == __SIZEOF_SIZE_T__);
  assert_signed(ssize_t);
-  assert(sizeof(ssize_t) == __SIZEOF_SIZE_T__);
+  quiz_assert(sizeof(ssize_t) == __SIZEOF_SIZE_T__);
 }
--- a/liba/test/stdint.c
+++ b/liba/test/stdint.c
@@ -4,18 +4,18 @@
 #include "helpers.h"

 QUIZ_CASE(liba_stdint_size) {
-  assert(sizeof(uint8_t) == 1);
-  assert(sizeof(uint16_t) == 2);
-  assert(sizeof(uint32_t) == 4);
-  assert(sizeof(uint64_t) == 8);
+  quiz_assert(sizeof(uint8_t) == 1);
+  quiz_assert(sizeof(uint16_t) == 2);
+  quiz_assert(sizeof(uint32_t) == 4);
+  quiz_assert(sizeof(uint64_t) == 8);

-  assert(sizeof(int8_t) == 1);
-  assert(sizeof(int16_t) == 2);
-  assert(sizeof(int32_t) == 4);
-  assert(sizeof(int64_t) == 8);
+  quiz_assert(sizeof(int8_t) == 1);
+  quiz_assert(sizeof(int16_t) == 2);
+  quiz_assert(sizeof(int32_t) == 4);
+  quiz_assert(sizeof(int64_t) == 8);

-  assert(sizeof(uintptr_t) == sizeof(void *));
-  assert(sizeof(intptr_t) == sizeof(void *));
+  quiz_assert(sizeof(uintptr_t) == sizeof(void *));
+  quiz_assert(sizeof(intptr_t) == sizeof(void *));
 }

 QUIZ_CASE(liba_stdint_signedness) {
--- a/liba/test/strlcpy.c
+++ b/liba/test/strlcpy.c
@@ -6,7 +6,7 @@ QUIZ_CASE(liba_strlcpy) {
  char * t = "Hello";
  char buffer[16];
  size_t result = strlcpy(buffer, t, 2);
-  assert(result == 1);
-  assert(buffer[0] == 'H');
-  assert(buffer[1] == NULL);
+  quiz_assert(result == 1);
+  quiz_assert(buffer[0] == 'H');
+  quiz_assert(buffer[1] == NULL);
 }
--- a/poincare/test/addition.cpp
+++ b/poincare/test/addition.cpp
@@ -9,13 +9,13 @@ using namespace Poincare;

 static inline void assert_approximation_equals(const Expression i, float f) {
  Poincare::GlobalContext c;
-  assert(i.approximateToScalar<float>(c, Preferences::AngleUnit::Degree) == f);
+  quiz_assert(i.approximateToScalar<float>(c, Preferences::AngleUnit::Degree) == f);
 }

 static inline void assert_parsed_expression_is_equal_to(const char * exp, Expression e) {
  Expression result = Expression::parse(exp);
-  assert(!result.isUninitialized());
-  assert(result.isIdenticalTo(e));
+  quiz_assert(!result.isUninitialized());
+  quiz_assert(result.isIdenticalTo(e));
 }

 QUIZ_CASE(poincare_addition_cast_does_not_copy) {
@@ -23,9 +23,9 @@ QUIZ_CASE(poincare_addition_cast_does_not_copy) {
  Integer i2(2);
  Addition j(i1, i2);
  Expression k = j;
-  assert(k.identifier() == (static_cast<Addition&>(k)).identifier());
-  assert(i1.identifier() == (static_cast<Expression&>(i1)).identifier());
-  assert(k.identifier() == (static_cast<Expression&>(k)).identifier());
+  quiz_assert(k.identifier() == (static_cast<Addition&>(k)).identifier());
+  quiz_assert(i1.identifier() == (static_cast<Expression&>(i1)).identifier());
+  quiz_assert(k.identifier() == (static_cast<Expression&>(k)).identifier());
 }

 QUIZ_CASE(poincare_addition_without_parsing) {
--- a/poincare/test/arithmetic.cpp
+++ b/poincare/test/arithmetic.cpp
@@ -22,7 +22,7 @@ void assert_gcd_equals_to(Integer a, Integer b, Integer c) {
 #if POINCARE_TESTS_PRINT_EXPRESSIONS
  cout << gcd.approximate<float>() << endl;
 #endif
-  assert(gcd.isEqualTo(c));
+  quiz_assert(gcd.isEqualTo(c));
 }

 void assert_lcm_equals_to(Integer a, Integer b, Integer c) {
@@ -35,7 +35,7 @@ void assert_lcm_equals_to(Integer a, Integer b, Integer c) {
 #if POINCARE_TESTS_PRINT_EXPRESSIONS
  cout << lcm.approximate<float>() << endl;
 #endif
-  assert(lcm.isEqualTo(c));
+  quiz_assert(lcm.isEqualTo(c));
 }

 void assert_prime_factorization_equals_to(Integer a, int * factors, int * coefficients, int length) {
@@ -57,8 +57,8 @@ void assert_prime_factorization_equals_to(Integer a, int * factors, int * coeffi
     * (the relation between integers and their approximation is a surjection,
     * however different integers are really likely to have different
     * approximations... */
-    assert(outputFactors[index].approximate<float>() == Integer(factors[index]).approximate<float>());
-    assert(outputCoefficients[index].approximate<float>() == Integer(coefficients[index]).approximate<float>());
+    quiz_assert(outputFactors[index].approximate<float>() == Integer(factors[index]).approximate<float>());
+    quiz_assert(outputCoefficients[index].approximate<float>() == Integer(coefficients[index]).approximate<float>());
  }
 }

--- a/poincare/test/convert_expression_to_text.cpp
+++ b/poincare/test/convert_expression_to_text.cpp
@@ -22,14 +22,14 @@ void assert_float_prints_to(T a, const char * result, Preferences::PrintFloatMod
  PrintFloat::convertFloatToText<T>(a, buffer, bufferSize, significantDigits, mode);

  for (int i=0; i<tagSize; i++) {
-    assert(taggedBuffer[i] == tag);
+    quiz_assert(taggedBuffer[i] == tag);
  }
  for (int i=tagSize+strlen(buffer)+1; i<bufferSize+2*tagSize; i++) {
-    assert(taggedBuffer[i] == tag);
+    quiz_assert(taggedBuffer[i] == tag);
  }
  translate_in_ASCII_chars(buffer);

-  assert(strcmp(buffer, result) == 0);
+  quiz_assert(strcmp(buffer, result) == 0);

  delete[] taggedBuffer;
 }
@@ -47,13 +47,13 @@ void assert_expression_prints_to(Expression * e, const char * result, Preference
  translate_in_ASCII_chars(buffer);

  for (int i=0; i<tagSize; i++) {
-    assert(taggedBuffer[i] == tag || taggedBuffer[i] == 0);
+    quiz_assert(taggedBuffer[i] == tag || taggedBuffer[i] == 0);
  }
  for (int i=tagSize+strlen(buffer)+1; i<bufferSize+2*tagSize; i++) {
-    assert(taggedBuffer[i] == tag || taggedBuffer[i] == 0);
+    quiz_assert(taggedBuffer[i] == tag || taggedBuffer[i] == 0);
  }

-  assert(strcmp(buffer, result) == 0);
+  quiz_assert(strcmp(buffer, result) == 0);

  delete[] taggedBuffer;
 }
--- a/poincare/test/fraction_layout.cpp
+++ b/poincare/test/fraction_layout.cpp
@@ -17,7 +17,7 @@ QUIZ_CASE(poincare_fraction_layout_create) {
  ExpressionLayoutCursor cursor(layout->editableChild(2), ExpressionLayoutCursor::Position::Left);
  cursor.addFractionLayoutAndCollapseSiblings();
  assert_expression_layout_serialize_to(layout, "(12)/(34)+5");
-  assert(cursor.isEquivalentTo(ExpressionLayoutCursor(layout->editableChild(0)->editableChild(1), ExpressionLayoutCursor::Position::Left)));
+  quiz_assert(cursor.isEquivalentTo(ExpressionLayoutCursor(layout->editableChild(0)->editableChild(1), ExpressionLayoutCursor::Position::Left)));
  delete layout;
 }

@@ -36,7 +36,7 @@ QUIZ_CASE(poincare_fraction_layout_delete) {
  ExpressionLayoutCursor cursor1(layout1->editableChild(0)->editableChild(1), ExpressionLayoutCursor::Position::Left);
  cursor1.performBackspace();
  assert_expression_layout_serialize_to(layout1, "1234");
-  assert(cursor1.isEquivalentTo(ExpressionLayoutCursor(layout1->editableChild(1), ExpressionLayoutCursor::Position::Right)));
+  quiz_assert(cursor1.isEquivalentTo(ExpressionLayoutCursor(layout1->editableChild(1), ExpressionLayoutCursor::Position::Right)));
  delete layout1;

  /*      ø
@@ -54,7 +54,7 @@ QUIZ_CASE(poincare_fraction_layout_delete) {
  ExpressionLayoutCursor cursor2(layout2->editableChild(2)->editableChild(1), ExpressionLayoutCursor::Position::Left);
  cursor2.performBackspace();
  assert_expression_layout_serialize_to(layout2, "1+3");
-  assert(cursor2.isEquivalentTo(ExpressionLayoutCursor(layout2->editableChild(1), ExpressionLayoutCursor::Position::Right)));
+  quiz_assert(cursor2.isEquivalentTo(ExpressionLayoutCursor(layout2->editableChild(1), ExpressionLayoutCursor::Position::Right)));
  delete layout2;
 }

--- a/poincare/test/function.cpp
+++ b/poincare/test/function.cpp
@@ -11,8 +11,8 @@ template<typename T>
 void assert_exp_is_bounded(Expression exp, T lowBound, T upBound, bool upBoundIncluded = false) {
  GlobalContext globalContext;
  T result = exp.approximateToScalar<T>(globalContext, Radian);
-  assert(result >= lowBound);
-  assert(result < upBound || (result == upBound && upBoundIncluded));
+  quiz_assert(result >= lowBound);
+  quiz_assert(result < upBound || (result == upBound && upBoundIncluded));
 }

 QUIZ_CASE(poincare_parse_function) {
--- a/poincare/test/helper.cpp
+++ b/poincare/test/helper.cpp
@@ -49,25 +49,25 @@ Expression parse_expression(const char * expression) {
  strlcpy(buffer, expression, sizeof(buffer));
  translate_in_special_chars(buffer);
  Expression result = Expression::parse(buffer);
-  assert(!result.isUninitialized());
+  quiz_assert(!result.isUninitialized());
  return result;
 }

 void assert_parsed_expression_type(const char * expression, Poincare::ExpressionNode::Type type) {
  Expression e = parse_expression(expression);
-  assert(e.type() == type);
+  quiz_assert(e.type() == type);
 }

 void assert_parsed_expression_is(const char * expression, Poincare::Expression r) {
  Expression e = parse_expression(expression);
-  assert(e.isIdenticalTo(r));
+  quiz_assert(e.isIdenticalTo(r));
 }

 void assert_parsed_expression_polynomial_degree(const char * expression, int degree, char symbolName) {
  GlobalContext globalContext;
  Expression e = parse_expression(expression);
  e = e.simplify(globalContext, Radian);
-  assert(e.polynomialDegree(symbolName) == degree);
+  quiz_assert(e.polynomialDegree(symbolName) == degree);
 }

 typedef Expression (*ProcessExpression)(Expression, Context & context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat);
@@ -87,7 +87,7 @@ void assert_parsed_expression_process_to(const char * expression, const char * r
  cout << "---- serialize to: " << buffer << " ----"  << endl;
  cout << "----- compared to: " << result << " ----\n"  << endl;
 #endif
-  assert(strcmp(buffer, result) == 0);
+  quiz_assert(strcmp(buffer, result) == 0);
 }

 template<typename T>
@@ -115,7 +115,7 @@ void assert_parsed_expression_serialize_to(Expression expression, const char * s
 #endif
  char buffer[500];
  expression.serialize(buffer, sizeof(buffer), mode, numberOfSignifiantDigits);
-  assert(strcmp(buffer, serializedExpression) == 0);
+  quiz_assert(strcmp(buffer, serializedExpression) == 0);
 }

 #if 0
@@ -131,7 +131,7 @@ void assert_parsed_expression_layout_serialize_to_self(const char * expressionLa
 #if POINCARE_TESTS_PRINT_EXPRESSIONS
  cout << "---- serialized to: " << buffer << " ----\n"  << endl;
 #endif
-  assert(strcmp(expressionLayout, buffer) == 0);
+  quiz_assert(strcmp(expressionLayout, buffer) == 0);
  delete e;
  delete el;
 }
@@ -145,7 +145,7 @@ void assert_expression_layout_serialize_to(Poincare::ExpressionLayout * layout,
  cout << "---- serialized to: " << buffer << " ----"  << endl;
  cout << "----- compared to: " << serialization << " ----\n"  << endl;
 #endif
-  assert(strcmp(serialization, buffer) == 0);
+  quiz_assert(strcmp(serialization, buffer) == 0);
 }

 #endif
--- a/poincare/test/identity.cpp
+++ b/poincare/test/identity.cpp
@@ -3,34 +3,34 @@
 #include "simplify_utils.h"

 QUIZ_CASE(poincare_identity_simple_term) {
-  assert(identical_to("1", "1"));
-  assert(!identical_to("1", "2"));
+  quiz_assert(identical_to("1", "1"));
+  quiz_assert(!identical_to("1", "2"));

-  assert(identical_to("A", "A"));
-  assert(!identical_to("A", "B"));
+  quiz_assert(identical_to("A", "A"));
+  quiz_assert(!identical_to("A", "B"));

-  assert(identical_to("1+2", "1+2"));
-  assert(!identical_to("1+2", "1+3"));
+  quiz_assert(identical_to("1+2", "1+2"));
+  quiz_assert(!identical_to("1+2", "1+3"));

-  assert(identical_to("1-2", "1-2"));
-  assert(!identical_to("1-2", "1-3"));
+  quiz_assert(identical_to("1-2", "1-2"));
+  quiz_assert(!identical_to("1-2", "1-3"));

-  assert(identical_to("1*2", "1*2"));
-  assert(!identical_to("1*2", "1*3"));
+  quiz_assert(identical_to("1*2", "1*2"));
+  quiz_assert(!identical_to("1*2", "1*3"));

-  assert(identical_to("1/2", "1/2"));
-  assert(!identical_to("1/2", "1/3"));
+  quiz_assert(identical_to("1/2", "1/2"));
+  quiz_assert(!identical_to("1/2", "1/3"));

-  assert(identical_to("1^2", "1^2"));
-  assert(!identical_to("1^2", "1^3"));
+  quiz_assert(identical_to("1^2", "1^2"));
+  quiz_assert(!identical_to("1^2", "1^3"));

-  assert(identical_to("cos(1)", "cos(1)"));
-  assert(!identical_to("cos(1)", "cos(2)"));
+  quiz_assert(identical_to("cos(1)", "cos(1)"));
+  quiz_assert(!identical_to("cos(1)", "cos(2)"));
 }

 QUIZ_CASE(poincare_identity_commutativity) {
-  assert(equivalent_to("1+2", "2+1"));
-  //assert(identical_to("1*2", "2*1"));
-  assert(!equivalent_to("1-2", "2-1"));
-  assert(!equivalent_to("1/2", "2/1"));
+  quiz_assert(equivalent_to("1+2", "2+1"));
+  //quiz_assert(identical_to("1*2", "2*1"));
+  quiz_assert(!equivalent_to("1-2", "2-1"));
+  quiz_assert(!equivalent_to("1/2", "2/1"));
 }
--- a/poincare/test/integer.cpp
+++ b/poincare/test/integer.cpp
@@ -26,18 +26,18 @@ QUIZ_CASE(poincare_integer_constructor) {
 }

 static inline void assert_equal(const Integer i, const Integer j) {
-  assert(Integer::NaturalOrder(i, j) == 0);
+  quiz_assert(Integer::NaturalOrder(i, j) == 0);
 }
 static inline void assert_not_equal(const Integer i, const Integer j) {
-  assert(Integer::NaturalOrder(i, j) != 0);
+  quiz_assert(Integer::NaturalOrder(i, j) != 0);
 }

 static inline void assert_lower(const Integer i, const Integer j) {
-  assert(Integer::NaturalOrder(i, j) < 0);
+  quiz_assert(Integer::NaturalOrder(i, j) < 0);
 }

 static inline void assert_greater(const Integer i, const Integer j) {
-  assert(Integer::NaturalOrder(i, j) > 0);
+  quiz_assert(Integer::NaturalOrder(i, j) > 0);
 }

 QUIZ_CASE(poincare_integer_compare) {
@@ -59,31 +59,31 @@ QUIZ_CASE(poincare_integer_compare) {
  assert_lower(Integer("-1234567891234567892109209109"), Integer("123456789123456789"));
  assert_greater(Integer("123456789123456789"), Integer("123456789123456788"));
  assert_greater(Integer::Overflow(), Integer("123456789123456788"));
-  //FIXME: assert(Integer("0x2BABE") == Integer(178878));
-  //FIXME: assert(Integer("0b1011") == Integer(11));
+  //FIXME: quiz_assert(Integer("0x2BABE") == Integer(178878));
+  //FIXME: quiz_assert(Integer("0b1011") == Integer(11));
 }

 QUIZ_CASE(poincare_integer_properties) {
-  assert(Integer(0).isZero());
-  assert(!Integer(-1).isZero());
-  assert(!Integer(1).isZero());
-  assert(Integer(1).isOne());
-  assert(!Integer(-1).isOne());
-  assert(!Integer(0).isOne());
-  assert(OverflowedInteger().isInfinity()); // 2^32^k_maxNumberOfDigits
-  assert(!MaxInteger().isInfinity()); // 2^32^k_maxNumberOfDigits-1
-  assert(!Integer(0).isInfinity());
-  assert(Integer(8).isEven());
-  assert(!Integer(7).isEven());
-  assert(Integer(-8).isEven());
-  assert(!Integer(-7).isEven());
-  assert(!Integer(2).isNegative());
-  assert(Integer(-2).isNegative());
-  assert(Integer::NumberOfBase10Digits(MaxInteger()) == 309);
+  quiz_assert(Integer(0).isZero());
+  quiz_assert(!Integer(-1).isZero());
+  quiz_assert(!Integer(1).isZero());
+  quiz_assert(Integer(1).isOne());
+  quiz_assert(!Integer(-1).isOne());
+  quiz_assert(!Integer(0).isOne());
+  quiz_assert(OverflowedInteger().isInfinity()); // 2^32^k_maxNumberOfDigits
+  quiz_assert(!MaxInteger().isInfinity()); // 2^32^k_maxNumberOfDigits-1
+  quiz_assert(!Integer(0).isInfinity());
+  quiz_assert(Integer(8).isEven());
+  quiz_assert(!Integer(7).isEven());
+  quiz_assert(Integer(-8).isEven());
+  quiz_assert(!Integer(-7).isEven());
+  quiz_assert(!Integer(2).isNegative());
+  quiz_assert(Integer(-2).isNegative());
+  quiz_assert(Integer::NumberOfBase10Digits(MaxInteger()) == 309);
 }

 static inline void assert_add_to(const Integer i, const Integer j, const Integer k) {
-  assert(Integer::NaturalOrder(Integer::Addition(i, j), k) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Addition(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_integer_addition) {
@@ -111,7 +111,7 @@ QUIZ_CASE(poincare_integer_addition) {
 }

 static inline void assert_sub_to(const Integer i, const Integer j, const Integer k) {
-  assert(Integer::NaturalOrder(Integer::Subtraction(i, j), k) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Subtraction(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_integer_subtraction) {
@@ -145,7 +145,7 @@ QUIZ_CASE(poincare_integer_subtraction) {
 }

 static inline void assert_mult_to(const Integer i, const Integer j, const Integer k) {
-  assert(Integer::NaturalOrder(Integer::Multiplication(i, j), k) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Multiplication(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_integer_multiplication) {
@@ -162,8 +162,8 @@ QUIZ_CASE(poincare_integer_multiplication) {
 }

 static inline void assert_div_to(const Integer i, const Integer j, const Integer q, const Integer r) {
-  assert(Integer::NaturalOrder(Integer::Division(i, j).quotient, q) == 0);
-  assert(Integer::NaturalOrder(Integer::Division(i, j).remainder, r) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Division(i, j).quotient, q) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Division(i, j).remainder, r) == 0);
 }

 QUIZ_CASE(poincare_integer_divide) {
@@ -193,7 +193,7 @@ QUIZ_CASE(poincare_integer_divide) {
 }

 static inline void assert_pow_to(const Integer i, const Integer j, const Integer k) {
-  assert(Integer::NaturalOrder(Integer::Power(i, j), k) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Power(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_integer_pow) {
@@ -202,7 +202,7 @@ QUIZ_CASE(poincare_integer_pow) {
 }

 static inline void assert_factorial_to(const Integer i, const Integer j) {
-  assert(Integer::NaturalOrder(Integer::Factorial(i), j) == 0);
+  quiz_assert(Integer::NaturalOrder(Integer::Factorial(i), j) == 0);
 }

 QUIZ_CASE(poincare_integer_factorial) {
@@ -223,7 +223,7 @@ QUIZ_CASE(poincare_integer_simplify) {
 template<typename T>
 void assert_integer_evals_to(const char * i, T result) {
  GlobalContext c;
-  assert(Integer(i).approximateToScalar<T>(c, Preferences::AngleUnit::Radian) == result);
+  quiz_assert(Integer(i).approximateToScalar<T>(c, Preferences::AngleUnit::Radian) == result);
 }

 QUIZ_CASE(poincare_integer_evaluate) {
--- a/poincare/test/parentheses_layout.cpp
+++ b/poincare/test/parentheses_layout.cpp
@@ -27,6 +27,6 @@ QUIZ_CASE(poincare_parenthesis_layout_size) {
  layout->addChildAtIndexInPlace(new CharLayout('6'), 5);
  layout->addChildAtIndexInPlace(rightPar, 7);
  layout->addChildAtIndexInPlace(new CharLayout('1'), 8);
-  assert(leftPar->size().height() == rightPar->size().height());
+  quiz_assert(leftPar->size().height() == rightPar->size().height());
  delete layout;
 }
--- a/poincare/test/properties.cpp
+++ b/poincare/test/properties.cpp
@@ -13,9 +13,9 @@ constexpr Poincare::ExpressionNode::Sign Unknown = Poincare::ExpressionNode::Sig
 void assert_parsed_expression_sign(const char * expression, Poincare::ExpressionNode::Sign sign) {
  GlobalContext globalContext;
  Expression e = parse_expression(expression);
-  assert(!e.isUninitialized());
+  quiz_assert(!e.isUninitialized());
  e = e.simplify(globalContext, Degree);
-  assert(e.sign() == sign);
+  quiz_assert(e.sign() == sign);
 }

 QUIZ_CASE(poincare_sign) {
@@ -59,12 +59,12 @@ QUIZ_CASE(poincare_polynomial_degree) {
 void assert_parsed_expression_has_characteristic_range(const char * expression, float range, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Degree) {
  GlobalContext globalContext;
  Expression e = parse_expression(expression);
-  assert(!e.isUninitialized());
+  quiz_assert(!e.isUninitialized());
  e = e.simplify(globalContext, angleUnit);
  if (std::isnan(range)) {
-    assert(std::isnan(e.characteristicXRange(globalContext, angleUnit)));
+    quiz_assert(std::isnan(e.characteristicXRange(globalContext, angleUnit)));
  } else {
-    assert(std::fabs(e.characteristicXRange(globalContext, angleUnit) - range) < 0.0000001f);
+    quiz_assert(std::fabs(e.characteristicXRange(globalContext, angleUnit) - range) < 0.0000001f);
  }
 }

@@ -84,16 +84,16 @@ QUIZ_CASE(poincare_characteristic_range) {

 void assert_parsed_expression_has_variables(const char * expression, const char * variables) {
  Expression e = parse_expression(expression);
-  assert(!e.isUninitialized());
+  quiz_assert(!e.isUninitialized());
  char variableBuffer[Expression::k_maxNumberOfVariables+1] = {0};
  int numberOfVariables = e.getVariables(Poincare::Symbol::isVariableSymbol, variableBuffer);
  if (variables == nullptr) {
-    assert(numberOfVariables == -1);
+    quiz_assert(numberOfVariables == -1);
  } else {
-    assert(numberOfVariables == strlen(variables));
+    quiz_assert(numberOfVariables == strlen(variables));
    char * currentChar = variableBuffer;
    while (*variables != 0) {
-      assert(*currentChar++ == *variables++);
+      quiz_assert(*currentChar++ == *variables++);
    }
  }
 }
@@ -110,18 +110,18 @@ QUIZ_CASE(poincare_get_variables) {
 void assert_parsed_expression_has_polynomial_coefficient(const char * expression, char symbolName, const char ** coefficients, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Degree) {
  GlobalContext globalContext;
  Expression e = parse_expression(expression);
-  assert(!e.isUninitialized());
+  quiz_assert(!e.isUninitialized());
  e = e.deepReduce(globalContext, angleUnit);
  Expression coefficientBuffer[Poincare::Expression::k_maxNumberOfPolynomialCoefficients];
  int d = e.getPolynomialReducedCoefficients(symbolName, coefficientBuffer, globalContext, Radian);
  for (int i = 0; i <= d; i++) {
    Expression f = parse_expression(coefficients[i]);
-    assert(!f.isUninitialized());
+    quiz_assert(!f.isUninitialized());
    coefficientBuffer[i] = coefficientBuffer[i].deepReduce(globalContext, angleUnit);
    f = f.deepReduce(globalContext, angleUnit);
-    assert(coefficientBuffer[i].isIdenticalTo(f));
+    quiz_assert(coefficientBuffer[i].isIdenticalTo(f));
  }
-  assert(coefficients[d+1] == 0);
+  quiz_assert(coefficients[d+1] == 0);
 }

 QUIZ_CASE(poincare_get_polynomial_coefficients) {
--- a/poincare/test/rational.cpp
+++ b/poincare/test/rational.cpp
@@ -18,18 +18,18 @@ QUIZ_CASE(poincare_rational_constructor) {
 }

 static inline void assert_equal(const Rational i, const Rational j) {
-  assert(Rational::NaturalOrder(i, j) == 0);
+  quiz_assert(Rational::NaturalOrder(i, j) == 0);
 }
 static inline void assert_not_equal(const Rational i, const Rational j) {
-  assert(Rational::NaturalOrder(i, j) != 0);
+  quiz_assert(Rational::NaturalOrder(i, j) != 0);
 }

 static inline void assert_lower(const Rational i, const Rational j) {
-  assert(Rational::NaturalOrder(i, j) < 0);
+  quiz_assert(Rational::NaturalOrder(i, j) < 0);
 }

 static inline void assert_greater(const Rational i, const Rational j) {
-  assert(Rational::NaturalOrder(i, j) > 0);
+  quiz_assert(Rational::NaturalOrder(i, j) > 0);
 }

 QUIZ_CASE(poincare_rational_compare) {
@@ -42,25 +42,25 @@ QUIZ_CASE(poincare_rational_compare) {
 }

 QUIZ_CASE(poincare_rational_properties) {
-  assert(Rational(-2).sign() == ExpressionNode::Sign::Negative);
-  assert(Rational(-2, 3).sign() == ExpressionNode::Sign::Negative);
-  assert(Rational(2, 3).sign() == ExpressionNode::Sign::Positive);
-  assert(Rational(0).isZero());
-  assert(!Rational(231).isZero());
-  assert(Rational(1).isOne());
-  assert(!Rational(-1).isOne());
-  assert(!Rational(1).isMinusOne());
-  assert(Rational(-1).isMinusOne());
-  assert(Rational(1,2).isHalf());
-  assert(!Rational(-1).isHalf());
-  assert(Rational(-1,2).isMinusHalf());
-  assert(!Rational(3,2).isMinusHalf());
-  assert(Rational(10).isTen());
-  assert(!Rational(-1).isTen());
+  quiz_assert(Rational(-2).sign() == ExpressionNode::Sign::Negative);
+  quiz_assert(Rational(-2, 3).sign() == ExpressionNode::Sign::Negative);
+  quiz_assert(Rational(2, 3).sign() == ExpressionNode::Sign::Positive);
+  quiz_assert(Rational(0).isZero());
+  quiz_assert(!Rational(231).isZero());
+  quiz_assert(Rational(1).isOne());
+  quiz_assert(!Rational(-1).isOne());
+  quiz_assert(!Rational(1).isMinusOne());
+  quiz_assert(Rational(-1).isMinusOne());
+  quiz_assert(Rational(1,2).isHalf());
+  quiz_assert(!Rational(-1).isHalf());
+  quiz_assert(Rational(-1,2).isMinusHalf());
+  quiz_assert(!Rational(3,2).isMinusHalf());
+  quiz_assert(Rational(10).isTen());
+  quiz_assert(!Rational(-1).isTen());
 }

 static inline void assert_add_to(const Rational i, const Rational j, const Rational k) {
-  assert(Rational::NaturalOrder(Rational::Addition(i, j), k) == 0);
+  quiz_assert(Rational::NaturalOrder(Rational::Addition(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_rational_addition) {
@@ -70,7 +70,7 @@ QUIZ_CASE(poincare_rational_addition) {
 }

 static inline void assert_pow_to(const Rational i,const Integer j, const Rational k) {
-  assert(Rational::NaturalOrder(Rational::IntegerPower(i, j), k) == 0);
+  quiz_assert(Rational::NaturalOrder(Rational::IntegerPower(i, j), k) == 0);
 }

 QUIZ_CASE(poincare_rational_power) {