rj_schema 0.0.1

data/ext/rj_schema/rapidjson/test/unittest/simdtest.cpp

@@ -0,0 +1,219 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// Since Travis CI installs old Valgrind 3.7.0, which fails with some SSE4.2
+// The unit tests prefix with SIMD should be skipped by Valgrind test
+
+// __SSE2__ and __SSE4_2__ are recognized by gcc, clang, and the Intel compiler.
+// We use -march=native with gmake to enable -msse2 and -msse4.2, if supported.
+#if defined(__SSE4_2__)
+#  define RAPIDJSON_SSE42
+#elif defined(__SSE2__)
+#  define RAPIDJSON_SSE2
+#elif defined(__ARM_NEON)
+#  define RAPIDJSON_NEON
+#endif
+
+#define RAPIDJSON_NAMESPACE rapidjson_simd
+
+#include "unittest.h"
+
+#include "rapidjson/reader.h"
+#include "rapidjson/writer.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+using namespace rapidjson_simd;
+
+#ifdef RAPIDJSON_SSE2
+#define SIMD_SUFFIX(name) name##_SSE2
+#elif defined(RAPIDJSON_SSE42)
+#define SIMD_SUFFIX(name) name##_SSE42
+#elif defined(RAPIDJSON_NEON)
+#define SIMD_SUFFIX(name) name##_NEON
+#else
+#define SIMD_SUFFIX(name) name
+#endif
+
+template <typename StreamType>
+void TestSkipWhitespace() {
+    for (size_t step = 1; step < 32; step++) {
+        char buffer[1025];
+        for (size_t i = 0; i < 1024; i++)
+            buffer[i] = " \t\r\n"[i % 4];
+        for (size_t i = 0; i < 1024; i += step)
+            buffer[i] = 'X';
+        buffer[1024] = '\0';
+
+        StreamType s(buffer);
+        size_t i = 0;
+        for (;;) {
+            SkipWhitespace(s);
+            if (s.Peek() == '\0')
+                break;
+            EXPECT_EQ(i, s.Tell());
+            EXPECT_EQ('X', s.Take());
+            i += step;
+        }
+    }
+}
+
+TEST(SIMD, SIMD_SUFFIX(SkipWhitespace)) {
+    TestSkipWhitespace<StringStream>();
+    TestSkipWhitespace<InsituStringStream>();
+}
+
+TEST(SIMD, SIMD_SUFFIX(SkipWhitespace_EncodedMemoryStream)) {
+    for (size_t step = 1; step < 32; step++) {
+        char buffer[1024];
+        for (size_t i = 0; i < 1024; i++)
+            buffer[i] = " \t\r\n"[i % 4];
+        for (size_t i = 0; i < 1024; i += step)
+            buffer[i] = 'X';
+
+        MemoryStream ms(buffer, 1024);
+        EncodedInputStream<UTF8<>, MemoryStream> s(ms);
+        size_t i = 0;
+        for (;;) {
+            SkipWhitespace(s);
+            if (s.Peek() == '\0')
+                break;
+            //EXPECT_EQ(i, s.Tell());
+            EXPECT_EQ('X', s.Take());
+            i += step;
+        }
+    }
+}
+
+struct ScanCopyUnescapedStringHandler : BaseReaderHandler<UTF8<>, ScanCopyUnescapedStringHandler> {
+    bool String(const char* str, size_t length, bool) {
+        memcpy(buffer, str, length + 1);
+        return true;
+    }
+    char buffer[1024 + 5 + 32];
+};
+
+template <unsigned parseFlags, typename StreamType>
+void TestScanCopyUnescapedString() {
+    char buffer[1024 + 5 + 32];
+    char backup[1024 + 5 + 32];
+
+    // Test "ABCDABCD...\\"
+    for (size_t offset = 0; offset < 32; offset++) {
+        for (size_t step = 0; step < 1024; step++) {
+            char* json = buffer + offset;
+            char *p = json;
+            *p++ = '\"';
+            for (size_t i = 0; i < step; i++)
+                *p++ = "ABCD"[i % 4];
+            *p++ = '\\';
+            *p++ = '\\';
+            *p++ = '\"';
+            *p++ = '\0';
+            strcpy(backup, json); // insitu parsing will overwrite buffer, so need to backup first
+
+            StreamType s(json);
+            Reader reader;
+            ScanCopyUnescapedStringHandler h;
+            reader.Parse<parseFlags>(s, h);
+            EXPECT_TRUE(memcmp(h.buffer, backup + 1, step) == 0);
+            EXPECT_EQ('\\', h.buffer[step]);    // escaped
+            EXPECT_EQ('\0', h.buffer[step + 1]);
+        }
+    }
+
+    // Test "\\ABCDABCD..."
+    for (size_t offset = 0; offset < 32; offset++) {
+        for (size_t step = 0; step < 1024; step++) {
+            char* json = buffer + offset;
+            char *p = json;
+            *p++ = '\"';
+            *p++ = '\\';
+            *p++ = '\\';
+            for (size_t i = 0; i < step; i++)
+                *p++ = "ABCD"[i % 4];
+            *p++ = '\"';
+            *p++ = '\0';
+            strcpy(backup, json); // insitu parsing will overwrite buffer, so need to backup first
+
+            StreamType s(json);
+            Reader reader;
+            ScanCopyUnescapedStringHandler h;
+            reader.Parse<parseFlags>(s, h);
+            EXPECT_TRUE(memcmp(h.buffer + 1, backup + 3, step) == 0);
+            EXPECT_EQ('\\', h.buffer[0]);    // escaped
+            EXPECT_EQ('\0', h.buffer[step + 1]);
+        }
+    }
+}
+
+TEST(SIMD, SIMD_SUFFIX(ScanCopyUnescapedString)) {
+    TestScanCopyUnescapedString<kParseDefaultFlags, StringStream>();
+    TestScanCopyUnescapedString<kParseInsituFlag, InsituStringStream>();
+}
+
+TEST(SIMD, SIMD_SUFFIX(ScanWriteUnescapedString)) {
+    char buffer[2048 + 1 + 32];
+    for (size_t offset = 0; offset < 32; offset++) {
+        for (size_t step = 0; step < 1024; step++) {
+            char* s = buffer + offset;
+            char* p = s;
+            for (size_t i = 0; i < step; i++)
+                *p++ = "ABCD"[i % 4];
+            char escape = "\0\n\\\""[step % 4];
+            *p++ = escape;
+            for (size_t i = 0; i < step; i++)
+                *p++ = "ABCD"[i % 4];
+
+            StringBuffer sb;
+            Writer<StringBuffer> writer(sb);
+            writer.String(s, SizeType(step * 2 + 1));
+            const char* q = sb.GetString();
+            EXPECT_EQ('\"', *q++);
+            for (size_t i = 0; i < step; i++)
+                EXPECT_EQ("ABCD"[i % 4], *q++);
+            if (escape == '\0') {
+                EXPECT_EQ('\\', *q++);
+                EXPECT_EQ('u', *q++);
+                EXPECT_EQ('0', *q++);
+                EXPECT_EQ('0', *q++);
+                EXPECT_EQ('0', *q++);
+                EXPECT_EQ('0', *q++);
+            }
+            else if (escape == '\n') {
+                EXPECT_EQ('\\', *q++);
+                EXPECT_EQ('n', *q++);
+            }
+            else if (escape == '\\') {
+                EXPECT_EQ('\\', *q++);
+                EXPECT_EQ('\\', *q++);
+            }
+            else if (escape == '\"') {
+                EXPECT_EQ('\\', *q++);
+                EXPECT_EQ('\"', *q++);
+            }
+            for (size_t i = 0; i < step; i++)
+                EXPECT_EQ("ABCD"[i % 4], *q++);
+            EXPECT_EQ('\"', *q++);
+            EXPECT_EQ('\0', *q++);
+        }
+    }
+}
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif

