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
}
