add unittest for `EncodeUnsafe` to increase coverage.

include/rapidjson/encodings.h

@@ -691,6 +691,8 @@ struct AutoUTF {
 
     \tprarm CodePointValidation Run validate before encode or not.
 */
+// By default, This Encoder will validate code point and generate parse error.
+// Users can switch the check feature off by set 'CodePointValidation' to 'false'.
 template<bool CodePointValidation = true>
 class ValidatableEncoder {
 public:
@@ -701,7 +703,6 @@ public:
     static bool EncodeUnsafe(OutputStream &os, unsigned codepoint);
 };
 
-// By default, reader will validate code point and generate parse error.
 template<bool CodePointValidation>
 template<typename TEncoding, typename OutputStream>
 bool
@@ -724,7 +725,6 @@ ValidatableEncoder<CodePointValidation>::EncodeUnsafe(OutputStream &os, unsigned
     return true;
 }
 
-// Users can switch the check feature off by set 'CodePointValidation' to 'false'.
 template<>
 template<typename TEncoding, typename OutputStream>
 bool
@@ -733,7 +733,6 @@ ValidatableEncoder<false>::Encode(OutputStream &os, unsigned codepoint) {
     return true;
 }
 
-// Users can switch the check feature off by set 'CodePointValidation' to 'false'.
 template<>
 template<typename TEncoding, typename OutputStream>
 bool

test/unittest/encodingstest.cpp

@@ -14,8 +14,6 @@
 
 #include "unittest.h"
 #include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"
 #include "rapidjson/stringbuffer.h"
 
 using namespace rapidjson;
@@ -332,6 +330,12 @@ TEST(EncodingsTest, UTF8) {
             }
         }
     }
+
+    // Validate code point before encoding
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<UTF8<>>(os, 0xFFFFFFFF));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<UTF8<>>(os, 0xFFFFFFFF));
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<UTF8<>>(os, 0xFFFFFFFF), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<UTF8<>>(os, 0xFFFFFFFF), AssertException);
 }
 
 TEST(EncodingsTest, UTF16) {
@@ -392,6 +396,20 @@ TEST(EncodingsTest, UTF16) {
             }
         }
     }
+
+    // Validate code point before encoding
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<UTF16<>>(os, 0xFFFFFFFF));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<UTF16<>>(os, 0xFFFFFFFF));
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<UTF16<>>(os, 0xD800));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<UTF16<>>(os, 0xD800));
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<UTF16<>>(os, 0xDFFF));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<UTF16<>>(os, 0xDFFF));
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<UTF16<>>(os, 0xFFFFFFFF), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<UTF16<>>(os, 0xFFFFFFFF), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<UTF16<>>(os, 0xD800), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<UTF16<>>(os, 0xD800), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<UTF16<>>(os, 0xDFFF), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<UTF16<>>(os, 0xDFFF), AssertException);
 }
 
 TEST(EncodingsTest, UTF32) {
@@ -423,6 +441,12 @@ TEST(EncodingsTest, UTF32) {
             }
         }
     }
+
+    // Validate code point before encoding
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<UTF32<>>(os, 0xFFFFFFFF));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<UTF32<>>(os, 0xFFFFFFFF));
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<UTF32<>>(os, 0xFFFFFFFF), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<UTF32<>>(os, 0xFFFFFFFF), AssertException);
 }
 
 TEST(EncodingsTest, ASCII) {
@@ -448,4 +472,10 @@ TEST(EncodingsTest, ASCII) {
             EXPECT_EQ(0, StrCmp(encodedStr, os2.GetString()));
         }
     }
+
+    // Validate code point before encoding
+    EXPECT_FALSE(ValidatableEncoder<>::Encode<ASCII<>>(os, 0x0080));
+    EXPECT_FALSE(ValidatableEncoder<>::EncodeUnsafe<ASCII<>>(os, 0x0080));
+    EXPECT_THROW(ValidatableEncoder<false>::Encode<ASCII<>>(os, 0x0080), AssertException);
+    EXPECT_THROW(ValidatableEncoder<false>::EncodeUnsafe<ASCII<>>(os, 0x0080), AssertException);
 }