rj_schema 0.2.4 → 0.2.5

data/ext/rj_schema/rapidjson/test/perftest/schematest.cpp

@@ -0,0 +1,223 @@
+#include "perftest.h"
+
+#if TEST_RAPIDJSON
+
+#include "rapidjson/schema.h"
+#include <ctime>
+#include <string>
+#include <vector>
+
+#define ARRAY_SIZE(a) sizeof(a) / sizeof(a[0])
+
+using namespace rapidjson;
+
+RAPIDJSON_DIAG_PUSH
+#if defined(__GNUC__) && __GNUC__ >= 7
+RAPIDJSON_DIAG_OFF(format-overflow)
+#endif
+
+template <typename Allocator>
+static char* ReadFile(const char* filename, Allocator& allocator) {
+    const char *paths[] = {
+        "",
+        "bin/",
+        "../bin/",
+        "../../bin/",
+        "../../../bin/"
+    };
+    char buffer[1024];
+    FILE *fp = 0;
+    for (size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); i++) {
+        sprintf(buffer, "%s%s", paths[i], filename);
+        fp = fopen(buffer, "rb");
+        if (fp)
+            break;
+    }
+
+    if (!fp)
+        return 0;
+
+    fseek(fp, 0, SEEK_END);
+    size_t length = static_cast<size_t>(ftell(fp));
+    fseek(fp, 0, SEEK_SET);
+    char* json = reinterpret_cast<char*>(allocator.Malloc(length + 1));
+    size_t readLength = fread(json, 1, length, fp);
+    json[readLength] = '\0';
+    fclose(fp);
+    return json;
+}
+
+RAPIDJSON_DIAG_POP
+
+class Schema : public PerfTest {
+public:
+    Schema() {}
+
+    virtual void SetUp() {
+        PerfTest::SetUp();
+
+        const char* filenames[] = {
+            "additionalItems.json",
+            "additionalProperties.json",
+            "allOf.json",
+            "anyOf.json",
+            "default.json",
+            "definitions.json",
+            "dependencies.json",
+            "enum.json",
+            "items.json",
+            "maximum.json",
+            "maxItems.json",
+            "maxLength.json",
+            "maxProperties.json",
+            "minimum.json",
+            "minItems.json",
+            "minLength.json",
+            "minProperties.json",
+            "multipleOf.json",
+            "not.json",
+            "oneOf.json",
+            "pattern.json",
+            "patternProperties.json",
+            "properties.json",
+            "ref.json",
+            "refRemote.json",
+            "required.json",
+            "type.json",
+            "uniqueItems.json"
+        };
+
+        char jsonBuffer[65536];
+        MemoryPoolAllocator<> jsonAllocator(jsonBuffer, sizeof(jsonBuffer));
+
+        for (size_t i = 0; i < ARRAY_SIZE(filenames); i++) {
+            char filename[FILENAME_MAX];
+            sprintf(filename, "jsonschema/tests/draft4/%s", filenames[i]);
+            char* json = ReadFile(filename, jsonAllocator);
+            if (!json) {
+                printf("json test suite file %s not found", filename);
+                return;
+            }
+
+            Document d;
+            d.Parse(json);
+            if (d.HasParseError()) {
+                printf("json test suite file %s has parse error", filename);
+                return;
+            }
+
+            for (Value::ConstValueIterator schemaItr = d.Begin(); schemaItr != d.End(); ++schemaItr) {
+                std::string schemaDescription = (*schemaItr)["description"].GetString();
+                if (IsExcludeTestSuite(schemaDescription))
+                    continue;
+
+                TestSuite* ts = new TestSuite;
+                ts->schema = new SchemaDocument((*schemaItr)["schema"]);
+
+                const Value& tests = (*schemaItr)["tests"];
+                for (Value::ConstValueIterator testItr = tests.Begin(); testItr != tests.End(); ++testItr) {
+                    if (IsExcludeTest(schemaDescription + ", " + (*testItr)["description"].GetString()))
+                        continue;
+
+                    Document* d2 = new Document;
+                    d2->CopyFrom((*testItr)["data"], d2->GetAllocator());
+                    ts->tests.push_back(d2);
+                }
+                testSuites.push_back(ts);
+            }
+        }
+    }
+
+    virtual void TearDown() {
+        PerfTest::TearDown();
+        for (TestSuiteList::const_iterator itr = testSuites.begin(); itr != testSuites.end(); ++itr)
+            delete *itr;
+        testSuites.clear();
+    }
+
+private:
+    // Using the same exclusion in https://github.com/json-schema/JSON-Schema-Test-Suite
+    static bool IsExcludeTestSuite(const std::string& description) {
+        const char* excludeTestSuites[] = {
+            //lost failing these tests
+            "remote ref",
+            "remote ref, containing refs itself",
+            "fragment within remote ref",
+            "ref within remote ref",
+            "change resolution scope",
+            // these below were added to get jsck in the benchmarks)
+            "uniqueItems validation",
+            "valid definition",
+            "invalid definition"
+        };
+
+        for (size_t i = 0; i < ARRAY_SIZE(excludeTestSuites); i++)
+            if (excludeTestSuites[i] == description)
+                return true;
+        return false;
+    }
+
+    // Using the same exclusion in https://github.com/json-schema/JSON-Schema-Test-Suite
+    static bool IsExcludeTest(const std::string& description) {
+        const char* excludeTests[] = {
+            //lots of validators fail these
+            "invalid definition, invalid definition schema",
+            "maxLength validation, two supplementary Unicode code points is long enough",
+            "minLength validation, one supplementary Unicode code point is not long enough",
+            //this is to get tv4 in the benchmarks
+            "heterogeneous enum validation, something else is invalid"
+        };
+
+        for (size_t i = 0; i < ARRAY_SIZE(excludeTests); i++)
+            if (excludeTests[i] == description)
+                return true;
+        return false;
+    }
+
+    Schema(const Schema&);
+    Schema& operator=(const Schema&);
+
+protected:
+    typedef std::vector<Document*> DocumentList;
+
+    struct TestSuite {
+        TestSuite() : schema() {}
+        ~TestSuite() {
+            delete schema;
+            for (DocumentList::iterator itr = tests.begin(); itr != tests.end(); ++itr)
+                delete *itr;
+        }
+        SchemaDocument* schema;
+        DocumentList tests;
+    };
+
+    typedef std::vector<TestSuite* > TestSuiteList;
+    TestSuiteList testSuites;
+};
+
+TEST_F(Schema, TestSuite) {
+    char validatorBuffer[65536];
+    MemoryPoolAllocator<> validatorAllocator(validatorBuffer, sizeof(validatorBuffer));
+
+    const int trialCount = 100000;
+    int testCount = 0;
+    clock_t start = clock();
+    for (int i = 0; i < trialCount; i++) {
+        for (TestSuiteList::const_iterator itr = testSuites.begin(); itr != testSuites.end(); ++itr) {
+            const TestSuite& ts = **itr;
+            GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<> >, MemoryPoolAllocator<> >  validator(*ts.schema, &validatorAllocator);
+            for (DocumentList::const_iterator testItr = ts.tests.begin(); testItr != ts.tests.end(); ++testItr) {
+                validator.Reset();
+                (*testItr)->Accept(validator);
+                testCount++;
+            }
+            validatorAllocator.Clear();
+        }
+    }
+    clock_t end = clock();
+    double duration = double(end - start) / CLOCKS_PER_SEC;
+    printf("%d trials in %f s -> %f trials per sec\n", trialCount, duration, trialCount / duration);
+    printf("%d tests per trial\n", testCount / trialCount);
+}
+
+#endif

data/ext/rj_schema/rapidjson/test/unittest/CMakeLists.txt

@@ -0,0 +1,92 @@
+include(CheckCXXCompilerFlag)
+
+set(UNITTEST_SOURCES
+	allocatorstest.cpp
+    bigintegertest.cpp
+	cursorstreamwrappertest.cpp
+    documenttest.cpp
+    dtoatest.cpp
+    encodedstreamtest.cpp
+    encodingstest.cpp
+    fwdtest.cpp
+    filestreamtest.cpp
+    itoatest.cpp
+    istreamwrappertest.cpp
+    jsoncheckertest.cpp
+    namespacetest.cpp
+    pointertest.cpp
+    prettywritertest.cpp
+    ostreamwrappertest.cpp
+    readertest.cpp
+    regextest.cpp
+	schematest.cpp
+	simdtest.cpp
+    strfunctest.cpp
+    stringbuffertest.cpp
+    strtodtest.cpp
+    unittest.cpp
+    valuetest.cpp
+    writertest.cpp)
+
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments -fcolor-diagnostics")
+		endif()
+endif(CCACHE_FOUND)
+
+set_property(DIRECTORY PROPERTY COMPILE_OPTIONS ${EXTRA_CXX_FLAGS})
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # If the user is running a newer version of Clang that includes the
+    # -Wdouble-promotion, we will ignore that warning.
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 3.7)
+        CHECK_CXX_COMPILER_FLAG("-Wno-double-promotion" HAS_NO_DOUBLE_PROMOTION)
+        if (HAS_NO_DOUBLE_PROMOTION)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-double-promotion")
+        endif()
+    endif()
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    # Force to always compile with /W4
+    if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+        string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    else()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+    endif()
+
+    # Force to always compile with /WX
+    if(CMAKE_CXX_FLAGS MATCHES "/WX-")
+        string(REGEX REPLACE "/WX-" "/WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    else()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
+    endif()
+endif()
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRAPIDJSON_HAS_STDSTRING=1")
+
+add_library(namespacetest STATIC namespacetest.cpp)
+
+add_executable(unittest ${UNITTEST_SOURCES})
+target_link_libraries(unittest ${TEST_LIBRARIES} namespacetest)
+
+add_dependencies(tests unittest)
+
+add_test(NAME unittest
+    COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unittest
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+
+if(NOT MSVC)
+    # Not running SIMD.* unit test cases for Valgrind
+    add_test(NAME valgrind_unittest
+        COMMAND valgrind --suppressions=${CMAKE_SOURCE_DIR}/test/valgrind.supp --leak-check=full --error-exitcode=1 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unittest --gtest_filter=-SIMD.*
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        add_test(NAME symbol_check
+        COMMAND sh -c "objdump -t -C libnamespacetest.a | grep rapidjson ; test $? -ne 0"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif(CMAKE_BUILD_TYPE STREQUAL "Debug")
+
+endif(NOT MSVC)

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

@@ -0,0 +1,100 @@
+// 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/allocators.h"
+
+using namespace rapidjson;
+
+template <typename Allocator>
+void TestAllocator(Allocator& a) {
+    EXPECT_TRUE(a.Malloc(0) == 0);
+
+    uint8_t* p = static_cast<uint8_t*>(a.Malloc(100));
+    EXPECT_TRUE(p != 0);
+    for (size_t i = 0; i < 100; i++)
+        p[i] = static_cast<uint8_t>(i);
+
+    // Expand
+    uint8_t* q = static_cast<uint8_t*>(a.Realloc(p, 100, 200));
+    EXPECT_TRUE(q != 0);
+    for (size_t i = 0; i < 100; i++)
+        EXPECT_EQ(i, q[i]);
+    for (size_t i = 100; i < 200; i++)
+        q[i] = static_cast<uint8_t>(i);
+
+    // Shrink
+    uint8_t *r = static_cast<uint8_t*>(a.Realloc(q, 200, 150));
+    EXPECT_TRUE(r != 0);
+    for (size_t i = 0; i < 150; i++)
+        EXPECT_EQ(i, r[i]);
+
+    Allocator::Free(r);
+
+    // Realloc to zero size
+    EXPECT_TRUE(a.Realloc(a.Malloc(1), 1, 0) == 0);
+}
+
+TEST(Allocator, CrtAllocator) {
+    CrtAllocator a;
+    TestAllocator(a);
+}
+
+TEST(Allocator, MemoryPoolAllocator) {
+    MemoryPoolAllocator<> a;
+    TestAllocator(a);
+
+    for (size_t i = 1; i < 1000; i++) {
+        EXPECT_TRUE(a.Malloc(i) != 0);
+        EXPECT_LE(a.Size(), a.Capacity());
+    }
+}
+
+TEST(Allocator, Alignment) {
+    if (sizeof(size_t) >= 8) {
+        EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000000), RAPIDJSON_ALIGN(0));
+        for (uint64_t i = 1; i < 8; i++) {
+            EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008), RAPIDJSON_ALIGN(i));
+            EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000010), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008) + i));
+            EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000001, 0x00000000), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0xFFFFFFF8) + i));
+            EXPECT_EQ(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF8), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0) + i));
+        }
+    }
+
+    EXPECT_EQ(0u, RAPIDJSON_ALIGN(0u));
+    for (uint32_t i = 1; i < 8; i++) {
+        EXPECT_EQ(8u, RAPIDJSON_ALIGN(i));
+        EXPECT_EQ(0xFFFFFFF8u, RAPIDJSON_ALIGN(0xFFFFFFF0u + i));
+    }
+}
+
+TEST(Allocator, Issue399) {
+    MemoryPoolAllocator<> a;
+    void* p = a.Malloc(100);
+    void* q = a.Realloc(p, 100, 200);
+    EXPECT_EQ(p, q);
+
+    // exhuasive testing
+    for (size_t j = 1; j < 32; j++) {
+        a.Clear();
+        a.Malloc(j); // some unaligned size
+        p = a.Malloc(1);
+        for (size_t i = 1; i < 1024; i++) {
+            q = a.Realloc(p, i, i + 1);
+            EXPECT_EQ(p, q);
+            p = q;
+        }
+    }
+}

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

