void testJSONValidator__isValidRoot::testRoots(void){ #ifdef JSON_VALIDATE assertTrue(JSONValidator::isValidRoot(JSON_TEXT("{}"))); assertTrue(JSONValidator::isValidRoot(JSON_TEXT("[]"))); assertTrue(JSONValidator::isValidRoot(JSON_TEXT("[\"stuff\"]"))); #endif }
static void assertConstEmpty(const json_string & s){ assertEquals(s.length(), 0); assertTrue(s.empty()); assertCStringSame(s.c_str(), JSON_TEXT("")); assertEquals(s, s); assertEquals(s, JSON_TEXT("")); }
void Callback(JSONNode & test, void * ide){ assertEquals(ide, (void*)0xDEADBEEF); ++counter; switch(counter){ case 1: assertEquals(test.type(), JSON_NODE); assertTrue(test.empty()); break; case 2: assertEquals(test.type(), JSON_ARRAY); assertTrue(test.empty()); break; case 3: assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 1); assertEquals(test[0].name(), JSON_TEXT("hello")); assertEquals(test[0].as_int(), 1); break; case 4: assertEquals(test.type(), JSON_ARRAY); assertEquals(test.size(), 3); break; case 5: assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 1); assertEquals(test[0].name(), JSON_TEXT("hi")); assertEquals(test[0].size(), 1) assertEquals(test[0][0].type(), JSON_NUMBER); assertEquals(test[0][0].name(), JSON_TEXT("one")); assertEquals(test[0][0].as_int(), 1); break; } }
void TestSuite::TestStreams(void){ #ifdef JSON_STREAM UnitTest::SetPrefix("TestStreams.cpp - Streams"); counter = 0; errorCounter = 0; JSONStream test(Callback, errorCallback, (void*)0xDEADBEEF); test << JSON_TEXT("{}[]"); assertEquals(2, counter); assertEquals(0, errorCounter); test << JSON_TEXT("{\"hel"); assertEquals(2, counter); assertEquals(0, errorCounter); test << JSON_TEXT("lo\" : 1"); assertEquals(2, counter); assertEquals(0, errorCounter); test << JSON_TEXT("}["); assertEquals(3, counter); assertEquals(0, errorCounter); test << JSON_TEXT("1,2,3]{\"hi\" : { \"one\" : 1}"); assertEquals(4, counter); assertEquals(0, errorCounter); test << JSON_TEXT("}"); assertEquals(5, counter); assertEquals(0, errorCounter); #ifdef JSON_SAFE test << JSON_TEXT("{\"hello\":12keaueuataueaouhe"); assertEquals(1, errorCounter); #endif #ifdef JSON_SECURITY_MAX_STREAM_OBJECTS test.reset(); unsigned int currentCount = errorCounter; json_string safe; for(int i = 0; i < JSON_SECURITY_MAX_STREAM_OBJECTS; ++i){ safe += JSON_TEXT("{}"); } test << safe; assertEquals(133, counter); assertEquals(currentCount, errorCounter); test.reset(); json_string unsafe; for(int i = 0; i <= JSON_SECURITY_MAX_STREAM_OBJECTS + 1; ++i){ unsafe += JSON_TEXT("{}"); } test << unsafe; assertEquals(261, counter); assertEquals(currentCount + 1, errorCounter); #endif #endif }
json_string internalJSONNode::WriteName(bool formatted, bool arrayChild) const { if (arrayChild){ return WRITER_EMPTY ; } else { return JSON_TEXT("\"") + JSONWorker::UnfixString(_name, _name_encoded) + ((formatted) ? JSON_TEXT("\" : ") : JSON_TEXT("\":")); } }
void * JSONMemory::json_realloc(void * ptr, size_t siz){ if (myrealloc){ #ifdef JSON_DEBUG //in debug mode, see if the malloc was successful void * result = myrealloc(ptr, siz); JSON_ASSERT(result, JSON_TEXT("out of memory")); return result; #else return myrealloc(ptr, (unsigned long)siz); #endif } #ifdef JSON_DEBUG //in debug mode, see if the malloc was successful void * result = realloc(ptr, siz); JSON_ASSERT(result, JSON_TEXT("out of memory")); return result; #else return realloc(ptr, siz); #endif }
JSONNode::json_iterator JSONNode::find_nocase(const json_string & name_t){ JSON_CHECK_INTERNAL(); JSON_ASSERT(type() == JSON_NODE, JSON_TEXT("finding a non-iteratable node")); makeUniqueInternal(); if (JSONNode ** res = internal -> at_nocase(name_t)){ return ptr_to_json_iterator(res); } return end(); }
void TestSuite::TestSelf(void){ UnitTest::SetPrefix("TestSuite.cpp - Self Test"); #ifndef JSON_STDERROR #ifdef JSON_DEBUG libjson::register_debug_callback(callback); #endif #endif assertUnitTest(); #if defined(JSON_SAFE) bool temp = false; JSON_ASSERT_SAFE(true, JSON_TEXT(""), temp = true;);
void testJSONValidator__isValidRoot::testNotRoots(void){ #ifdef JSON_VALIDATE assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{]"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[}"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{}aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[]aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT(""))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[\"stuff\":{},]"))); #endif }
void Callback(JSONNODE * test, void *){ ++counter; switch(counter){ case 1: assertEquals(json_type(test), JSON_NODE); assertTrue(json_empty(test)); break; case 2: assertEquals(json_type(test), JSON_ARRAY); assertTrue(json_empty(test)); break; case 3:{ assertEquals(json_type(test), JSON_NODE); assertEquals(json_size(test), 1); json_char * temp = json_name(json_at(test, 0)); assertCStringSame(temp, JSON_TEXT("hello")); json_free(temp); assertEquals(json_as_int(json_at(test, 0)), 1); break;} case 4: assertEquals(json_type(test), JSON_ARRAY); assertEquals(json_size(test), 3); break; case 5:{ assertEquals(json_type(test), JSON_NODE); assertEquals(json_size(test), 1); json_char * temp = json_name(json_at(test, 0)); assertCStringSame(temp, JSON_TEXT("hi")); json_free(temp); assertEquals(json_size(json_at(test, 0)), 1); assertEquals(json_type(json_at(json_at(test, 0),0)), JSON_NUMBER); temp = json_name(json_at(json_at(test, 0),0)); assertCStringSame(temp, JSON_TEXT("one")); json_free(temp); assertEquals(json_as_int(json_at(json_at(test, 0),0)), 1); break;} } }
void testJSONValidator__isValidRoot::testSuddenEnd(void){ #ifdef JSON_VALIDATE assertFalse(JSONValidator::isValidRoot(JSON_TEXT(""))); //--- void testJSONValidator__isValidRoot::testRoots(void){ assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("["))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[\"stuff"))); //---void testJSONValidator__isValidRoot::testNotRoots(void){ assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{}aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[]aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("aoe"))); #endif }
json_string internalJSONNode::WriteChildren(unsigned int indent){ //Iterate through the children and write them if (Children.empty()) return WRITER_EMPTY; json_string indent_plus_one; json_string indent_this; json_string res; //handle whether or not it's formatted JSON if (indent != 0xFFFFFFFF){ //it's formatted, make the indentation strings indent_this = NEW_LINE + makeIndent(indent); indent_plus_one = NEW_LINE + makeIndent(++indent); } //else it's not formatted, leave the indentation strings empty const size_t size_minus_one = Children.size() - 1; size_t i=0; json_foreach(Children, it){ res += indent_plus_one + (*it) -> internal -> Write(indent, type() == JSON_ARRAY); if (i < size_minus_one) res += JSON_TEXT(","); //the last one does not get a comma, but all of the others do ++i; }
void jsonChildren::inc(void){ if (mysize == mycapacity){ //it's full if (!mycapacity){ //the array hasn't been created yet JSON_ASSERT(!array, JSON_TEXT("Expanding a 0 capacity array, but not null")); #ifdef JSON_LESS_MEMORY array = json_malloc<JSONNode*>(1); mycapacity = 1; #else array = json_malloc<JSONNode*>(8); //8 seems average for JSON, and it's only 64 bytes mycapacity = 8; #endif } else { #ifdef JSON_LESS_MEMORY mycapacity += 1; //increment the size of the array #else mycapacity <<= 1; //double the size of the array #endif array = json_realloc<JSONNode*>(array, mycapacity); } } }
void jsonChildren::inc(json_index_t amount){ if (!amount) return; if (mysize + amount >= mycapacity){ //it's full if (!mycapacity){ //the array hasn't been created yet JSON_ASSERT(!array, JSON_TEXT("Expanding a 0 capacity array, but not null")); #ifdef JSON_LESS_MEMORY array = json_malloc<JSONNode*>(amount); mycapacity = amount; #else array = json_malloc<JSONNode*>(amount > 8 ? amount : 8); //8 seems average for JSON, and it's only 64 bytes mycapacity = amount > 8 ? amount : 8; #endif } else { #ifdef JSON_LESS_MEMORY mycapacity = mysize + amount; //increment the size of the array #else while(mysize + amount > mycapacity){ mycapacity <<= 1; //double the size of the array } #endif array = json_realloc<JSONNode*>(array, mycapacity); } } }
void TestSuite::TestInspectors(void){ UnitTest::SetPrefix("TestInspectors.cpp - Inspectors"); JSONNode test = JSONNode(JSON_NULL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("")); assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); assertEquals(test.as_bool(), false); #endif test = 15.5f; assertEquals(test.type(), JSON_NUMBER); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("15.5")); #endif assertEquals(test.as_int(), 15); assertEquals(test.as_float(), 15.5f); #ifdef JSON_CASTABLE assertEquals(test.as_bool(), true); #endif test = 0.0f; assertEquals(test.type(), JSON_NUMBER); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("0")); #endif assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); #ifdef JSON_CASTABLE assertEquals(test.as_bool(), false); #endif test = true; assertEquals(test.type(), JSON_BOOL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("true")); assertEquals(test.as_int(), 1); assertEquals(test.as_float(), 1.0f); #endif assertEquals(test.as_bool(), true); test = false; assertEquals(test.type(), JSON_BOOL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("false")); assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); #endif assertEquals(test.as_bool(), false); #ifdef JSON_CASTABLE test.cast(JSON_NODE); #else test = JSONNode(JSON_NODE); #endif assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 0); test.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world"))); test.push_back(JSONNode(JSON_TEXT("hello"), JSON_TEXT("mars"))); test.push_back(JSONNode(JSON_TEXT("salut"), JSON_TEXT("france"))); assertEquals(test.size(), 3); TestSuite::testParsingItself(test); #ifdef JSON_CASTABLE JSONNode casted = test.as_array(); #ifdef JSON_UNIT_TEST assertNotEquals(casted.internal, test.internal); #endif assertEquals(casted.type(), JSON_ARRAY); assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 3); assertEquals(casted.size(), 3); TestSuite::testParsingItself(casted); #endif UnitTest::SetPrefix("TestInspectors.cpp - Location"); try { #ifdef JSON_CASTABLE assertEquals(casted.at(0), JSON_TEXT("world")); assertEquals(casted.at(1), JSON_TEXT("mars")); assertEquals(casted.at(2), JSON_TEXT("france")); assertEquals(casted.at(0).name(), JSON_TEXT("")); assertEquals(casted.at(1).name(), JSON_TEXT("")); assertEquals(casted.at(2).name(), JSON_TEXT("")); #endif assertEquals(test.at(0), JSON_TEXT("world")); assertEquals(test.at(1), JSON_TEXT("mars")); assertEquals(test.at(2), JSON_TEXT("france")); assertEquals(test.at(0).name(), JSON_TEXT("hi")); assertEquals(test.at(1).name(), JSON_TEXT("hello")); assertEquals(test.at(2).name(), JSON_TEXT("salut")); } catch (std::out_of_range){ FAIL("exception caught"); } try { assertEquals(test.at(JSON_TEXT("hi")), JSON_TEXT("world")); assertEquals(test.at(JSON_TEXT("hello")), JSON_TEXT("mars")); assertEquals(test.at(JSON_TEXT("salut")), JSON_TEXT("france")); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS assertEquals(test.at_nocase(JSON_TEXT("SALUT")), JSON_TEXT("france")); assertEquals(test.at_nocase(JSON_TEXT("HELLO")), JSON_TEXT("mars")); assertEquals(test.at_nocase(JSON_TEXT("HI")), JSON_TEXT("world")); #endif } catch (std::out_of_range){ FAIL("exception caught"); } assertException(test.at(JSON_TEXT("meh")), std::out_of_range); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS assertException(test.at_nocase(JSON_TEXT("meh")), std::out_of_range); #endif assertEquals(test[JSON_TEXT("hi")], json_string(JSON_TEXT("world"))); assertEquals(test[JSON_TEXT("hello")], json_string(JSON_TEXT("mars"))); assertEquals(test[JSON_TEXT("salut")], json_string(JSON_TEXT("france"))); assertEquals(test[0], JSON_TEXT("world")); assertEquals(test[1], JSON_TEXT("mars")); assertEquals(test[2], JSON_TEXT("france")); #ifdef JSON_ITERATORS #ifdef JSON_CASTABLE UnitTest::SetPrefix("TestInspectors.cpp - Iterators"); for(JSONNode::iterator it = casted.begin(), end = casted.end(); it != end; ++it){ assertEquals((*it).name(), JSON_TEXT("")); } #endif #endif #ifdef JSON_BINARY UnitTest::SetPrefix("TestInspectors.cpp - Binary"); test.set_binary((const unsigned char *)"Hello World", 11); assertEquals(test.type(), JSON_STRING); assertEquals(test.as_string(), JSON_TEXT("SGVsbG8gV29ybGQ=")); assertEquals(test.as_binary(), "Hello World"); assertEquals(test.as_binary().size(), 11); test = JSON_TEXT("Hello World"); assertEquals(test.type(), JSON_STRING); assertEquals(test.as_string(), JSON_TEXT("Hello World")); #ifdef JSON_SAFE assertEquals(test.as_binary(), ""); #endif #endif #ifdef JSON_READ_PRIORITY //This is a regression test for a bug in at() json_string buffer(JSON_TEXT("{ \"myValue1\" : \"foo\", \"myValue2\" : \"bar\"}")); JSONNode current = libjson::parse(buffer); try { JSONNode & value1 = current[JSON_TEXT("myValue1")]; assertEquals(value1.as_string(), JSON_TEXT("foo")); JSONNode & value2 = current[JSON_TEXT("myValue2")]; assertEquals(value2.as_string(), JSON_TEXT("bar")); } catch (...){ assertTrue(false); } #endif }
#include "JSONNode.h" #include "JSONWorker.h" #include "JSONValidator.h" #include "JSONStream.h" #include "JSONGlobals.h" #include <stdexcept> //some methods throw exceptions #ifdef JSON_MEMORY_MANAGE #define MANAGER_INSERT(x) json_global(NODE_HANDLER).insert(x) #define MANAGER_STREAM_INSERT(x) json_global(STREAM_HANDLER).insert(x) #else #define MANAGER_INSERT(x) x #define MANAGER_STREAM_INSERT(x) x #endif static const json_char * EMPTY_CSTRING(JSON_TEXT("")); #ifdef JSON_MEMORY_POOL #include "JSONMemoryPool.h" extern memory_pool<NODEPOOL> json_node_mempool; #endif inline json_char * toCString(const json_string & str) json_nothrow { const size_t len = (str.length() + 1) * sizeof(json_char); #ifdef JSON_MEMORY_MANAGE return (json_char *)json_global(STRING_HANDLER).insert(std::memcpy(json_malloc<json_char>(len), str.c_str(), len)); #else return (json_char *)std::memcpy(json_malloc<json_char>(len), str.c_str(), len); #endif }
JSON_CHECK_INTERNAL(); JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find_nocase")); makeUniqueInternal(); if (JSONWGNode ** res = internal -> at_nocase(name_t)){ return ptr_to_json_iterator(res); } return end(); } #endif JSONWGNode::json_iterator JSONWGNode::erase(json_iterator pos) json_nothrow { JSON_CHECK_INTERNAL(); JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase")); JSON_ASSERT_UNIQUE("erase 1"); JSON_ASSERT_SAFE(pos < end(), JSON_TEXT("erase out of range"), return end();); JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("erase out of range"), return begin();); deleteJSONWGNode(*(json_iterator_ptr(pos))); internal -> CHILDREN -> erase(json_iterator_ptr(pos)); return (empty()) ? end() : pos; } JSONWGNode::json_iterator JSONWGNode::erase(json_iterator _start, const json_iterator & _end) json_nothrow { if (_start == _end) return _start; JSON_CHECK_INTERNAL(); JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase")); JSON_ASSERT_UNIQUE("erase 3"); JSON_ASSERT_SAFE(_start <= end(), JSON_TEXT("erase out of lo range"), return end();); JSON_ASSERT_SAFE(_end <= end(), JSON_TEXT("erase out of hi range"), return end();); JSON_ASSERT_SAFE(_start >= begin(), JSON_TEXT("erase out of lo range"), return begin();); JSON_ASSERT_SAFE(_end >= begin(), JSON_TEXT("erase out of hi range"), return begin();); for (JSONWGNode ** pos = json_iterator_ptr(_start); pos < json_iterator_ptr(_end); ++pos){
JSONNode::json_iterator JSONNode::erase(json_iterator pos){ JSON_CHECK_INTERNAL(); JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, JSON_TEXT("erasing a non-iteratable node")); JSON_ASSERT_UNIQUE("erase 1"); JSON_ASSERT_SAFE(pos < end(), JSON_TEXT("erase out of range"), return end(););
void TestSuite::TestConverters(void){ UnitTest::SetPrefix("TestConverters.cpp - Converters"); assertEquals(sizeof(char), 1); assertEquals(NumberToString::_itoa<char>((char)127), JSON_TEXT("127")); assertEquals(NumberToString::_itoa<char>((char)15), JSON_TEXT("15")); assertEquals(NumberToString::_itoa<char>((char)0), JSON_TEXT("0")); assertEquals(NumberToString::_itoa<char>((char)-15), JSON_TEXT("-15")); assertEquals(NumberToString::_itoa<char>((char)-127), JSON_TEXT("-127")); assertEquals(sizeof(short), 2); assertEquals(NumberToString::_itoa<short>((short)32767), JSON_TEXT("32767")); assertEquals(NumberToString::_itoa<short>((short)15), JSON_TEXT("15")); assertEquals(NumberToString::_itoa<short>((short)0), JSON_TEXT("0")); assertEquals(NumberToString::_itoa<short>((short)-15), JSON_TEXT("-15")); assertEquals(NumberToString::_itoa<short>((short)-32767), JSON_TEXT("-32767")); assertEquals(sizeof(int), 4); assertEquals(NumberToString::_itoa<int>(2147483647), JSON_TEXT("2147483647")); assertEquals(NumberToString::_itoa<int>(15), JSON_TEXT("15")); assertEquals(NumberToString::_itoa<int>(0), JSON_TEXT("0")); assertEquals(NumberToString::_itoa<int>(-15), JSON_TEXT("-15")); assertEquals(NumberToString::_itoa<int>(-2147483647), JSON_TEXT("-2147483647")); #ifdef TEST_LONG_EXTREMES assertEquals(NumberToString::_itoa<long>(9223372036854775807L), JSON_TEXT("9223372036854775807")); assertEquals(NumberToString::_itoa<long>(-9223372036854775807L), JSON_TEXT("-9223372036854775807")); assertEquals(NumberToString::_uitoa<unsigned long>(18446744073709551615UL), JSON_TEXT("18446744073709551615")); #endif assertEquals(NumberToString::_itoa<long>(15), JSON_TEXT("15")); assertEquals(NumberToString::_itoa<long>(0), JSON_TEXT("0")); assertEquals(NumberToString::_itoa<long>(-15), JSON_TEXT("-15")); assertEquals(NumberToString::_uitoa<unsigned char>(255), JSON_TEXT("255")); assertEquals(NumberToString::_uitoa<unsigned char>(15), JSON_TEXT("15")); assertEquals(NumberToString::_uitoa<unsigned char>(0), JSON_TEXT("0")); assertEquals(NumberToString::_uitoa<unsigned short>(65535), JSON_TEXT("65535")); assertEquals(NumberToString::_uitoa<unsigned short>(15), JSON_TEXT("15")); assertEquals(NumberToString::_uitoa<unsigned short>(0), JSON_TEXT("0")); assertEquals(NumberToString::_uitoa<unsigned int>(4294967295u), JSON_TEXT("4294967295")); assertEquals(NumberToString::_uitoa<unsigned int>(15), JSON_TEXT("15")); assertEquals(NumberToString::_uitoa<unsigned int>(0), JSON_TEXT("0")); assertEquals(NumberToString::_uitoa<unsigned long>(15), JSON_TEXT("15")); assertEquals(NumberToString::_uitoa<unsigned long>(0), JSON_TEXT("0")); assertEquals(NumberToString::_ftoa((json_number)1.0), JSON_TEXT("1")); assertEquals(NumberToString::_ftoa((json_number)1.002), JSON_TEXT("1.002")); assertEquals(NumberToString::_ftoa((json_number)10.0), JSON_TEXT("10")); assertEquals(NumberToString::_ftoa((json_number)-1.0), JSON_TEXT("-1")); assertEquals(NumberToString::_ftoa((json_number)-1.002), JSON_TEXT("-1.002")); assertEquals(NumberToString::_ftoa((json_number)-10.0), JSON_TEXT("-10")); assertEquals(NumberToString::_ftoa((json_number)0.0), JSON_TEXT("0")); assertTrue(_floatsAreEqual(1.1, 1.1)); assertTrue(_floatsAreEqual(1.000000001, 1.0)); assertTrue(_floatsAreEqual(1.0, 1.000000001)); assertFalse(_floatsAreEqual(1.0, 1.0001)); assertFalse(_floatsAreEqual(1.0001, 1.0)); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS #ifdef JSON_UNIT_TEST UnitTest::SetPrefix("TestConverters.cpp - Checking case-insensitive"); assertTrue(internalJSONNode::AreEqualNoCase(JSON_TEXT("hello"), JSON_TEXT("HeLLo"))); assertTrue(internalJSONNode::AreEqualNoCase(JSON_TEXT("hell5o"), JSON_TEXT("HELL5O"))); assertTrue(internalJSONNode::AreEqualNoCase(JSON_TEXT("HeLLo"), JSON_TEXT("hello"))); assertTrue(internalJSONNode::AreEqualNoCase(JSON_TEXT("HELL5O"), JSON_TEXT("hell5o"))); assertFalse(internalJSONNode::AreEqualNoCase(JSON_TEXT("hello"), JSON_TEXT("Hello "))); assertFalse(internalJSONNode::AreEqualNoCase(JSON_TEXT("hello"), JSON_TEXT("hi"))); assertFalse(internalJSONNode::AreEqualNoCase(JSON_TEXT("hello"), JSON_TEXT("55555"))); assertFalse(internalJSONNode::AreEqualNoCase(JSON_TEXT("hello"), JSON_TEXT("jonny"))); #endif #endif #ifdef JSON_SAFE assertTrue(NumberToString::isNumeric(JSON_TEXT("0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0.0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("1.0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-0.0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("-1.0e+2"))); #ifdef JSON_STRICT assertFalse(NumberToString::isNumeric(JSON_TEXT("0xABCD"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("0124"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0."))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1."))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.0"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.0"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.0e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.0e2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.0e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.0e-2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0e+2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1e+2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.e+2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.e+2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+0.0e+2"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("+1.0e+2"))); #else assertTrue(NumberToString::isNumeric(JSON_TEXT("0xABCD"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("0124"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1."))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.0"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.0e2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.0e-2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+0.0e+2"))); assertTrue(NumberToString::isNumeric(JSON_TEXT("+1.0e+2"))); #endif assertFalse(NumberToString::isNumeric(JSON_TEXT("0xABCDv"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("00124"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("09124"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("0no"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("no"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("n1234"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("12no"))); assertFalse(NumberToString::isNumeric(JSON_TEXT("0en5"))); #endif }
void TestSuite::TestInspectors(void){ UnitTest::SetPrefix("TestInspectors.cpp - Inspectors"); #ifdef JSON_LIBRARY JSONNODE * test = json_new(JSON_NULL); assertEquals(json_type(test), JSON_NULL); json_char * res = json_as_string(test); assertCStringSame(res, JSON_TEXT("")); json_free(res); assertEquals_Primitive(json_as_int(test), 0); assertEquals_Primitive(json_as_float(test), 0.0f); assertEquals(json_as_bool(test), false); json_set_f(test, 15.5f); assertEquals(json_type(test), JSON_NUMBER); #ifdef JSON_CASTABLE res = json_as_string(test); assertCStringSame(res, JSON_TEXT("15.5")); json_free(res); #endif assertEquals_Primitive(json_as_int(test), 15); assertEquals_Primitive(json_as_float(test), 15.5f); #ifdef JSON_CASTABLE assertEquals(json_as_bool(test), true); #endif json_set_f(test, 0.0f); assertEquals(json_type(test), JSON_NUMBER); #ifdef JSON_CASTABLE res = json_as_string(test); assertCStringSame(res, JSON_TEXT("0")); json_free(res); #endif assertEquals_Primitive(json_as_int(test), 0); assertEquals_Primitive(json_as_float(test), 0.0f); #ifdef JSON_CASTABLE assertEquals(json_as_bool(test), false); #endif json_set_b(test, true); assertEquals(json_type(test), JSON_BOOL); #ifdef JSON_CASTABLE res = json_as_string(test); assertCStringSame(res, JSON_TEXT("true")); json_free(res); assertEquals_Primitive(json_as_int(test), 1); assertEquals_Primitive(json_as_float(test), 1.0f); #endif assertEquals(json_as_bool(test), true); json_set_b(test, false); assertEquals(json_type(test), JSON_BOOL); #ifdef JSON_CASTABLE res = json_as_string(test); assertCStringSame(res, JSON_TEXT("false")); json_free(res); assertEquals_Primitive(json_as_int(test), 0); assertEquals_Primitive(json_as_float(test), 0.0f); #endif assertEquals(json_as_bool(test), false); #ifdef JSON_CASTABLE json_cast(test, JSON_NODE); assertEquals(json_type(test), JSON_NODE); assertEquals(json_size(test), 0); json_push_back(test, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world"))); json_push_back(test, json_new_a(JSON_TEXT("hello"), JSON_TEXT("mars"))); json_push_back(test, json_new_a(JSON_TEXT("salut"), JSON_TEXT("france"))); assertEquals(json_size(test), 3); TestSuite::testParsingItself(test); JSONNODE * casted = json_as_array(test); #ifdef JSON_UNIT_TEST assertNotEquals(((JSONNode*)casted) -> internal, ((JSONNode*)test) -> internal); #endif assertEquals(json_type(casted), JSON_ARRAY); assertEquals(json_type(test), JSON_NODE); assertEquals(json_size(test), 3); assertEquals(json_size(casted), 3); TestSuite::testParsingItself(casted); #endif UnitTest::SetPrefix("TestInspectors.cpp - Location"); #ifdef JSON_CASTABLE #define CheckAt(parent, locale, text)\ if(JSONNODE * temp = json_at(parent, locale)){\ json_char * _res = json_as_string(temp);\ assertCStringSame(_res, text);\ json_free(_res);\ } else {\ FAIL(std::string("CheckAt: ") + #parent + "[" + #locale + "]");\ } #define CheckNameAt(parent, locale, text)\ if(JSONNODE * temp = json_at(parent, locale)){\ json_char * _res = json_name(temp);\ assertCStringSame(_res, text);\ json_free(_res);\ } else {\ FAIL(std::string("CheckNameAt: ") + #parent + "[" + #locale + "]");\ } CheckAt(casted, 0, JSON_TEXT("world")); CheckAt(casted, 1, JSON_TEXT("mars")); CheckAt(casted, 2, JSON_TEXT("france")); CheckNameAt(casted, 0, JSON_TEXT("")); CheckNameAt(casted, 1, JSON_TEXT("")); CheckNameAt(casted, 2, JSON_TEXT("")); CheckAt(test, 0, JSON_TEXT("world")); CheckAt(test, 1, JSON_TEXT("mars")); CheckAt(test, 2, JSON_TEXT("france")); CheckNameAt(test, 0, JSON_TEXT("hi")); CheckNameAt(test, 1, JSON_TEXT("hello")); CheckNameAt(test, 2, JSON_TEXT("salut")); #define CheckGet(parent, locale, text)\ if(JSONNODE * temp = json_get(parent, locale)){\ json_char * _res = json_as_string(temp);\ assertCStringSame(_res, text);\ json_free(_res);\ } else {\ FAIL(std::string("CheckGet: ") + #parent + "[" + #locale + "]");\ } #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS #define CheckGetNoCase(parent, locale, text)\ if(JSONNODE * temp = json_get_nocase(parent, locale)){\ json_char * _res = json_as_string(temp);\ assertCStringSame(_res, text);\ json_free(_res);\ } else {\ FAIL(std::string("CheckGetNoCase: ") + #parent + "[" + #locale + "]");\ } #else #define CheckGetNoCase(parent, locale, text) #endif CheckGet(test, JSON_TEXT("hi"), JSON_TEXT("world")); CheckGetNoCase(test, JSON_TEXT("HI"), JSON_TEXT("world")); CheckGet(test, JSON_TEXT("hello"), JSON_TEXT("mars")); CheckGetNoCase(test, JSON_TEXT("HELLO"), JSON_TEXT("mars")); CheckGet(test, JSON_TEXT("salut"), JSON_TEXT("france")); CheckGetNoCase(test, JSON_TEXT("SALUT"), JSON_TEXT("france")); assertNull(json_get(test, JSON_TEXT("meh"))); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS assertNull(json_get_nocase(test, JSON_TEXT("meh"))); #endif #endif #ifdef JSON_ITERATORS #ifdef JSON_CASTABLE UnitTest::SetPrefix("TestInspectors.cpp - Iterators"); for(JSONNODE_ITERATOR it = json_begin(casted), end = json_end(casted); it != end; ++it){ json_char * _res = json_name(*it); assertCStringSame(_res, JSON_TEXT("")); json_free(_res); } #endif #endif #ifdef JSON_BINARY UnitTest::SetPrefix("TestInspectors.cpp - Binary"); json_set_binary(test, (const unsigned char *)"Hello World", 11); assertEquals(json_type(test), JSON_STRING); json_char * _res = json_as_string(test); assertCStringSame(_res, JSON_TEXT("SGVsbG8gV29ybGQ=")); json_free(_res); unsigned long i; if(char * bin = (char*)json_as_binary(test, &i)){ assertEquals(i, 11); char * terminated = (char*)std::memcpy(std::malloc(i + 1), bin, i); terminated[i] = '\0'; assertCStringEquals(terminated, "Hello World"); json_free(bin); std::free(terminated); } else { FAIL("as_binary failed"); } json_set_a(test, JSON_TEXT("Hello World")); assertEquals(json_type(test), JSON_STRING); _res = json_as_string(test); assertCStringSame(_res, JSON_TEXT("Hello World")); json_free(_res); #ifdef JSON_SAFE assertEquals(json_as_binary(test, &i), 0); assertEquals(i, 0); #endif #endif json_delete(test); #ifdef JSON_CASTABLE json_delete(casted); #endif #else JSONNode test = JSONNode(JSON_NULL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("")); assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); assertEquals(test.as_bool(), false); #endif test = 15.5f; assertEquals(test.type(), JSON_NUMBER); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("15.5")); #endif assertEquals(test.as_int(), 15); assertEquals(test.as_float(), 15.5f); #ifdef JSON_CASTABLE assertEquals(test.as_bool(), true); #endif test = 0.0f; assertEquals(test.type(), JSON_NUMBER); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("0")); #endif assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); #ifdef JSON_CASTABLE assertEquals(test.as_bool(), false); #endif test = true; assertEquals(test.type(), JSON_BOOL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("true")); assertEquals(test.as_int(), 1); assertEquals(test.as_float(), 1.0f); #endif assertEquals(test.as_bool(), true); test = false; assertEquals(test.type(), JSON_BOOL); #ifdef JSON_CASTABLE assertEquals(test.as_string(), JSON_TEXT("false")); assertEquals(test.as_int(), 0); assertEquals(test.as_float(), 0.0f); #endif assertEquals(test.as_bool(), false); #ifdef JSON_CASTABLE test.cast(JSON_NODE); #else test = JSONNode(JSON_NODE); #endif assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 0); test.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world"))); test.push_back(JSONNode(JSON_TEXT("hello"), JSON_TEXT("mars"))); test.push_back(JSONNode(JSON_TEXT("salut"), JSON_TEXT("france"))); assertEquals(test.size(), 3); TestSuite::testParsingItself(test); #ifdef JSON_CASTABLE JSONNode casted = test.as_array(); #ifdef JSON_UNIT_TEST assertNotEquals(casted.internal, test.internal); #endif assertEquals(casted.type(), JSON_ARRAY); assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 3); assertEquals(casted.size(), 3); TestSuite::testParsingItself(casted); #endif UnitTest::SetPrefix("TestInspectors.cpp - Location"); try { #ifdef JSON_CASTABLE assertEquals(casted.at(0), JSON_TEXT("world")); assertEquals(casted.at(1), JSON_TEXT("mars")); assertEquals(casted.at(2), JSON_TEXT("france")); assertEquals(casted.at(0).name(), JSON_TEXT("")); assertEquals(casted.at(1).name(), JSON_TEXT("")); assertEquals(casted.at(2).name(), JSON_TEXT("")); #endif assertEquals(test.at(0), JSON_TEXT("world")); assertEquals(test.at(1), JSON_TEXT("mars")); assertEquals(test.at(2), JSON_TEXT("france")); assertEquals(test.at(0).name(), JSON_TEXT("hi")); assertEquals(test.at(1).name(), JSON_TEXT("hello")); assertEquals(test.at(2).name(), JSON_TEXT("salut")); } catch (std::out_of_range){ FAIL("exception caught"); } try { assertEquals(test.at(JSON_TEXT("hi")), JSON_TEXT("world")); assertEquals(test.at(JSON_TEXT("hello")), JSON_TEXT("mars")); assertEquals(test.at(JSON_TEXT("salut")), JSON_TEXT("france")); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS assertEquals(test.at_nocase(JSON_TEXT("SALUT")), JSON_TEXT("france")); assertEquals(test.at_nocase(JSON_TEXT("HELLO")), JSON_TEXT("mars")); assertEquals(test.at_nocase(JSON_TEXT("HI")), JSON_TEXT("world")); #endif } catch (std::out_of_range){ FAIL("exception caught"); } assertException(test.at(JSON_TEXT("meh")), std::out_of_range); #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS assertException(test.at_nocase(JSON_TEXT("meh")), std::out_of_range); #endif assertEquals(test[JSON_TEXT("hi")], json_string(JSON_TEXT("world"))); assertEquals(test[JSON_TEXT("hello")], json_string(JSON_TEXT("mars"))); assertEquals(test[JSON_TEXT("salut")], json_string(JSON_TEXT("france"))); assertEquals(test[0], JSON_TEXT("world")); assertEquals(test[1], JSON_TEXT("mars")); assertEquals(test[2], JSON_TEXT("france")); #ifdef JSON_ITERATORS #ifdef JSON_CASTABLE UnitTest::SetPrefix("TestInspectors.cpp - Iterators"); for(JSONNode::iterator it = casted.begin(), end = casted.end(); it != end; ++it){ assertEquals((*it).name(), JSON_TEXT("")); } #endif #endif #ifdef JSON_BINARY UnitTest::SetPrefix("TestInspectors.cpp - Binary"); test.set_binary((const unsigned char *)"Hello World", 11); assertEquals(test.type(), JSON_STRING); assertEquals(test.as_string(), JSON_TEXT("SGVsbG8gV29ybGQ=")); assertEquals(test.as_binary(), "Hello World"); assertEquals(test.as_binary().size(), 11); test = JSON_TEXT("Hello World"); assertEquals(test.type(), JSON_STRING); assertEquals(test.as_string(), JSON_TEXT("Hello World")); #ifdef JSON_SAFE assertEquals(test.as_binary(), ""); #endif #endif #ifdef JSON_READ_PRIORITY //This is a regression test for a bug in at() json_string buffer(JSON_TEXT("{ \"myValue1\" : \"foo\", \"myValue2\" : \"bar\"}")); JSONNode current = libjson::parse(buffer); try { JSONNode & value1 = current[JSON_TEXT("myValue1")]; assertEquals(value1.as_string(), JSON_TEXT("foo")); JSONNode & value2 = current[JSON_TEXT("myValue2")]; assertEquals(value2.as_string(), JSON_TEXT("bar")); } catch (...){ assertTrue(false); } #endif #endif }
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "stdafx.h" #include "JSONNode.h" #include "JSONNode.inl" #ifdef JSON_WRITER #include "JSONWorker.h" const static json_string WRITER_EMPTY; #ifndef JSON_NEWLINE const static json_string NEW_LINE(JSON_TEXT("\n")); #else const static json_string NEW_LINE(JSON_TEXT(JSON_NEWLINE)); #endif #ifdef JSON_INDENT const static json_string INDENT(JSON_TEXT(JSON_INDENT)); inline json_string makeIndent(unsigned int amount){ if (amount == 0xFFFFFFFF) return WRITER_EMPTY; json_string result; result.reserve(amount); for(unsigned int i=0; i < amount; ++i){ result += INDENT; } return result;
#ifdef JSON_LESS_MEMORY mycapacity = mysize + amount; //increment the size of the array #else while(mysize + amount > mycapacity){ mycapacity <<= 1; //double the size of the array } #endif array = json_realloc<JSONNode*>(array, mycapacity); } } } //actually deletes everything within the vector, this is safe to do on an empty or even a null array void jsonChildren::deleteAll(void){ json_foreach((*this), runner){ JSON_ASSERT(*runner, JSON_TEXT("a null pointer within the children")); JSONNode::deleteJSONNode(*runner); //this is why I can't do forward declaration } } void jsonChildren::doerase(JSONNode ** position, json_index_t number){ JSON_ASSERT(array, JSON_TEXT("erasing something from a null array 2")); JSON_ASSERT(position >= array, JSON_TEXT("position is beneath the start of the array 2")); JSON_ASSERT(position + number <= array + mysize, JSON_TEXT("erasing out of bounds 2")); if (position + number >= array + mysize){ mysize = (json_index_t)(position - array); #ifndef JSON_ISO_STRICT JSON_ASSERT((long long)position - (long long)array >= 0, JSON_TEXT("doing negative allocation")); #endif } else { memmove(position, position + number, (mysize - (position - array) - number) * sizeof(JSONNode *));
#endif void TestSuite::TestSelf(void){ UnitTest::SetPrefix("TestSuite.cpp - Self Test"); #ifndef JSON_STDERROR #ifdef JSON_DEBUG libjson::register_debug_callback(callback); #endif #endif assertUnitTest(); #if defined(JSON_SAFE) bool temp = false; JSON_ASSERT_SAFE(true, JSON_TEXT(""), temp = true;); assertFalse(temp); JSON_ASSERT_SAFE(false, JSON_TEXT(""), temp = true;); assertTrue(temp); temp = false; JSON_FAIL_SAFE(JSON_TEXT(""), temp = true;); assertTrue(temp); #endif echo("If this fails, then edit JSON_INDEX_TYPE in JSONOptions.h"); assertLessThanEqualTo(sizeof(json_index_t), sizeof(void*)); } //makes sure that libjson didn't leak memory somewhere void TestSuite::TestFinal(void){ #ifdef JSON_UNIT_TEST UnitTest::SetPrefix("TestSuite.cpp - Memory Leak");
void TestSuite::TestString(void){ UnitTest::SetPrefix("TestString.cpp - Test String Class"); { json_string s; assertEmpty(s); } { json_string s; assertEmpty(s); json_string m(s); assertEmpty(m); assertEmpty(s); assertSame(s, m); } { json_string s(JSON_TEXT("hello")); assertEquals(s.length(), 5); assertFalse(s.empty()); assertCStringSame(s.c_str(), JSON_TEXT("hello")); assertEquals(s, s); assertEquals(s, JSON_TEXT("hello")); s.clear(); assertEmpty(s); } { json_string s(5, 'h'); assertEquals(s.length(), 5); assertFalse(s.empty()); assertCStringSame(s.c_str(), JSON_TEXT("hhhhh")); assertEquals(s, s); assertEquals(s, JSON_TEXT("hhhhh")); s.clear(); assertEmpty(s); } { json_string s(5, 'h'); json_string m(s); assertSame(s, m); } { json_string s(5, 'h'); json_string m(s); assertSame(s, m); s.clear(); assertEmpty(s); assertEquals(s.length(), 0); assertDifferent(s, m); } { json_string s(JSON_TEXT("hello")); json_string m = s; assertSame(s, m); m = s.substr(1, 3); assertEquals(m.length(), 3); assertEquals(m, JSON_TEXT("ell")); } { json_string s(JSON_TEXT("hello")); json_string m = s; assertSame(s, m); m = s.substr(1); assertEquals(m.length(), 4); assertEquals(m, JSON_TEXT("ello")); } { json_string s(JSON_TEXT("hello")); s += JSON_TEXT(" world"); assertEquals(s.length(), 11); assertEquals(s, JSON_TEXT("hello world")); } { json_string s(JSON_TEXT("hello")); json_string m = s + JSON_TEXT(" world ") + s; assertEquals(m.length(), 17); assertEquals(m, JSON_TEXT("hello world hello")); } { json_string s(JSON_TEXT("hello")); s += 'a'; s += 'a'; s += 'a'; s += 'a'; assertEquals(s.length(), 9); assertEquals(s, JSON_TEXT("helloaaaa")); } { json_string s(JSON_TEXT("hello world")); size_t pos = s.find('w'); assertEquals(pos, 6); } { json_string s(JSON_TEXT("hello world")); size_t pos = s.find('z'); assertEquals(pos, json_string::npos); } { json_string s(JSON_TEXT("hello world")); size_t pos = s.find_first_not_of(JSON_TEXT("helo")); assertEquals(pos, 5); } { json_string s(JSON_TEXT("hello world")); size_t pos = s.find_first_of(JSON_TEXT("ol")); assertEquals(pos, 2); } { json_string s(JSON_TEXT("hello world")); s.erase(s.begin(), s.begin() + 3); assertEquals(s, JSON_TEXT("lo world")); } { json_string s(JSON_TEXT("hello world"), 5); assertEquals(s, JSON_TEXT("hello")); } #ifndef JSON_STRING_HEADER { json_string s(JSON_TEXT("hello world")); std::wstring wtest(L"hello world"); std::string stest("hello world"); assertEquals(libjson::to_std_string(s), stest); assertEquals(stest, libjson::to_std_string(s)); assertEquals(libjson::to_std_wstring(s), wtest); assertEquals(wtest, libjson::to_std_wstring(s)); assertEquals(s, libjson::to_json_string(stest)); assertEquals(libjson::to_json_string(stest), s); assertEquals(s, libjson::to_json_string(wtest)); assertEquals(libjson::to_json_string(wtest), s); } #endif }
#include "JSON_FAIL_SAFE.h" #include "../../Source/JSONDebug.h" #if defined JSON_DEBUG #ifndef JSON_STDERROR static json_string last; #ifdef JSON_LIBRARY static void callback(const json_char * p){ last = p; } #else static void callback(const json_string & p){ last = p; } #endif #endif #endif const json_string fail_constfs = JSON_TEXT("fail"); //should pass the same pointer all the way through, no copies const json_string null_constfs = JSON_TEXT(""); #if defined JSON_DEBUG || defined JSON_SAFE json_error_callback_t origCallbackfs = NULL; #endif void testJSONDebug_JSON_FAIL_SAFE::setUp(const std::string & methodName){ BaseTest::setUp(methodName); #if defined JSON_DEBUG #ifndef JSON_STDERROR origCallbackfs = JSONDebug::register_callback(callback); //check that the callback was called last = null_constfs; #endif #endif } void testJSONDebug_JSON_FAIL_SAFE::tearDown(void){
void TestSuite::TestFunctions(void){ UnitTest::SetPrefix("TestFunctions.cpp - Swap"); #ifdef JSON_LIBRARY JSONNODE * test1 = json_new(JSON_NODE); JSONNODE * test2 = json_new(JSON_NODE); json_set_i(test1, 14); json_set_i(test2, 35); json_swap(test1, test2); assertEquals_Primitive(json_as_int(test1), 35); assertEquals_Primitive(json_as_int(test2), 14); UnitTest::SetPrefix("TestFunctions.cpp - Duplicate"); json_delete(test1); test1 = json_duplicate(test2); #ifdef JSON_UNIT_TEST assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #endif assertTrue(json_equal(test1, test2)); UnitTest::SetPrefix("TestFunctions.cpp - Duplicate with children"); JSONNODE * node = json_new(JSON_NODE); json_push_back(node, json_new_i(JSON_TEXT(""), 15)); json_push_back(node, json_new_f(JSON_TEXT(""), 27.4f)); json_push_back(node, json_new_b(JSON_TEXT(""), true)); TestSuite::testParsingItself(node); JSONNODE * dup = json_duplicate(node); assertEquals(json_size(dup), 3); #ifdef JSON_UNIT_TEST assertNotEquals(((JSONNode*)node) -> internal, ((JSONNode*)dup) -> internal); #endif assertEquals(json_type(dup), JSON_NODE); TestSuite::testParsingItself(node); TestSuite::testParsingItself(dup); assertEquals_Primitive(json_as_int(json_at(dup, 0)), 15); assertEquals_Primitive(json_as_float(json_at(dup, 1)), 27.4f); assertEquals(json_as_bool(json_at(dup, 2)), true); assertTrue(json_equal(json_at(dup, 0), json_at(node, 0))); assertTrue(json_equal(json_at(dup, 1), json_at(node, 1))); assertTrue(json_equal(json_at(dup, 2), json_at(node, 2))); TestSuite::testParsingItself(dup); #ifdef JSON_ITERATORS for(JSONNODE_ITERATOR it = json_begin(node), end = json_end(node), dup_it = json_begin(dup); it != end; ++it, ++dup_it){ assertTrue(json_equal(*it, *dup_it)); #ifdef JSON_UNIT_TEST assertNotEquals(((JSONNode*)(*it)) -> internal, ((JSONNode*)(*dup_it)) -> internal); #endif } #endif UnitTest::SetPrefix("TestFunctions.cpp - Nullify"); json_nullify(test1); assertEquals(json_type(test1), JSON_NULL); json_char * res = json_name(test1); assertCStringSame(res, JSON_TEXT("")); json_free(res); #ifdef JSON_CASTABLE UnitTest::SetPrefix("TestFunctions.cpp - Cast"); json_cast(test1, JSON_NULL); json_set_i(test2, 1); json_cast(test2, JSON_BOOL); assertEquals(json_type(test1), JSON_NULL); assertEquals(json_type(test2), JSON_BOOL); assertEquals(json_as_bool(test2), true); json_set_b(test2, true); assertEquals(json_as_bool(test2), true); json_cast(test2, JSON_NUMBER); assertEquals_Primitive(json_as_float(test2), 1.0f); json_set_f(test2, 0.0f); assertEquals_Primitive(json_as_float(test2), 0.0f); json_cast(test2, JSON_BOOL); assertEquals(json_as_bool(test2), false); #endif UnitTest::SetPrefix("TestFunctions.cpp - Merge"); json_set_a(test1, JSON_TEXT("hello")); json_set_a(test2, JSON_TEXT("hello")); #ifdef JSON_UNIT_TEST assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #endif assertTrue(json_equal(test1, test2)); json_merge(test1, test2); #ifdef JSON_UNIT_TEST #ifdef JSON_REF_COUNT assertEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #else assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #endif #endif #ifdef JSON_CASTABLE json_cast(test1, JSON_NODE); json_cast(test2, JSON_NODE); assertEquals(json_type(test1), JSON_NODE); assertEquals(json_type(test2), JSON_NODE); json_push_back(test1, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world"))); json_push_back(test2, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world"))); TestSuite::testParsingItself(test1); TestSuite::testParsingItself(test2); json_merge(test1, test2); #ifdef JSON_UNIT_TEST #ifdef JSON_REF_COUNT assertEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #else assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal); #endif #endif TestSuite::testParsingItself(test1); TestSuite::testParsingItself(test2); #endif json_delete(test1); json_delete(test2); json_delete(node); json_delete(dup); #else JSONNode test1; JSONNode test2; test1 = JSON_TEXT("hello"); test2 = JSON_TEXT("world"); test1.swap(test2); assertEquals(test1, JSON_TEXT("world")); assertEquals(test2, JSON_TEXT("hello")); UnitTest::SetPrefix("TestFunctions.cpp - Duplicate"); test1 = test2.duplicate(); #ifdef JSON_UNIT_TEST assertNotEquals(test1.internal, test2.internal); #endif assertEquals(test1, test2); UnitTest::SetPrefix("TestFunctions.cpp - Duplicate with children"); JSONNode node = JSONNode(JSON_NODE); node.push_back(JSONNode(JSON_TEXT(""), 15)); node.push_back(JSONNode(JSON_TEXT(""), JSON_TEXT("hello world"))); node.push_back(JSONNode(JSON_TEXT(""), true)); TestSuite::testParsingItself(node); JSONNode dup = node.duplicate(); assertEquals(dup.size(), 3); #ifdef JSON_UNIT_TEST assertNotEquals(node.internal, dup.internal); #endif assertEquals(dup.type(), JSON_NODE); TestSuite::testParsingItself(node); TestSuite::testParsingItself(dup); try { assertEquals(dup.at(0), 15); assertEquals(dup.at(1), JSON_TEXT("hello world")); assertEquals(dup.at(2), true); assertEquals(dup.at(0), node.at(0)); assertEquals(dup.at(1), node.at(1)); assertEquals(dup.at(2), node.at(2)); } catch (std::out_of_range){ FAIL("exception caught"); } TestSuite::testParsingItself(dup); #ifdef JSON_ITERATORS for(JSONNode::iterator it = node.begin(), end = node.end(), dup_it = dup.begin(); it != end; ++it, ++dup_it){ assertEquals(*it, *dup_it); #ifdef JSON_UNIT_TEST assertNotEquals((*it).internal, (*dup_it).internal); #endif } #endif UnitTest::SetPrefix("TestFunctions.cpp - Nullify"); test1.nullify(); assertEquals(test1.type(), JSON_NULL); assertEquals(test1.name(), JSON_TEXT("")); #ifdef JSON_CASTABLE UnitTest::SetPrefix("TestFunctions.cpp - Cast"); test1.cast(JSON_NULL); test2 = 1; test2.cast(JSON_BOOL); assertEquals(test1.type(), JSON_NULL); assertEquals(test2.type(), JSON_BOOL); assertEquals(test2, true); test2 = true; assertEquals(test2, true); test2.cast(JSON_NUMBER); assertEquals(test2, 1.0f); test2 = 0.0f; assertEquals(test2, 0.0f); test2.cast(JSON_BOOL); assertEquals(test2, false); #endif UnitTest::SetPrefix("TestFunctions.cpp - Merge"); test1 = JSON_TEXT("hello"); test2 = JSON_TEXT("hello"); #ifdef JSON_UNIT_TEST assertNotEquals(test1.internal, test2.internal); #endif assertEquals(test1, test2); test1.merge(test2); #ifdef JSON_UNIT_TEST #ifdef JSON_REF_COUNT assertEquals(test1.internal, test2.internal); #else assertNotEquals(test1.internal, test2.internal); #endif #endif #ifdef JSON_CASTABLE test1.cast(JSON_NODE); test2.cast(JSON_NODE); #else test1 = JSONNode(JSON_NODE); test2 = JSONNode(JSON_NODE); #endif assertEquals(test1.type(), JSON_NODE); assertEquals(test2.type(), JSON_NODE); test1.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world"))); test2.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world"))); TestSuite::testParsingItself(test1); TestSuite::testParsingItself(test2); test1.merge(test2); #ifdef JSON_UNIT_TEST #ifdef JSON_REF_COUNT assertEquals(test1.internal, test2.internal); #else assertNotEquals(test1.internal, test2.internal); #endif #endif TestSuite::testParsingItself(test1); TestSuite::testParsingItself(test2); #endif }
inline json_string makeIndent(unsigned int amount){ if (amount == 0xFFFFFFFF) return WRITER_EMPTY; return json_string(amount, JSON_TEXT('\t')); }
return JSON_TEXT('\1'); } #ifdef JSON_READ_PRIORITY JSONNode JSONWorker::parse(const json_string & json) json_throws(std::invalid_argument) { json_auto<json_char> s; size_t len; s.set(RemoveWhiteSpace(json, len, true)); return _parse_unformatted(s.ptr, s.ptr + len); } JSONNode JSONWorker::parse_unformatted(const json_string & json) json_throws(std::invalid_argument) { #if defined JSON_DEBUG || defined JSON_SAFE #ifndef JSON_NO_EXCEPTIONS JSON_ASSERT_SAFE((json[0] == JSON_TEXT('{')) || (json[0] == JSON_TEXT('[')), JSON_TEXT("Not JSON!"), throw std::invalid_argument(json_global(EMPTY_STD_STRING));); #else JSON_ASSERT_SAFE((json[0] == JSON_TEXT('{')) || (json[0] == JSON_TEXT('[')), JSON_TEXT("Not JSON!"), return JSONNode(JSON_NULL);); #endif #endif return _parse_unformatted(json.data(), json.data() + json.length()); } JSONNode JSONWorker::_parse_unformatted(const json_char * json, const json_char * const end) json_throws(std::invalid_argument) { #ifdef JSON_COMMENTS json_char firstchar = *json; json_string _comment; json_char * runner = (json_char*)json; if (json_unlikely(firstchar == JSON_TEMP_COMMENT_IDENTIFIER)){ //multiple comments will be consolidated into one newcomment: while(*(++runner) != JSON_TEMP_COMMENT_IDENTIFIER){
void TestSuite::TestInequality(void){ UnitTest::SetPrefix("TestInequality.cpp - Inequality"); #ifdef JSON_LIBRARY JSONNODE * test1 = json_new(JSON_NODE); JSONNODE * test2 = json_new(JSON_NODE); json_set_a(test1, JSON_TEXT("hello")); json_set_a(test2, JSON_TEXT("world")); assertFalse(json_equal(test1, test2)); json_set_i(test2,13); assertFalse(json_equal(test1, test2)); json_set_f(test2, 13.5f); assertFalse(json_equal(test1, test2)); json_set_b(test2, true); assertFalse(json_equal(test1, test2)); json_set_b(test2, false); assertFalse(json_equal(test1, test2)); json_nullify(test2); assertFalse(json_equal(test1, test2)); json_delete(test1); json_delete(test2); #else JSONNode test1; JSONNode test2; test1 = JSON_TEXT("hello"); test2 = JSON_TEXT("world"); assertNotEquals(test1, test2); assertNotEquals(test1, JSON_TEXT("hi")); assertNotEquals(test2, 13.5f); assertNotEquals(test2, 14); assertNotEquals(test2, true); assertNotEquals(test2, false); test2 = 13; assertNotEquals(test1, test2); assertNotEquals(test2, 13.5f); assertNotEquals(test2, 14); assertNotEquals(test2, true); assertNotEquals(test2, false); assertNotEquals(test2, JSON_TEXT("13")); //not the same type test2 = 13.5f; assertNotEquals(test1, test2); assertNotEquals(test2, 13); assertNotEquals(test2, 14); assertNotEquals(test2, true); assertNotEquals(test2, false); assertNotEquals(test2, JSON_TEXT("13.5")); //not the same type test2 = true; assertNotEquals(test1, test2); assertNotEquals(test2, 13.5f); assertNotEquals(test2, 14); assertNotEquals(test2, false); assertNotEquals(test2, JSON_TEXT("true")); //not the same type test2 = false; assertNotEquals(test1, test2); assertNotEquals(test2, 13.5f); assertNotEquals(test2, 14); assertNotEquals(test2, true); assertNotEquals(test2, JSON_TEXT("false")); //not the same type test2.nullify(); assertNotEquals(test1, test2); assertNotEquals(test2, 13.5f); assertNotEquals(test2, 14); assertNotEquals(test2, true); assertNotEquals(test2, false); assertNotEquals(test2, "null"); //not the same type #endif }
void TestSuite::TestWriter(void){ UnitTest::SetPrefix("Writing"); #ifdef JSON_LIBRARY #define assertWrite(node, func, expected)\ {\ json_char * _temp = func(node);\ assertCStringSame(_temp, expected);\ json_free(_temp);\ } JSONNODE * test1 = json_new(JSON_NODE); assertWrite(test1, json_write, JSON_TEXT("{}")); json_push_back(test1, json_new_a(JSON_TEXT("Hello"), JSON_TEXT("World"))); json_push_back(test1, json_new_b(JSON_TEXT("libjson"), true)); assertWrite(test1, json_write, JSON_TEXT("{\"Hello\":\"World\",\"libjson\":true}")); #ifdef JSON_NEWLINE assertEquals(JSON_NEWLINE, JSON_TEXT("\r\n")); #ifdef JSON_INDENT assertEquals(JSON_INDENT, JSON_TEXT(" ")) assertWrite(test1, json_write_formatted, JSON_TEXT("{\r\n \"Hello\" : \"World\",\r\n \"libjson\" : true\r\n}")); #else assertWrite(test1, json_write_formatted, JSON_TEXT("{\r\n\t\"Hello\" : \"World\",\r\n\t\"libjson\" : true\r\n}")); #endif #else #ifdef JSON_INDENT assertEquals(JSON_INDENT, JSON_TEXT(" ")) assertWrite(test1, json_write_formatted, JSON_TEXT("{\n \"Hello\" : \"World\",\n \"libjson\" : true\n}")); #else assertWrite(test1, json_write_formatted, JSON_TEXT("{\n\t\"Hello\" : \"World\",\n\t\"libjson\" : true\n}")); #endif #endif json_delete(test1); JSONNODE * test2 = json_new(JSON_ARRAY); assertWrite(test2, json_write, JSON_TEXT("[]")); json_delete(test2); JSONNODE * card = json_new(JSON_ARRAY); JSONNODE *c = json_new(JSON_ARRAY); json_push_back(c, json_new_a(JSON_TEXT("name"), JSON_TEXT("Entrée Audio Intégrée 1"))); json_push_back(c, json_new_i(NULL, 0)); json_push_back(card, c); #ifdef JSON_UNICODE assertWrite(card, json_write, JSON_TEXT("[[\"Entr\\u00E9e Audio Int\\u00E9gr\\u00E9e 1\",0]]")) JSONNODE * ass = json_parse(JSON_TEXT("[[\"Entr\\u00E9e Audio Int\\u00E9gr\\u00E9e 1\",0]]")); JSONNODE * item = json_at(json_at(ass, 0), 0); assertWrite(item, json_as_string, JSON_TEXT("Entrée Audio Intégrée 1")); #else assertWrite(card, json_write, JSON_TEXT("[[\"Entr\\u00C3\\u00A9e Audio Int\\u00C3\\u00A9gr\\u00C3\\u00A9e 1\",0]]")) JSONNODE * ass = json_parse(JSON_TEXT("[[\"Entr\\u00C3\\u00A9e Audio Int\\u00C3\\u00A9gr\\u00C3\\u00A9e 1\",0]]")); JSONNODE * item = json_at(json_at(ass, 0), 0); assertWrite(item, json_as_string, JSON_TEXT("Entrée Audio Intégrée 1")); #endif json_delete(card); json_delete(ass); #ifdef JSON_COMMENTS JSONNODE * test3 = json_new(JSON_NODE); json_push_back(test3, json_new_a(JSON_TEXT("Hi"), JSON_TEXT("There"))); json_push_back(test3, json_new_a(JSON_TEXT("Hello"), JSON_TEXT("World"))); json_set_comment(json_at(test3, 0), JSON_TEXT("Testing stuff")); json_set_comment(json_at(test3, 1), JSON_TEXT("Multi\r\nLine\nUnix and Windows")); assertWrite(test3, json_write, JSON_TEXT("{\"Hi\":\"There\",\"Hello\":\"World\"}")); #if !defined( JSON_INDENT) && !defined(JSON_NEWLINE) #ifdef JSON_WRITE_BASH_COMMENTS assertWrite(test3, json_write_formatted, JSON_TEXT("{\n\t\n\t#Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t#Multi\n\t#Line\n\t#Unix and Windows\n\t\"Hello\" : \"World\"\n}")); #elif defined(JSON_WRITE_SINGLE_LINE_COMMENTS) assertWrite(test3, json_write_formatted, JSON_TEXT("{\n\t\n\t//Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t//Multi\n\t//Line\n\t//Unix and Windows\n\t\"Hello\" : \"World\"\n}")); #else assertWrite(test3, json_write_formatted, JSON_TEXT("{\n\t\n\t//Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t/*\n\t\tMulti\n\t\tLine\n\t\tUnix and Windows\n\t*/\n\t\"Hello\" : \"World\"\n}")); #endif #endif json_delete(test3); #endif #else JSONNode test1(JSON_NODE); assertEquals(test1.write(), JSON_TEXT("{}")); test1.push_back(JSONNode(JSON_TEXT("Hello"), JSON_TEXT("World"))); test1.push_back(JSONNode(JSON_TEXT("libjson"), true)); assertEquals(test1.write(), JSON_TEXT("{\"Hello\":\"World\",\"libjson\":true}")); #ifdef JSON_NEWLINE assertEquals(JSON_NEWLINE, JSON_TEXT("\r\n")); #ifdef JSON_INDENT assertEquals(JSON_INDENT, JSON_TEXT(" ")) assertEquals(test1.write_formatted(), JSON_TEXT("{\r\n \"Hello\" : \"World\",\r\n \"libjson\" : true\r\n}")); #else assertEquals(test1.write_formatted(), JSON_TEXT("{\r\n\t\"Hello\" : \"World\",\r\n\t\"libjson\" : true\r\n}")); #endif #else #ifdef JSON_INDENT assertEquals(JSON_INDENT, JSON_TEXT(" ")) assertEquals(test1.write_formatted(), JSON_TEXT("{\n \"Hello\" : \"World\",\n \"libjson\" : true\n}")); #else assertEquals(test1.write_formatted(), JSON_TEXT("{\n\t\"Hello\" : \"World\",\n\t\"libjson\" : true\n}")); #endif #endif JSONNode test2(JSON_ARRAY); assertEquals(test2.write(), JSON_TEXT("[]")); #ifdef JSON_COMMENTS JSONNode test3(JSON_NODE); test3.push_back(JSONNode(JSON_TEXT("Hi"), JSON_TEXT("There"))); test3.push_back(JSONNode(JSON_TEXT("Hello"), JSON_TEXT("World"))); test3[0].set_comment(JSON_TEXT("Testing stuff")); test3[1].set_comment(JSON_TEXT("Multi\r\nLine\nUnix and Windows")); assertEquals(test3.write(), JSON_TEXT("{\"Hi\":\"There\",\"Hello\":\"World\"}")); #if !defined( JSON_INDENT) && !defined(JSON_NEWLINE) #ifdef JSON_WRITE_BASH_COMMENTS assertEquals(test3.write_formatted(), JSON_TEXT("{\n\t\n\t#Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t#Multi\n\t#Line\n\t#Unix and Windows\n\t\"Hello\" : \"World\"\n}")); #elif defined(JSON_WRITE_SINGLE_LINE_COMMENTS) assertEquals(test3.write_formatted(), JSON_TEXT("{\n\t\n\t//Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t//Multi\n\t//Line\n\t//Unix and Windows\n\t\"Hello\" : \"World\"\n}")); #else assertEquals(test3.write_formatted(), JSON_TEXT("{\n\t\n\t//Testing stuff\n\t\"Hi\" : \"There\",\n\t\n\t/*\n\t\tMulti\n\t\tLine\n\t\tUnix and Windows\n\t*/\n\t\"Hello\" : \"World\"\n}")); #endif #endif #endif #endif }