[poincare] Add TreeByReference tests

poincare/Makefile

@@ -188,6 +188,7 @@ objsExpected += $(addprefix poincare/src/,\
 
 tests += $(addprefix poincare/test/,\
   tree/tree_by_value.cpp\
+  tree/tree_by_reference.cpp\
 )
 
 testsExpected += $(addprefix poincare/test/,\

poincare/test/tree/helpers.h

@@ -0,0 +1,28 @@
+#include "blob_node.h"
+#include "pair_node.h"
+
+#if POINCARE_TREE_LOG
+#include <iostream>
+#endif
+
+static inline int pool_size() {
+  return Poincare::TreePool::sharedPool()->numberOfNodes();
+}
+#if POINCARE_TREE_LOG
+static inline void log_pool() {
+  Poincare::TreePool::sharedPool()->flatLog(std::cout);
+}
+#endif
+
+static void assert_pool_size(int i) {
+#if POINCARE_TREE_LOG
+  int poolSize = pool_size();
+  if (poolSize != i) {
+    std::cout << "Expected pool of size " << i << " but got " << poolSize << std::endl;
+    log_pool();
+    assert(false);
+  }
+#else
+  assert(pool_size() == i);
+#endif
+}

poincare/test/tree/tree_by_reference.cpp

@@ -0,0 +1,64 @@
+#include <quiz.h>
+#include <poincare.h>
+#include <assert.h>
+
+#include "helpers.h"
+
+using namespace Poincare;
+
+QUIZ_CASE(tree_by_reference_are_discared_after_block) {
+  assert_pool_size(0);
+  {
+    BlobByReference b(0);
+    assert_pool_size(1);
+  }
+  assert_pool_size(0);
+}
+
+static void make_temp_blob() {
+  BlobByReference b(5);
+}
+QUIZ_CASE(tree_by_reference_are_discared_after_function_call) {
+  assert_pool_size(0);
+  make_temp_blob();
+  assert_pool_size(0);
+}
+
+QUIZ_CASE(tree_by_reference_can_be_copied) {
+  assert_pool_size(0);
+  BlobByReference b(123);
+  assert_pool_size(1);
+  TreeByReference t = b;
+  assert_pool_size(1);
+}
+
+static TreeByReference blob_with_data_3() {
+  return BlobByReference(3);
+}
+QUIZ_CASE(tree_by_reference_can_be_returned) {
+  assert_pool_size(0);
+  TreeByReference b = blob_with_data_3();
+  assert_pool_size(1);
+}
+
+QUIZ_CASE(tree_by_reference_allocation_failures) {
+  assert_pool_size(0);
+  BlobByReference b(1);
+  assert_pool_size(1);
+  {
+    BlobByReference array[100];
+    assert(pool_size() > 1);
+    assert(pool_size() < 100);
+  }
+  assert_pool_size(1);
+}
+
+QUIZ_CASE(tree_by_reference_does_not_copy) {
+  assert_pool_size(0);
+  BlobByReference b1(1);
+  BlobByReference b2(2);
+  PairByReference p(b1, b2);
+  assert_pool_size(3);
+  PairByReference p2 = p;
+  assert_pool_size(3);
+}

poincare/test/tree/tree_by_value.cpp

@@ -2,38 +2,11 @@
 #include <poincare.h>
 #include <assert.h>
 
-#include "blob_node.h"
-#include "pair_node.h"
-
-#if POINCARE_TREE_LOG
-#include <iostream>
-#endif
+#include "helpers.h"
 
 using namespace Poincare;
 
-static inline int pool_size() {
-  return TreePool::sharedPool()->numberOfNodes();
-}
-#if POINCARE_TREE_LOG
-static inline void log_pool() {
-  TreePool::sharedPool()->flatLog(std::cout);
-}
-#endif
-
-static void assert_pool_size(int i) {
-#if POINCARE_TREE_LOG
-  int poolSize = pool_size();
-  if (poolSize != i) {
-    std::cout << "Expected pool of size " << i << " but got " << poolSize << std::endl;
-    log_pool();
-    assert(false);
-  }
-#else
-  assert(pool_size() == i);
-#endif
-}
-
-QUIZ_CASE(tree_by_values_are_discared_after_block) {
+QUIZ_CASE(tree_by_value_are_discared_after_block) {
   assert_pool_size(0);
   {
     BlobByValue b(0);
@@ -42,16 +15,16 @@ QUIZ_CASE(tree_by_values_are_discared_after_block) {
   assert_pool_size(0);
 }
 
-void make_temp_blob() {
+static void make_temp_blob() {
   BlobByValue b(5);
 }
-QUIZ_CASE(tree_by_values_are_discared_after_function_call) {
+QUIZ_CASE(tree_by_value_are_discared_after_function_call) {
   assert_pool_size(0);
   make_temp_blob();
   assert_pool_size(0);
 }
 
-QUIZ_CASE(tree_by_values_can_be_copied) {
+QUIZ_CASE(tree_by_value_can_be_copied) {
   assert_pool_size(0);
   BlobByValue b(123);
   assert_pool_size(1);
@@ -59,16 +32,16 @@ QUIZ_CASE(tree_by_values_can_be_copied) {
   assert_pool_size(2);
 }
 
-TreeByValue blob_with_data_3() {
+static TreeByValue blob_with_data_3() {
   return BlobByValue(3);
 }
-QUIZ_CASE(tree_by_values_can_be_returned) {
+QUIZ_CASE(tree_by_value_can_be_returned) {
   assert_pool_size(0);
   TreeByValue b = blob_with_data_3();
   assert_pool_size(1);
 }
 
-QUIZ_CASE(tree_by_values_allocation_failures) {
+QUIZ_CASE(tree_by_value_allocation_failures) {
   assert_pool_size(0);
   BlobByValue b(1);
   assert_pool_size(1);