Merge remote-tracking branch 'upstream/master' into TransitionTable

2 files changed, 158 insertions, 9 deletions

diff --git a/test/unittest/unittest.h b/test/unittest/unittest.h
index 0234319a..ad87d720 100644
--- a/test/unittest/unittest.h
+++ b/test/unittest/unittest.h
@@ -56,4 +56,22 @@ inline void TempFilename(char *filename) {
 			filename[i] = filename[i + 1];

 }

 

+// Use exception for catching assert

+#if _MSC_VER

+#pragma warning(disable : 4127)

+#endif

+

+class AssertException : public std::exception {

+public:

+	AssertException(const char* w) : what_(w) {}

+	AssertException(const AssertException& other) : what_(other.what_) {}

+	AssertException& operator=(const AssertException& rhs) { what_ = rhs.what_; return *this;  }

+	virtual const char* what() const throw() { return what_; }

+

+private:

+	const char* what_;

+};

+

+#define RAPIDJSON_ASSERT(x) if (!(x)) throw AssertException(RAPIDJSON_STRINGIFY(x))

+

 #endif // UNITTEST_H_

diff --git a/test/unittest/writertest.cpp b/test/unittest/writertest.cpp
index be3d77b2..48d7c4ea 100644
--- a/test/unittest/writertest.cpp
+++ b/test/unittest/writertest.cpp
@@ -1,4 +1,5 @@
 #include "unittest.h"

+

 #include "rapidjson/document.h"

 #include "rapidjson/reader.h"

 #include "rapidjson/writer.h"

@@ -14,6 +15,7 @@ TEST(Writer, Compact) {
 	reader.Parse<0>(s, writer);

 	EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3]}", buffer.GetString());

 	EXPECT_EQ(77u, buffer.GetSize());

+	EXPECT_TRUE(writer.IsComplete());

 }

 

 // json -> parse -> writer -> json

@@ -25,6 +27,7 @@ TEST(Writer, Compact) {
 		Reader reader; \

 		reader.Parse<0>(s, writer); \

 		EXPECT_STREQ(json, buffer.GetString()); \

+		EXPECT_TRUE(writer.IsComplete()); \

 	}

 

 TEST(Writer, Int) {

@@ -80,9 +83,10 @@ TEST(Writer,DoublePrecision) {
 		reader.Parse<0>(s, writer.SetDoublePrecision(12));

 		EXPECT_EQ(writer.GetDoublePrecision(), 12);

 		EXPECT_STREQ(json, buffer.GetString());

-		buffer.Clear();

 	}

 	{ // explicit individual double precisions

+		buffer.Clear();

+		writer.Reset(buffer);

 		writer.SetDoublePrecision(2);

 		writer.StartArray();

 		writer.Double(1.2345, 5);

@@ -93,11 +97,12 @@ TEST(Writer,DoublePrecision) {
 

 		EXPECT_EQ(writer.GetDoublePrecision(), 2);

 		EXPECT_STREQ(json, buffer.GetString());

-		buffer.Clear();

 	}

 	{ // write with default precision (output with precision loss)

 		Document d;

 		d.Parse<0>(json);

+		buffer.Clear();

+		writer.Reset(buffer);

 		d.Accept(writer.SetDoublePrecision());

 

 		// parsed again to avoid platform-dependent floating point outputs

@@ -108,18 +113,38 @@ TEST(Writer,DoublePrecision) {
 		EXPECT_DOUBLE_EQ(d[1u].GetDouble(), 1.23457);

 		EXPECT_DOUBLE_EQ(d[2u].GetDouble(), 0.123457);

 		EXPECT_DOUBLE_EQ(d[3u].GetDouble(), 1234570);

-		buffer.Clear();

 	}

 }

 

 TEST(Writer, Transcode) {

+	const char json[] = "{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3],\"dollar\":\"\x24\",\"cents\":\"\xC2\xA2\",\"euro\":\"\xE2\x82\xAC\",\"gclef\":\"\xF0\x9D\x84\x9E\"}";

+

 	// UTF8 -> UTF16 -> UTF8

-	StringStream s("{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3], \"dollar\":\"\x24\", \"cents\":\"\xC2\xA2\", \"euro\":\"\xE2\x82\xAC\", \"gclef\":\"\xF0\x9D\x84\x9E\" } ");

-	StringBuffer buffer;

-	Writer<StringBuffer, UTF16<>, UTF8<> > writer(buffer);

-	GenericReader<UTF8<>, UTF16<> > reader;

-	reader.Parse<0>(s, writer);

-	EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3],\"dollar\":\"\x24\",\"cents\":\"\xC2\xA2\",\"euro\":\"\xE2\x82\xAC\",\"gclef\":\"\xF0\x9D\x84\x9E\"}", buffer.GetString());

+	{

+		StringStream s(json);

+		StringBuffer buffer;

+		Writer<StringBuffer, UTF16<>, UTF8<> > writer(buffer);

+		GenericReader<UTF8<>, UTF16<> > reader;

+		reader.Parse(s, writer);

+		EXPECT_STREQ(json, buffer.GetString());

+	}

+

+	// UTF8 -> UTF8 -> ASCII -> UTF8 -> UTF8

+	{

+		StringStream s(json);

+		StringBuffer buffer;

+		Writer<StringBuffer, UTF8<>, ASCII<> > writer(buffer);

+		Reader reader;

+		reader.Parse(s, writer);

+

+		StringBuffer buffer2;

+		Writer<StringBuffer> writer2(buffer2);

+		GenericReader<ASCII<>, UTF8<> > reader2;

+		StringStream s2(buffer.GetString());

+		reader2.Parse(s2, writer2);

+

+		EXPECT_STREQ(json, buffer2.GetString());

+	}

 }

 

 #include <sstream>