data/ext/rj_schema/rapidjson/test/unittest/strfunctest.cpp

@@ -0,0 +1,30 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#include "unittest.h"
+#include "rapidjson/internal/strfunc.h"
+
+using namespace rapidjson;
+using namespace rapidjson::internal;
+
+TEST(StrFunc, CountStringCodePoint) {
+    SizeType count;
+    EXPECT_TRUE(CountStringCodePoint<UTF8<> >("", 0, &count));
+    EXPECT_EQ(0u, count);
+    EXPECT_TRUE(CountStringCodePoint<UTF8<> >("Hello", 5, &count));
+    EXPECT_EQ(5u, count);
+    EXPECT_TRUE(CountStringCodePoint<UTF8<> >("\xC2\xA2\xE2\x82\xAC\xF0\x9D\x84\x9E", 9, &count)); // cents euro G-clef
+    EXPECT_EQ(3u, count);
+    EXPECT_FALSE(CountStringCodePoint<UTF8<> >("\xC2\xA2\xE2\x82\xAC\xF0\x9D\x84\x9E\x80", 10, &count));
+}

data/ext/rj_schema/rapidjson/test/unittest/stringbuffertest.cpp

@@ -0,0 +1,192 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#include "unittest.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/writer.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+using namespace rapidjson;
+
+TEST(StringBuffer, InitialSize) {
+    StringBuffer buffer;
+    EXPECT_EQ(0u, buffer.GetSize());
+    EXPECT_EQ(0u, buffer.GetLength());
+    EXPECT_STREQ("", buffer.GetString());
+}
+
+TEST(StringBuffer, Put) {
+    StringBuffer buffer;
+    buffer.Put('A');
+
+    EXPECT_EQ(1u, buffer.GetSize());
+    EXPECT_EQ(1u, buffer.GetLength());
+    EXPECT_STREQ("A", buffer.GetString());
+}
+
+TEST(StringBuffer, PutN_Issue672) {
+    GenericStringBuffer<UTF8<>, MemoryPoolAllocator<> > buffer;
+    EXPECT_EQ(0, buffer.GetSize());
+    EXPECT_EQ(0, buffer.GetLength());
+    rapidjson::PutN(buffer, ' ', 1);
+    EXPECT_EQ(1, buffer.GetSize());
+    EXPECT_EQ(1, buffer.GetLength());
+}
+
+TEST(StringBuffer, Clear) {
+    StringBuffer buffer;
+    buffer.Put('A');
+    buffer.Put('B');
+    buffer.Put('C');
+    buffer.Clear();
+
+    EXPECT_EQ(0u, buffer.GetSize());
+    EXPECT_EQ(0u, buffer.GetLength());
+    EXPECT_STREQ("", buffer.GetString());
+}
+
+TEST(StringBuffer, Push) {
+    StringBuffer buffer;
+    buffer.Push(5);
+
+    EXPECT_EQ(5u, buffer.GetSize());
+    EXPECT_EQ(5u, buffer.GetLength());
+
+    // Causes sudden expansion to make the stack's capacity equal to size
+    buffer.Push(65536u);
+    EXPECT_EQ(5u + 65536u, buffer.GetSize());
+}
+
+TEST(StringBuffer, Pop) {
+    StringBuffer buffer;
+    buffer.Put('A');
+    buffer.Put('B');
+    buffer.Put('C');
+    buffer.Put('D');
+    buffer.Put('E');
+    buffer.Pop(3);
+
+    EXPECT_EQ(2u, buffer.GetSize());
+    EXPECT_EQ(2u, buffer.GetLength());
+    EXPECT_STREQ("AB", buffer.GetString());
+}
+
+TEST(StringBuffer, GetLength_Issue744) {
+    GenericStringBuffer<UTF16<wchar_t> > buffer;
+    buffer.Put('A');
+    buffer.Put('B');
+    buffer.Put('C');
+    EXPECT_EQ(3u * sizeof(wchar_t), buffer.GetSize());
+    EXPECT_EQ(3u, buffer.GetLength());
+}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+#if 0 // Many old compiler does not support these. Turn it off temporaily.
+
+#include <type_traits>
+
+TEST(StringBuffer, Traits) {
+    static_assert( std::is_constructible<StringBuffer>::value, "");
+    static_assert( std::is_default_constructible<StringBuffer>::value, "");
+#ifndef _MSC_VER
+    static_assert(!std::is_copy_constructible<StringBuffer>::value, "");
+#endif
+    static_assert( std::is_move_constructible<StringBuffer>::value, "");
+
+    static_assert(!std::is_nothrow_constructible<StringBuffer>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<StringBuffer>::value, "");
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1800
+    static_assert(!std::is_nothrow_copy_constructible<StringBuffer>::value, "");
+    static_assert(!std::is_nothrow_move_constructible<StringBuffer>::value, "");
+#endif
+
+    static_assert( std::is_assignable<StringBuffer,StringBuffer>::value, "");
+#ifndef _MSC_VER
+    static_assert(!std::is_copy_assignable<StringBuffer>::value, "");
+#endif
+    static_assert( std::is_move_assignable<StringBuffer>::value, "");
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1800
+    static_assert(!std::is_nothrow_assignable<StringBuffer, StringBuffer>::value, "");
+#endif
+
+    static_assert(!std::is_nothrow_copy_assignable<StringBuffer>::value, "");
+    static_assert(!std::is_nothrow_move_assignable<StringBuffer>::value, "");
+
+    static_assert( std::is_destructible<StringBuffer>::value, "");
+#ifndef _MSC_VER
+    static_assert(std::is_nothrow_destructible<StringBuffer>::value, "");
+#endif
+}
+
+#endif
+
+TEST(StringBuffer, MoveConstructor) {
+    StringBuffer x;
+    x.Put('A');
+    x.Put('B');
+    x.Put('C');
+    x.Put('D');
+
+    EXPECT_EQ(4u, x.GetSize());
+    EXPECT_EQ(4u, x.GetLength());
+    EXPECT_STREQ("ABCD", x.GetString());
+
+    // StringBuffer y(x); // does not compile (!is_copy_constructible)
+    StringBuffer y(std::move(x));
+    EXPECT_EQ(0u, x.GetSize());
+    EXPECT_EQ(0u, x.GetLength());
+    EXPECT_EQ(4u, y.GetSize());
+    EXPECT_EQ(4u, y.GetLength());
+    EXPECT_STREQ("ABCD", y.GetString());
+
+    // StringBuffer z = y; // does not compile (!is_copy_assignable)
+    StringBuffer z = std::move(y);
+    EXPECT_EQ(0u, y.GetSize());
+    EXPECT_EQ(0u, y.GetLength());
+    EXPECT_EQ(4u, z.GetSize());
+    EXPECT_EQ(4u, z.GetLength());
+    EXPECT_STREQ("ABCD", z.GetString());
+}
+
+TEST(StringBuffer, MoveAssignment) {
+    StringBuffer x;
+    x.Put('A');
+    x.Put('B');
+    x.Put('C');
+    x.Put('D');
+
+    EXPECT_EQ(4u, x.GetSize());
+    EXPECT_EQ(4u, x.GetLength());
+    EXPECT_STREQ("ABCD", x.GetString());
+
+    StringBuffer y;
+    // y = x; // does not compile (!is_copy_assignable)
+    y = std::move(x);
+    EXPECT_EQ(0u, x.GetSize());
+    EXPECT_EQ(4u, y.GetLength());
+    EXPECT_STREQ("ABCD", y.GetString());
+}
+
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif

