simdtest.cpp File Reference

#include "unittest.h"
#include "rapidjson/reader.h"
#include "rapidjson/writer.h"

Include dependency graph for simdtest.cpp:

Go to the source code of this file.

Classes
struct	ScanCopyUnescapedStringHandler

Macros
#define	RAPIDJSON_NAMESPACE   rapidjson_simd
#define	SIMD_SUFFIX(name)

Functions
template<typename StreamType >
void	TestSkipWhitespace ()
	TEST (SIMD, SIMD_SUFFIX(SkipWhitespace))
	TEST (SIMD, SIMD_SUFFIX(SkipWhitespace_EncodedMemoryStream))
template<unsigned parseFlags, typename StreamType >
void	TestScanCopyUnescapedString ()
	TEST (SIMD, SIMD_SUFFIX(ScanCopyUnescapedString))
	TEST (SIMD, SIMD_SUFFIX(ScanWriteUnescapedString))

Macro Definition Documentation

RAPIDJSON_NAMESPACE

#define RAPIDJSON_NAMESPACE   rapidjson_simd

Definition at line 28 of file simdtest.cpp.

SIMD_SUFFIX

#define SIMD_SUFFIX

(

name

)

Value:

name

Definition at line 49 of file simdtest.cpp.

Function Documentation

TEST() [1/4]

TEST	(	SIMD	,
		SIMD_SUFFIX(ScanCopyUnescapedString)	)

Definition at line 164 of file simdtest.cpp.

                                                 {
    TestScanCopyUnescapedString<kParseDefaultFlags, StringStream>();
    TestScanCopyUnescapedString<kParseInsituFlag, InsituStringStream>();
}

Here is the call graph for this function:

TEST() [2/4]

TEST	(	SIMD	,
		SIMD_SUFFIX(ScanWriteUnescapedString)	)

Definition at line 169 of file simdtest.cpp.

                                                  {
    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++);
        }
    }
}

Here is the call graph for this function:

TEST() [3/4]

TEST	(	SIMD	,
		SIMD_SUFFIX(SkipWhitespace)	)

Definition at line 75 of file simdtest.cpp.

                                        {
    TestSkipWhitespace<StringStream>();
    TestSkipWhitespace<InsituStringStream>();
}

Here is the call graph for this function:

TEST() [4/4]

TEST	(	SIMD	,
		SIMD_SUFFIX(SkipWhitespace_EncodedMemoryStream)	)

Definition at line 80 of file simdtest.cpp.

                                                            {
    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;
        }
    }
}

Here is the call graph for this function:

TestScanCopyUnescapedString()

template<unsigned parseFlags, typename StreamType >

void TestScanCopyUnescapedString

(

)

Definition at line 111 of file simdtest.cpp.

                                   {
    char buffer[1024u + 5 + 32];
    char backup[1024u + 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]);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestSkipWhitespace()

template<typename StreamType >

void TestSkipWhitespace

(

)

Definition at line 53 of file simdtest.cpp.

                          {
    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;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: