Organized test files in subfolders

test/StaticJsonBuffer/basics.cpp

@@ -0,0 +1,65 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class StaticJsonBuffer_Basic_Tests : public testing::Test {
+ protected:
+  StaticJsonBuffer<64> buffer;
+};
+
+TEST_F(StaticJsonBuffer_Basic_Tests, CapacityMatchTemplateParameter) {
+  ASSERT_EQ(64, buffer.capacity());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, InitialSizeIsZero) {
+  ASSERT_EQ(0, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, GrowsAfterAlloc) {
+  buffer.alloc(1);
+  ASSERT_LE(1U, buffer.size());
+  buffer.alloc(1);
+  ASSERT_LE(2U, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenFull) {
+  buffer.alloc(64);
+  buffer.alloc(1);
+  ASSERT_EQ(64, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenTooSmall) {
+  buffer.alloc(65);
+  ASSERT_EQ(0, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNonNull) {
+  void *p = buffer.alloc(64);
+  ASSERT_NE(static_cast<void *>(0), p);
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenFull) {
+  buffer.alloc(64);
+  void *p = buffer.alloc(1);
+  ASSERT_EQ(NULL, p);
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenTooSmall) {
+  void *p = buffer.alloc(65);
+  ASSERT_EQ(NULL, p);
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, Alignment) {
+  size_t mask = sizeof(void *) - 1;
+
+  for (size_t size = 1; size <= sizeof(void *); size++) {
+    size_t addr = reinterpret_cast<size_t>(buffer.alloc(1));
+    ASSERT_EQ(0, addr & mask);
+  }
+}

test/StaticJsonBuffer/createArray.cpp

@@ -0,0 +1,46 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+TEST(StaticJsonBuffer_CreateArray_Tests, GrowsWithArray) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(2)> json;
+
+  JsonArray &array = json.createArray();
+  ASSERT_EQ(JSON_ARRAY_SIZE(0), json.size());
+
+  array.add("hello");
+  ASSERT_EQ(JSON_ARRAY_SIZE(1), json.size());
+
+  array.add("world");
+  ASSERT_EQ(JSON_ARRAY_SIZE(2), json.size());
+}
+
+TEST(StaticJsonBuffer_CreateArray_Tests, SucceedWhenBigEnough) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(0)> json;
+
+  JsonArray &array = json.createArray();
+  ASSERT_TRUE(array.success());
+}
+
+TEST(StaticJsonBuffer_CreateArray_Tests, FailsWhenTooSmall) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(0) - 1> json;
+
+  JsonArray &array = json.createArray();
+  ASSERT_FALSE(array.success());
+}
+
+TEST(StaticJsonBuffer_CreateArray_Tests, ArrayDoesntGrowWhenFull) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(1)> json;
+
+  JsonArray &array = json.createArray();
+  array.add("hello");
+  array.add("world");
+
+  EXPECT_EQ(1, array.size());
+}

test/StaticJsonBuffer/createObject.cpp

@@ -0,0 +1,57 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+TEST(StaticJsonBuffer_CreateObject_Tests, GrowsWithObject) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(3)> buffer;
+
+  JsonObject &obj = buffer.createObject();
+  ASSERT_EQ(JSON_OBJECT_SIZE(0), buffer.size());
+
+  obj["hello"];
+  ASSERT_EQ(JSON_OBJECT_SIZE(0), buffer.size());
+
+  obj["hello"] = 1;
+  ASSERT_EQ(JSON_OBJECT_SIZE(1), buffer.size());
+
+  obj["world"] = 2;
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), buffer.size());
+
+  obj["world"] = 3;  // <- same key, should not grow
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), buffer.size());
+}
+
+TEST(StaticJsonBuffer_CreateObject_Tests, SucceedWhenBigEnough) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0)> buffer;
+
+  JsonObject &object = buffer.createObject();
+  ASSERT_TRUE(object.success());
+}
+
+TEST(StaticJsonBuffer_CreateObject_Tests, FailsWhenTooSmall) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0) - 1> buffer;
+
+  JsonObject &object = buffer.createObject();
+  ASSERT_FALSE(object.success());
+}
+
+TEST(StaticJsonBuffer_CreateObject_Tests, ObjectDoesntGrowWhenFull) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1)> buffer;
+
+  JsonObject &obj = buffer.createObject();
+  obj["hello"] = 1;
+  obj["world"] = 2;
+
+  ASSERT_EQ(JSON_OBJECT_SIZE(1), buffer.size());
+  ASSERT_EQ(1, obj.size());
+
+  char json[64];
+  obj.printTo(json, sizeof(json));
+  ASSERT_STREQ("{\"hello\":1}", json);
+}

test/StaticJsonBuffer/parseArray.cpp

