added more tests and helper macros

includes/Pickler.h

@@ -16,7 +16,7 @@ struct pickle_jar {
 
 struct pickle_shelf {
     struct pickle_jar* pickle_jars;
-    int pickle_jarCount = 0;
+    int pickle_jarCount;
     bool passed;
 };
 
@@ -66,10 +66,12 @@ int __pickle_shelf_run(pickle_shelf*);
 /// To create a pickle we need to run
 /// _PICKLE_ pickle takes a name.
 ///
-#define INSTALLSHELF struct pickle_shelf __pickle_shelf__ = { 0, 0 };
+#define INSTALLSHELF struct pickle_shelf __pickle_shelf__ = { 0, 0, true };
 #define CREATEJAR(jar_name) struct pickle_jar jar_name = {#jar_name, 0, 0, true};
 #define PICKLE(name) struct pickle name = []() -> pickle
 #define ADDPICKLE(jar,pickle) __pickle_add_jar(&jar, pickle, #pickle)
-#define PUTJARONSHLEF(jar) __pickle_jar_add_to_shelf(&__pickle_shelf__,jar);
+#define PUTJARONSHELF(jar) __pickle_jar_add_to_shelf(&__pickle_shelf__,jar);
+#define PUTJARONASHELF(shelf,jar) __pickle_jar_add_to_shelf(&shelf,jar);
 #define PICKLESHELF __pickle_shelf_run(&__pickle_shelf__)
+#define APICKLESHELF(shelf) __pickle_shelf_run(&shelf)
 #endif

source/Pickler.cpp

@@ -61,7 +61,7 @@ void printoutPickle(pickle p) {
     if(p.passed) {
         std::cout << "\033[1;92m[=======Pickled======]\n";
     }else {
-        std::cout << "\033[1;31m[==Droped the Pickle=]" << p.message<<"\n";
+        std::cout << "\033[1;31m[==Droped the Pickle=] " << p.message<<"\n";
     }
     std::cout << "[========DONE========]\033[1;39;49m\n";
 }

testing/source.cpp

@@ -1,13 +1,14 @@
-#include "../includes/Pickler.h"
+#include "Pickler.h"
 void testing() {
 }
 
 int main (int argc, char *argv[]) {
     
-    pickle_shelf __pickle_shelf__ = pickle_shelf();
+    pickle_shelf __pickle_shelf = pickle_shelf();
     
     CREATEJAR(Pickle_Logic_Tests);
     CREATEJAR(Pickle_Deffinition_Test);
+
     PICKLE(Add_Pickle_Test){
         CREATEJAR(PickleAddTest);
         struct pickle p = {"Pickle_Test","testing", true};
@@ -22,21 +23,62 @@ int main (int argc, char *argv[]) {
         if(DIFFERENT(test_jar.functionCount, PickleAddTest.functionCount)) {
             ASSERT("functionCount not the same", false);
         }
-        ASSERT("",true);
+        ASSERT("Good",true);
     }();
+
     PICKLE(Test_SAME){ 
         ASSERT("This test should succsead", SAME(2,2));
     }();
     PICKLE(Test_DIFFERENT){ 
         ASSERT("This is testing if this works", DIFFERENT(1,2));
     }();
+
+    PICKLE(Test_INSTALLSHELF) {
+        struct pickle_shelf shelf = {0,0,true};
+        INSTALLSHELF;
+        if(DIFFERENT(shelf.passed, __pickle_shelf__.passed))
+            ASSERT("var passed not the same",false);
+        if(DIFFERENT(shelf.pickle_jarCount, __pickle_shelf__.pickle_jarCount))
+            ASSERT("var pickle_jarCount not the same",false);
+        if(DIFFERENT(shelf.pickle_jars, __pickle_shelf__.pickle_jars))
+            ASSERT("var pickle_jars not the same",false);
+        ASSERT("Good",true);
+    }();
+
+    PICKLE(Test_PICKLESHELF) {
+        {
+        INSTALLSHELF;
+        CREATEJAR(PICKLESHELF_Test_Jar);
+        PICKLE(test) {ASSERT("Good", true);}();
+        ADDPICKLE(PICKLESHELF_Test_Jar,test);
+        PUTJARONSHELF(PICKLESHELF_Test_Jar);
+        
+        if(DIFFERENT(PICKLESHELF, 0))
+                ASSERT("Pickle Shelf not good", false);
+        }
+        {
+        INSTALLSHELF;
+        CREATEJAR(PICKLESHELF_Test_Jar);
+        PICKLE(test) {ASSERT("Should Failed", false);}();
+        ADDPICKLE(PICKLESHELF_Test_Jar,test);
+        PUTJARONSHELF(PICKLESHELF_Test_Jar);
+        
+        if(SAME(PICKLESHELF, 0))
+                ASSERT("Pickle Shelf not good", false);
+        }
+        ASSERT("Good",true);
+    }();
+    
+
+    
     ADDPICKLE(Pickle_Deffinition_Test,Add_Pickle_Test);
+    ADDPICKLE(Pickle_Deffinition_Test,Test_INSTALLSHELF);
+    ADDPICKLE(Pickle_Logic_Tests,Test_PICKLESHELF);
     ADDPICKLE(Pickle_Logic_Tests,Test_SAME);
     ADDPICKLE(Pickle_Logic_Tests,Test_DIFFERENT);
-    PUTJARONSHLEF(Pickle_Logic_Tests);
+    PUTJARONASHELF(__pickle_shelf,Pickle_Logic_Tests);
-    PUTJARONSHLEF(Pickle_Deffinition_Test);
+    PUTJARONASHELF(__pickle_shelf,Pickle_Deffinition_Test);
 
-    return __pickle_shelf_run(&__pickle_shelf__);
+    return __pickle_shelf_run(&__pickle_shelf);
-;
 }