@@ -160,3 +185,109 @@ TEST(Writer, OStreamWrapper) {
 	std::string actual = ss.str();

 	EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3]}", actual.c_str());

 }

+

+TEST(Writer, AssertRootMustBeArrayOrObject) {

+#define T(x)\

+	{\

+		StringBuffer buffer;\

+		Writer<StringBuffer> writer(buffer);\

+		ASSERT_THROW(x, AssertException);\

+	}

+	T(writer.Bool(false));

+	T(writer.Bool(true));

+	T(writer.Null());

+	T(writer.Int(0));

+	T(writer.Uint(0));

+	T(writer.Int64(0));

+	T(writer.Uint64(0));

+	T(writer.Double(0));

+	T(writer.String("foo"));

+#undef T

+}

+

+TEST(Writer, AssertIncorrectObjectLevel) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	writer.StartObject();

+	writer.EndObject();

+	ASSERT_THROW(writer.EndObject(), AssertException);

+}

+

+TEST(Writer, AssertIncorrectArrayLevel) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	writer.StartArray();

+	writer.EndArray();

+	ASSERT_THROW(writer.EndArray(), AssertException);

+}

+

+TEST(Writer, AssertIncorrectEndObject) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	writer.StartObject();

+	ASSERT_THROW(writer.EndArray(), AssertException);

+}

+

+TEST(Writer, AssertIncorrectEndArray) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	writer.StartObject();

+	ASSERT_THROW(writer.EndArray(), AssertException);

+}

+

+TEST(Writer, AssertObjectKeyNotString) {

+#define T(x)\

+	{\

+		StringBuffer buffer;\

+		Writer<StringBuffer> writer(buffer);\

+		writer.StartObject();\

+		ASSERT_THROW(x, AssertException); \

+	}

+	T(writer.Bool(false));

+	T(writer.Bool(true));

+	T(writer.Null());

+	T(writer.Int(0));

+	T(writer.Uint(0));

+	T(writer.Int64(0));

+	T(writer.Uint64(0));

+	T(writer.Double(0));

+	T(writer.StartObject());

+	T(writer.StartArray());

+#undef T

+}

+

+TEST(Writer, AssertMultipleRoot) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	writer.StartObject();

+	writer.EndObject();

+	ASSERT_THROW(writer.StartObject(), AssertException);

+}

+

+TEST(Writer, RootObjectIsComplete) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	EXPECT_FALSE(writer.IsComplete());

+	writer.StartObject();

+	EXPECT_FALSE(writer.IsComplete());

+	writer.String("foo");

+	EXPECT_FALSE(writer.IsComplete());

+	writer.Int(1);

+	EXPECT_FALSE(writer.IsComplete());

+	writer.EndObject();

+	EXPECT_TRUE(writer.IsComplete());

+}

+

+TEST(Writer, RootArrayIsComplete) {

+	StringBuffer buffer;

+	Writer<StringBuffer> writer(buffer);

+	EXPECT_FALSE(writer.IsComplete());

+	writer.StartArray();

+	EXPECT_FALSE(writer.IsComplete());

+	writer.String("foo");

+	EXPECT_FALSE(writer.IsComplete());

+	writer.Int(1);

+	EXPECT_FALSE(writer.IsComplete());

+	writer.EndArray();

+	EXPECT_TRUE(writer.IsComplete());

+}