@@ -0,0 +1,138 @@
+// 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/biginteger.h"
+
+using namespace rapidjson::internal;
+
+#define BIGINTEGER_LITERAL(s) BigInteger(s, sizeof(s) - 1)
+
+static const BigInteger kZero(0);
+static const BigInteger kOne(1);
+static const BigInteger kUint64Max = BIGINTEGER_LITERAL("18446744073709551615");
+static const BigInteger kTwo64 = BIGINTEGER_LITERAL("18446744073709551616");
+
+TEST(BigInteger, Constructor) {
+    EXPECT_TRUE(kZero.IsZero());
+    EXPECT_TRUE(kZero == kZero);
+    EXPECT_TRUE(kZero == BIGINTEGER_LITERAL("0"));
+    EXPECT_TRUE(kZero == BIGINTEGER_LITERAL("00"));
+
+    const BigInteger a(123);
+    EXPECT_TRUE(a == a);
+    EXPECT_TRUE(a == BIGINTEGER_LITERAL("123"));
+    EXPECT_TRUE(a == BIGINTEGER_LITERAL("0123"));
+
+    EXPECT_EQ(2u, kTwo64.GetCount());
+    EXPECT_EQ(0u, kTwo64.GetDigit(0));
+    EXPECT_EQ(1u, kTwo64.GetDigit(1));
+}
+
+TEST(BigInteger, AddUint64) {
+    BigInteger a = kZero;
+    a += 0u;
+    EXPECT_TRUE(kZero == a);
+
+    a += 1u;
+    EXPECT_TRUE(kOne == a);
+
+    a += 1u;
+    EXPECT_TRUE(BigInteger(2) == a);
+
+    EXPECT_TRUE(BigInteger(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF)) == kUint64Max);
+    BigInteger b = kUint64Max;
+    b += 1u;
+    EXPECT_TRUE(kTwo64 == b);
+    b += RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
+    EXPECT_TRUE(BIGINTEGER_LITERAL("36893488147419103231") == b);
+}
+
+TEST(BigInteger, MultiplyUint64) {
+    BigInteger a = kZero;
+    a *= static_cast <uint64_t>(0);
+    EXPECT_TRUE(kZero == a);
+    a *= static_cast <uint64_t>(123);
+    EXPECT_TRUE(kZero == a);
+
+    BigInteger b = kOne;
+    b *= static_cast<uint64_t>(1);
+    EXPECT_TRUE(kOne == b);
+    b *= static_cast<uint64_t>(0);
+    EXPECT_TRUE(kZero == b);
+
+    BigInteger c(123);
+    c *= static_cast<uint64_t>(456u);
+    EXPECT_TRUE(BigInteger(123u * 456u) == c);
+    c *= RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
+    EXPECT_TRUE(BIGINTEGER_LITERAL("1034640981606221330982120") == c);
+    c *= RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
+    EXPECT_TRUE(BIGINTEGER_LITERAL("19085757395861596536664473018420572782123800") == c);
+}
+
+TEST(BigInteger, MultiplyUint32) {
+    BigInteger a = kZero;
+    a *= static_cast <uint32_t>(0);
+    EXPECT_TRUE(kZero == a);
+    a *= static_cast <uint32_t>(123);
+    EXPECT_TRUE(kZero == a);
+
+    BigInteger b = kOne;
+    b *= static_cast<uint32_t>(1);
+    EXPECT_TRUE(kOne == b);
+    b *= static_cast<uint32_t>(0);
+    EXPECT_TRUE(kZero == b);
+
+    BigInteger c(123);
+    c *= static_cast<uint32_t>(456u);
+    EXPECT_TRUE(BigInteger(123u * 456u) == c);
+    c *= 0xFFFFFFFFu;
+    EXPECT_TRUE(BIGINTEGER_LITERAL("240896125641960") == c);
+    c *= 0xFFFFFFFFu;
+    EXPECT_TRUE(BIGINTEGER_LITERAL("1034640981124429079698200") == c);
+}
+
+TEST(BigInteger, LeftShift) {
+    BigInteger a = kZero;
+    a <<= 1;
+    EXPECT_TRUE(kZero == a);
+    a <<= 64;
+    EXPECT_TRUE(kZero == a);
+
+    a = BigInteger(123);
+    a <<= 0;
+    EXPECT_TRUE(BigInteger(123) == a);
+    a <<= 1;
+    EXPECT_TRUE(BigInteger(246) == a);
+    a <<= 64;
+    EXPECT_TRUE(BIGINTEGER_LITERAL("4537899042132549697536") == a);
+    a <<= 99;
+    EXPECT_TRUE(BIGINTEGER_LITERAL("2876235222267216943024851750785644982682875244576768") == a);
+
+    a = 1;
+    a <<= 64; // a.count_ != 1
+    a <<= 256; // interShift == 0
+    EXPECT_TRUE(BIGINTEGER_LITERAL("2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576") == a);
+}
+
+TEST(BigInteger, Compare) {
+    EXPECT_EQ(0, kZero.Compare(kZero));
+    EXPECT_EQ(1, kOne.Compare(kZero));
+    EXPECT_EQ(-1, kZero.Compare(kOne));
+    EXPECT_EQ(0, kUint64Max.Compare(kUint64Max));
+    EXPECT_EQ(0, kTwo64.Compare(kTwo64));
+    EXPECT_EQ(-1, kUint64Max.Compare(kTwo64));
+    EXPECT_EQ(1, kTwo64.Compare(kUint64Max));
+}