Rewrote tests on hash tables

JsonParserTests/JsonHashTableTests.cpp

@@ -15,85 +15,130 @@ namespace ArduinoJsonParserTests
 {		
     TEST_CLASS(JsonHashTableTests)
 	{
-		char json[128];
 		JsonParser<32> parser;
 		JsonHashTable hashTable;
+        JsonArray nestedArray;
+		char json[256];
 
 	public:
 
-		TEST_METHOD_INITIALIZE(Initialize)
+        TEST_METHOD(EmptyString)
         {
-			strcpy(json, "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}");
+            whenInputIs("");
+            parseMustFail();
+        }
+
+        TEST_METHOD(EmptyHashTable)
+        {
+            whenInputIs("{}");
+            parseMustSucceed();
+        }
+
+        TEST_METHOD(TwoIntegers)
+        {
+            whenInputIs("{\"key1\":1,\"key2\":2}");
+            parseMustSucceed();
+            itemMustBe("key1", 1L);
+            itemMustBe("key2", 2L);
+            itemMustNotExists("key3");
+        }
+
+        TEST_METHOD(TwoBooleans)
+        {
+            whenInputIs("{\"key1\":true,\"key2\":false}");
+            parseMustSucceed();
+            itemMustBe("key1", true);
+            itemMustBe("key2", false);
+            itemMustNotExists("key3");
+        }
+
+        TEST_METHOD(TwoStrings)
+        {
+            whenInputIs("{\"key1\":\"hello\",\"key2\":\"world\"}");
+            parseMustSucceed();
+            itemMustBe("key1", "hello");
+            itemMustBe("key2", "world");
+            itemMustNotExists("key3");
+        }
+
+        TEST_METHOD(TwoNestedArrays)
+        {
+            whenInputIs("{\"key1\":[1,2],\"key2\":[3,4]}");
+            parseMustSucceed();
+
+            itemMustBeAnArray("key1");
+            arrayLengthMustBe(2);
+            arrayItemMustBe(0, 1L);
+            arrayItemMustBe(1, 2L);
+            arrayItemMustBe(2, 0L);
+
+            itemMustBeAnArray("key2");
+            arrayLengthMustBe(2);
+            arrayItemMustBe(0, 3L);
+            arrayItemMustBe(1, 4L);
+            arrayItemMustBe(2, 0L);
+
+            itemMustNotExists("key3");
+        }
+
+    private:
+
+        void whenInputIs(const char* input)
+        {
+            strcpy(json, input);
             hashTable = parser.parseHashTable(json);
         }
 
-		TEST_METHOD(HashTable_Success_ReturnsTrue)
+        void parseMustFail()
+        {
+            Assert::IsFalse(hashTable.success());
+        }
+
+        void parseMustSucceed()
         {
             Assert::IsTrue(hashTable.success());
         }
 
-		TEST_METHOD(HashTable_GetString_ReturnsExpectedValue)
+        void itemMustBe(const char* key, long expected)
         {
-			string name = hashTable.getString("Name");
+            Assert::AreEqual(expected, hashTable.getLong(key));
-			Assert::AreEqual(name, string("Blanchon"));
         }
 
-		TEST_METHOD(HashTable_GetArray_ReturnsExpectedValue)
+        void itemMustBe(const char* key, bool expected)
         {
-			JsonArray skills = hashTable.getArray("Skills");
+            Assert::AreEqual(expected, hashTable.getBool(key));
-
-			string skill0 = skills.getString(0);
-			Assert::AreEqual(skill0, string("C"));
-
-			string skill1 = skills.getString(1);
-			Assert::AreEqual(skill1, string("C++"));
-
-			string skill2 = skills.getString(2);
-			Assert::AreEqual(skill2, string("C#"));
         }
 
-		TEST_METHOD(HashTable_GetLong_ReturnsExpectedValue)
+        void itemMustBe(const char* key, const char* expected)
         {
-			int age = hashTable.getLong("Age");
+            Assert::AreEqual(expected, hashTable.getString(key));
-			Assert::AreEqual(32, age);
         }
 
-		TEST_METHOD(HashTable_GetBool_ReturnsExpectedValue)
+        void itemMustNotExists(const char* key)
         {
-			bool online = hashTable.getBool("Online");
+            Assert::IsFalse(hashTable.containsKey(key));
-			Assert::AreEqual(true, online);
+            Assert::IsFalse(hashTable.getHashTable(key).success());
+            Assert::IsFalse(hashTable.getArray(key).success());
+            Assert::IsFalse(hashTable.getBool(key));
+            Assert::AreEqual(0.0, hashTable.getDouble(key));
+            Assert::AreEqual(0L,  hashTable.getLong(key));
+            Assert::IsNull(hashTable.getString(key));
         }
 
-        TEST_METHOD(OneDimensionArrayInHashTable)
+        void itemMustBeAnArray(const char* key)
         {
-            char json[] = "{a:[0,0],b:[0,0]}";
+            nestedArray = hashTable.getArray(key);
-
+            Assert::IsTrue(nestedArray.success());
-            JsonHashTable root = parser.parseHashTable(json);
-            Assert::IsTrue(root.success());
-
-            JsonArray arrayA = root.getArray("a");
-            Assert::IsTrue(arrayA.success());
-            Assert::AreEqual(2, arrayA.getLength());
-
-            JsonArray arrayB = root.getArray("b");
-            Assert::IsTrue(arrayB.success());
-            Assert::AreEqual(2, arrayB.getLength());
         }
 
-        TEST_METHOD(TwoDimensionsArrayInHashTable)
+        void arrayLengthMustBe(int expected)
         {
-            char json[] = "{a:[[0],[0]],b:[[0],[0]]}";
+            Assert::AreEqual(expected, nestedArray.getLength());
+        }
 
-            JsonHashTable root = parser.parseHashTable(json);
+        void arrayItemMustBe(int index, long expected)
-            Assert::IsTrue(root.success());
+        {
-
+            Assert::AreEqual(expected, nestedArray.getLong(index));
-            JsonArray arrayA = root.getArray("a");
-            Assert::IsTrue(arrayA.success());
-            Assert::AreEqual(2, arrayA.getLength());
-
-            JsonArray arrayB = root.getArray("b");
-            Assert::IsTrue(arrayB.success());
-            Assert::AreEqual(2, arrayB.getLength());
         }
 	};
 }