data/ext/rj_schema/rapidjson/test/unittest/strtodtest.cpp

@@ -0,0 +1,132 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#include "unittest.h"
+
+#include "rapidjson/internal/strtod.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+#define BIGINTEGER_LITERAL(s) BigInteger(s, sizeof(s) - 1)
+
+using namespace rapidjson::internal;
+
+TEST(Strtod, CheckApproximationCase) {
+    static const int kSignificandSize = 52;
+    static const int kExponentBias = 0x3FF;
+    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    // http://www.exploringbinary.com/using-integers-to-check-a-floating-point-approximation/
+    // Let b = 0x1.465a72e467d88p-149
+    //       = 5741268244528520 x 2^-201
+    union {
+        double d;
+        uint64_t u;
+    }u;
+    u.u = 0x465a72e467d88 | ((static_cast<uint64_t>(-149 + kExponentBias)) << kSignificandSize);
+    const double b = u.d;
+    const uint64_t bInt = (u.u & kSignificandMask) | kHiddenBit;
+    const int bExp = static_cast<int>(((u.u & kExponentMask) >> kSignificandSize) - kExponentBias - kSignificandSize);
+    EXPECT_DOUBLE_EQ(1.7864e-45, b);
+    EXPECT_EQ(RAPIDJSON_UINT64_C2(0x001465a7, 0x2e467d88), bInt);
+    EXPECT_EQ(-201, bExp);
+
+    // Let d = 17864 x 10-49
+    const char dInt[] = "17864";
+    const int dExp = -49;
+
+    // Let h = 2^(bExp-1)
+    const int hExp = bExp - 1;
+    EXPECT_EQ(-202, hExp);
+
+    int dS_Exp2 = 0;
+    int dS_Exp5 = 0;
+    int bS_Exp2 = 0;
+    int bS_Exp5 = 0;
+    int hS_Exp2 = 0;
+    int hS_Exp5 = 0;
+
+    // Adjust for decimal exponent
+    if (dExp >= 0) {
+        dS_Exp2 += dExp;
+        dS_Exp5 += dExp;
+    }
+    else {
+        bS_Exp2 -= dExp;
+        bS_Exp5 -= dExp;
+        hS_Exp2 -= dExp;
+        hS_Exp5 -= dExp;
+    }
+
+    // Adjust for binary exponent
+    if (bExp >= 0)
+        bS_Exp2 += bExp;
+    else {
+        dS_Exp2 -= bExp;
+        hS_Exp2 -= bExp;
+    }
+
+    // Adjust for half ulp exponent
+    if (hExp >= 0)
+        hS_Exp2 += hExp;
+    else {
+        dS_Exp2 -= hExp;
+        bS_Exp2 -= hExp;
+    }
+
+    // Remove common power of two factor from all three scaled values
+    int common_Exp2 = (std::min)(dS_Exp2, (std::min)(bS_Exp2, hS_Exp2));
+    dS_Exp2 -= common_Exp2;
+    bS_Exp2 -= common_Exp2;
+    hS_Exp2 -= common_Exp2;
+
+    EXPECT_EQ(153, dS_Exp2);
+    EXPECT_EQ(0, dS_Exp5);
+    EXPECT_EQ(1, bS_Exp2);
+    EXPECT_EQ(49, bS_Exp5);
+    EXPECT_EQ(0, hS_Exp2);
+    EXPECT_EQ(49, hS_Exp5);
+
+    BigInteger dS = BIGINTEGER_LITERAL(dInt);
+    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<size_t>(dS_Exp2);
+
+    BigInteger bS(bInt);
+    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<size_t>(bS_Exp2);
+
+    BigInteger hS(1);
+    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<size_t>(hS_Exp2);
+
+    EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994138521801764465966248930731085529088") == dS);
+    EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994122305215569213032722473144531250000") == bS);
+    EXPECT_TRUE(BIGINTEGER_LITERAL("17763568394002504646778106689453125") == hS);
+
+    EXPECT_EQ(1, dS.Compare(bS));
+    
+    BigInteger delta(0);
+    EXPECT_FALSE(dS.Difference(bS, &delta));
+    EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta);
+    EXPECT_TRUE(bS.Difference(dS, &delta));
+    EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta);
+
+    EXPECT_EQ(-1, delta.Compare(hS));
+}
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif