src.dualinventive.com/jjacobs/dinetrpcll-sniffer/libdipp/tests/json.cpp

/*
 * json.cpp
 *
 *  Created on: Jun 11, 2015
 *      Author: mstroom
 */
#include <memory>
#include "jansson.h"
#include <di/Json.h>
#include <gtest/gtest.h>

using namespace Di;
using namespace std;

TEST(Json, Constructor) {
	shared_ptr<Json> j;

	// Try to create a new Json object with an invalid json message
	j = make_shared<Json>("", 0);
	EXPECT_TRUE(j->hasError());

	// Try to create a new Json object with a valid json message
	j = make_shared<Json>("{}", 0);
	EXPECT_FALSE(j->hasError());

	// Try to create a new Json object with an invalid object
	j = make_shared<Json>(Json::J_NULL);
	EXPECT_TRUE(j->hasError());

	// Try to create a new Json object with a valid object
	j = make_shared<Json>(Json::J_OBJECT);
	EXPECT_FALSE(j->hasError());

	// Try to create a new Json object with an array
	j = make_shared<Json>(Json::J_ARRAY);
	EXPECT_FALSE(j->hasError());
}

TEST(Json, getObject) {
	shared_ptr<Json> j = make_shared<Json>("{\"test_string\":\"test\", \"test_json_null\" : null}", 1);

	if(j->isObject()) {
		// Test should return nullptr
		EXPECT_EQ(nullptr, j->getObject(""));

		// Test with valid string ref
		shared_ptr<Json> ret = j->getObject("test_string");
		EXPECT_EQ("test", ret->getString());

		// Test with valid string ref
		EXPECT_EQ(nullptr, j->getObject("test_json_null"));

		// Test with invalid string ref
		EXPECT_EQ(nullptr, j->getObject("invalid"));
	}
	else {
		ADD_FAILURE();
	}
}

TEST(Json, getArraySize) {
	shared_ptr<Json> j = nullptr;

	j = make_shared<Json>(Json::J_OBJECT);

	// If the Json object is not an array, return value should be 0
	EXPECT_EQ(0U, j->getArraySize());

	j = make_shared<Json>(Json::J_ARRAY);
	// Empty array will also result in 0
	EXPECT_EQ(0U, j->getArraySize());

	if(j->setString("test") == 0) {
		// Array has an element, so return value should be 1
		EXPECT_EQ(1U, j->getArraySize());
	} else {
		ADD_FAILURE();
	}
}

TEST(Json, getArrayIndex) {
	shared_ptr<Json> j = make_shared<Json>(Json::J_ARRAY);

	if(j->setNull() == 0) {
		// If the element is of type J_NULL, return value should be nullptr
		EXPECT_EQ(nullptr, j->getArrayIndex(0));
	} else {
		ADD_FAILURE();
	}

	if(j->setString("test") == 0) {
		// Return value should be a valid pointer
		EXPECT_NE(nullptr, j->getArrayIndex(1));
	} else {
		ADD_FAILURE();
	}
}

TEST(Json, setTypes) {
	shared_ptr<Json> j = nullptr;
	shared_ptr<Json> value = make_shared<Json>(Json::J_OBJECT);

	/* We have a few special cases in which the Json object is of
	 * the J_OBJECT type so we need to test these as well
	 */
	j = make_shared<Json>(Json::J_OBJECT);

	if(j->setNull("key") != 0) {
		ADD_FAILURE();
	}

	if(j->setString("key", "value", 5) != 0) {
		ADD_FAILURE();
	}

	if(j->setObject("key", value) != 0) {
		ADD_FAILURE();
	}

	if(j->setArray("key", value) != 0) {
		ADD_FAILURE();
	}

	// Continue testing with J_ARRAY type of Json object
	j = make_shared<Json>(Json::J_ARRAY);

	if(j->setNull() != 0) {
		ADD_FAILURE();
	}

	if(j->setNull("key") != 0) {
		ADD_FAILURE();
	}

	if(j->setString("value") != 0) {
		ADD_FAILURE();
	}

	if(j->setString("key", "value") != 0) {
		ADD_FAILURE();
	}

	if(j->setString("key", "value", 5) != 0) {
		ADD_FAILURE();
	}

	if(j->setNumber(0) != 0) {
		ADD_FAILURE();
	}

	if(j->setNumber("key", 0) != 0) {
		ADD_FAILURE();
	}

	if(j->setReal(1.1) != 0) {
		ADD_FAILURE();
	}

	if(j->setReal("key", 1.1) != 0) {
		ADD_FAILURE();
	}

	if(j->setBool(false) != 0) {
		ADD_FAILURE();
	}

	if(j->setBool("key", false) != 0) {
		ADD_FAILURE();
	}

	if(j->setObject(value) != 0) {
		ADD_FAILURE();
	}

	if(j->setObject("key", value) != 0) {
		ADD_FAILURE();
	}

	if(j->setArray(value) != 0) {
		ADD_FAILURE();
	}

	if(j->setArray("key", value) != 0) {
		ADD_FAILURE();
	}
}