@@ -0,0 +1,96 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class StaticJsonBuffer_ParseArray_Tests : public testing::Test {
+ protected:
+  void with(StaticJsonBufferBase& jsonBuffer) {
+    _jsonBuffer = &jsonBuffer;
+  }
+
+  void whenInputIs(const char* json) {
+    strcpy(_jsonString, json);
+  }
+
+  void parseMustSucceed() {
+    EXPECT_TRUE(_jsonBuffer->parseArray(_jsonString).success());
+  }
+
+  void parseMustFail() {
+    EXPECT_FALSE(_jsonBuffer->parseArray(_jsonString).success());
+  }
+
+ private:
+  StaticJsonBufferBase* _jsonBuffer;
+  char _jsonString[256];
+};
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, TooSmallBufferForEmptyArray) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(0) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("[]");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, BufferOfTheRightSizeForEmptyArray) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(0)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("[]");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, TooSmallBufferForArrayWithOneValue) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(1) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("[1]");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests,
+       BufferOfTheRightSizeForArrayWithOneValue) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(1)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("[1]");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests,
+       TooSmallBufferForArrayWithNestedObject) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("[{}]");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests,
+       BufferOfTheRightSizeForArrayWithNestedObject) {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("[{}]");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, CharPtrNull) {
+  ASSERT_FALSE(
+      StaticJsonBuffer<100>().parseArray(static_cast<char*>(0)).success());
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, ConstCharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>()
+                   .parseArray(static_cast<const char*>(0))
+                   .success());
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, CopyStringNotSpaces) {
+  StaticJsonBuffer<100> jsonBuffer;
+  jsonBuffer.parseArray("  [ \"1234567\" ] ");
+  ASSERT_EQ(JSON_ARRAY_SIZE(1) + sizeof("1234567"), jsonBuffer.size());
+  // note we use a string of 8 bytes to be sure that the StaticJsonBuffer
+  // will not insert bytes to enforce alignement
+}

test/StaticJsonBuffer/parseObject.cpp

@@ -0,0 +1,89 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class StaticJsonBuffer_ParseObject_Tests : public testing::Test {
+ protected:
+  void with(StaticJsonBufferBase& jsonBuffer) {
+    _jsonBuffer = &jsonBuffer;
+  }
+
+  void whenInputIs(const char* json) {
+    strcpy(_jsonString, json);
+  }
+
+  void parseMustSucceed() {
+    EXPECT_TRUE(_jsonBuffer->parseObject(_jsonString).success());
+  }
+
+  void parseMustFail() {
+    EXPECT_FALSE(_jsonBuffer->parseObject(_jsonString).success());
+  }
+
+ private:
+  StaticJsonBufferBase* _jsonBuffer;
+  char _jsonString[256];
+};
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, TooSmallBufferForEmptyObject) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("{}");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, BufferOfTheRightSizeForEmptyObject) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("{}");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests,
+       TooSmallBufferForObjectWithOneValue) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("{\"a\":1}");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests,
+       BufferOfTheRightSizeForObjectWithOneValue) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("{\"a\":1}");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests,
+       TooSmallBufferForObjectWithNestedObject) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0) - 1> bufferTooSmall;
+  with(bufferTooSmall);
+  whenInputIs("{\"a\":[]}");
+  parseMustFail();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests,
+       BufferOfTheRightSizeForObjectWithNestedObject) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)> bufferOfRightSize;
+  with(bufferOfRightSize);
+  whenInputIs("{\"a\":[]}");
+  parseMustSucceed();
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, CharPtrNull) {
+  ASSERT_FALSE(
+      StaticJsonBuffer<100>().parseObject(static_cast<char*>(0)).success());
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, ConstCharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>()
+                   .parseObject(static_cast<const char*>(0))
+                   .success());
+}

test/StaticJsonBuffer/string.cpp

@@ -0,0 +1,48 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+TEST(StaticJsonBuffer_String_Tests, WorksWhenBufferIsBigEnough) {
+  StaticJsonBuffer<6> jsonBuffer;
+
+  StaticJsonBufferBase::String str = jsonBuffer.startString();
+  str.append('h');
+  str.append('e');
+  str.append('l');
+  str.append('l');
+  str.append('o');
+
+  ASSERT_STREQ("hello", str.c_str());
+}
+
+TEST(StaticJsonBuffer_String_Tests, ReturnsNullWhenTooSmall) {
+  StaticJsonBuffer<5> jsonBuffer;
+
+  StaticJsonBufferBase::String str = jsonBuffer.startString();
+  str.append('h');
+  str.append('e');
+  str.append('l');
+  str.append('l');
+  str.append('o');
+
+  ASSERT_EQ(NULL, str.c_str());
+}
+
+TEST(StaticJsonBuffer_String_Tests, SizeIncreases) {
+  StaticJsonBuffer<5> jsonBuffer;
+
+  StaticJsonBufferBase::String str = jsonBuffer.startString();
+  ASSERT_EQ(0, jsonBuffer.size());
+
+  str.append('h');
+  ASSERT_EQ(1, jsonBuffer.size());
+
+  str.c_str();
+  ASSERT_EQ(2, jsonBuffer.size());
+}