TEST(Json, doublePrec) {
	shared_ptr<Json> j = make_shared<Json>("{\"exp1\":1.239514e6, \"exp2\":1e6, \"int1\": 4294967295, \"int2\": 9223372036854775807, \"int3\":9223372036854775806, \"dbltoint1\":43892.39593, \"dbltoint2\":194395.0000001}");
	shared_ptr<Json> x;
	x = j->getObject("exp1");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(1239514L, x->getNumber());

	x = j->getObject("exp2");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(1000000L, x->getNumber());

	x = j->getObject("int1");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(4294967295L, x->getNumber());

	x = j->getObject("int2");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(9223372036854775807L, x->getNumber());

	x = j->getObject("int3");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(9223372036854775806L, x->getNumber());

	x = j->getObject("dbltoint1");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(43892L, x->getNumber());

	x = j->getObject("dbltoint2");
	EXPECT_TRUE(x->isNumber());
	EXPECT_EQ(194395L, x->getNumber());
}

TEST(Json, getTypes) {
	shared_ptr<Json> j = nullptr;
	/* This test only includes two types, J_ARRAY and J_OBJECT because
	 * the wrapper will return an error if we try to create a new Json
	 * object of any other type than these two
	 */

	j = make_shared<Json>(Json::J_ARRAY);
	if(!j->hasError()) {
		// Created as a J_ARRAY type so return value should be J_ARRAY
		EXPECT_EQ(Json::J_ARRAY, j->getType());
	} else {
		ADD_FAILURE();
	}

	j = make_shared<Json>(Json::J_OBJECT);
	if(!j->hasError()) {
		// Created as a J_OBJECT type so return value should be J_OBJECT
		EXPECT_EQ(Json::J_OBJECT, j->getType());
	} else {
		ADD_FAILURE();
	}
}

TEST(Json, Iter) {
	shared_ptr<Json> j = make_shared<Json>(Json::J_OBJECT);
	string key;
	shared_ptr<Json> val, val2;

	// Number of items should be 0
	EXPECT_EQ(j->numIter(), 0U);
	EXPECT_EQ(j->beginIter(&key, &val), -1);

	EXPECT_EQ(j->setString("test","abc"), 0);
	EXPECT_EQ(j->setNumber("test2", 1234), 0);

	// Number of items now should be 2
	EXPECT_EQ(j->numIter(), 2U);

	EXPECT_EQ(j->beginIter(nullptr, &val), -1);
	EXPECT_EQ(j->beginIter(nullptr, nullptr), -1);
	EXPECT_EQ(j->beginIter(&key, nullptr), -1);

	EXPECT_EQ(j->beginIter(&key, &val), 0);
	// Yes, jansson changes the order of items in object, we can expect both
	if (key == "test") {
		EXPECT_EQ("test", key);
		EXPECT_TRUE(val->isString());
		EXPECT_EQ("abc", val->getString());
	} else {
		EXPECT_EQ("test2", key);
		EXPECT_TRUE(val->isNumber());
		EXPECT_EQ(1234U, val->getNumber());
	}

	EXPECT_EQ(j->nextIter(nullptr, &val), -1);
	EXPECT_EQ(j->nextIter(nullptr, nullptr), -1);
	EXPECT_EQ(j->nextIter(&key, nullptr), -1);

	EXPECT_EQ(j->nextIter(&key, &val), 0);
	// Yes, jansson changes the order of items in object, we can expect both
	if (key == "test") {
		EXPECT_EQ("test", key);
		EXPECT_TRUE(val->isString());
		EXPECT_EQ("abc", val->getString());
	} else {
		EXPECT_EQ("test2", key);
		EXPECT_TRUE(val->isNumber());
		EXPECT_EQ(1234U, val->getNumber());
	}

	// There a no more data blobs
	EXPECT_EQ(j->nextIter(&key, &val), -1);
}

TEST(Json, dumpString) {
	shared_ptr<Json> j = make_shared<Json>(Json::J_ARRAY);

	if(j->setString("{}") == 0){
		j->dumpString();
	} else {
		ADD_FAILURE();
	}
}

TEST(Json, nulling) {
	string a;
	shared_ptr<Json> k = make_shared<Json>("{}");
	ASSERT_FALSE(k->hasError());

	shared_ptr<Json> j = make_shared<Json>("{invalid json]");
	ASSERT_TRUE(j->hasError());

	ASSERT_FALSE(j->isObject());
	ASSERT_FALSE(j->isBool());
	ASSERT_FALSE(j->isString());
	ASSERT_FALSE(j->isNumber());
	ASSERT_FALSE(j->isArray());
	ASSERT_EQ(nullptr, j->getObject(""));
	ASSERT_EQ(0U, j->getArraySize());
	ASSERT_EQ(nullptr, j->getArrayIndex(0));
	ASSERT_FALSE(j->getBool());
	ASSERT_EQ(0, j->getNumber());
	ASSERT_NEAR(0, j->getReal(), 0.1);
	ASSERT_EQ(Json::J_NULL, j->getType());
	ASSERT_EQ("", j->getString());
	ASSERT_EQ(0U, j->numIter());
	ASSERT_EQ(-1, j->beginIter(&a, nullptr));
	ASSERT_EQ(-1, j->beginIter(nullptr, nullptr));
	ASSERT_EQ(-1, j->beginIter(nullptr, &k));
	ASSERT_EQ(-1, j->beginIter(&a, &k));
	ASSERT_EQ(-1, j->nextIter(&a, nullptr));
	ASSERT_EQ(-1, j->nextIter(nullptr, nullptr));
	ASSERT_EQ(-1, j->nextIter(nullptr, &k));
	ASSERT_EQ(-1, j->nextIter(&a, &k));
}