EncodedStreamTest Class Reference

Inheritance diagram for EncodedStreamTest:

Collaboration diagram for EncodedStreamTest:

Public Member Functions
	EncodedStreamTest ()
virtual	~EncodedStreamTest ()
virtual void	SetUp ()
virtual void	TearDown ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()

Protected Member Functions
template<typename FileEncoding, typename MemoryEncoding>
void	TestEncodedInputStream (const char *filename)
void	TestAutoUTFInputStream (const char *filename, bool expectHasBOM)
template<typename FileEncoding, typename MemoryEncoding>
void	TestEncodedOutputStream (const char *expectedFilename, bool putBOM)
void	TestAutoUTFOutputStream (UTFType type, bool putBOM, const char *expectedFilename)
bool	CompareFile (const char *filename, const char *expectedFilename)
bool	CompareBufferFile (const char *actualBuffer, size_t actualLength, const char *expectedFilename)
Protected Member Functions inherited from testing::Test
	Test ()
	Test ()

Static Protected Member Functions
static FILE *	Open (const char *filename)
static char *	ReadFile (const char *filename, bool appendPath, size_t *outLength)

Protected Attributes
char *	json_
size_t	length_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)

Detailed Description

Definition at line 25 of file encodedstreamtest.cpp.

Constructor & Destructor Documentation

EncodedStreamTest()

EncodedStreamTest::EncodedStreamTest ( )

inline

Definition at line 27 of file encodedstreamtest.cpp.

: json_(), length_() {}

~EncodedStreamTest()

EncodedStreamTest::~EncodedStreamTest ( )

virtual

Definition at line 252 of file encodedstreamtest.cpp.

{}

Member Function Documentation

CompareBufferFile()

bool EncodedStreamTest::CompareBufferFile ( const char * actualBuffer, size_t actualLength, const char * expectedFilename )

inlineprotected

Definition at line 240 of file encodedstreamtest.cpp.

                                                                                                        {
        size_t expectedLength;
        char* expectedBuffer = ReadFile(expectedFilename, true, &expectedLength);
        bool ret = (expectedLength == actualLength) && memcmp(expectedBuffer, actualBuffer, actualLength) == 0;
        free(expectedBuffer);
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

CompareFile()

bool EncodedStreamTest::CompareFile ( const char * filename, const char * expectedFilename )

inlineprotected

Definition at line 230 of file encodedstreamtest.cpp.

                                                                         {
        size_t actualLength, expectedLength;
        char* actualBuffer = ReadFile(filename, false, &actualLength);
        char* expectedBuffer = ReadFile(expectedFilename, true, &expectedLength);
        bool ret = (expectedLength == actualLength) && memcmp(expectedBuffer, actualBuffer, actualLength) == 0;
        free(actualBuffer);
        free(expectedBuffer);
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Open()

FILE * EncodedStreamTest::Open ( const char * filename )

inlinestaticprotected

Definition at line 44 of file encodedstreamtest.cpp.

                                            {
        const char *paths[] = {
            "encodings",
            "bin/encodings",
            "../bin/encodings",
            "../../bin/encodings",
            "../../../bin/encodings"
        };
        char buffer[1024];
        for (size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); i++) {
            sprintf(buffer, "%s/%s", paths[i], filename);
            FILE *fp = fopen(buffer, "rb");
            if (fp)
                return fp;
        }
        return 0;
    }

Here is the caller graph for this function:

ReadFile()

char * EncodedStreamTest::ReadFile ( const char * filename, bool appendPath, size_t * outLength )

inlinestaticprotected

Definition at line 62 of file encodedstreamtest.cpp.

                                                                                    {
        FILE *fp = appendPath ? Open(filename) : fopen(filename, "rb");
 
        if (!fp) {
            *outLength = 0;
            return 0;
        }
 
        fseek(fp, 0, SEEK_END);
        *outLength = static_cast<size_t>(ftell(fp));
        fseek(fp, 0, SEEK_SET);
        char* buffer = static_cast<char*>(malloc(*outLength + 1));
        size_t readLength = fread(buffer, 1, *outLength, fp);
        buffer[readLength] = '\0';
        fclose(fp);
        return buffer;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

SetUp()

virtual void EncodedStreamTest::SetUp ( )

inlinevirtual

Reimplemented from testing::Test.

Definition at line 30 of file encodedstreamtest.cpp.

                         {
        json_ = ReadFile("utf8.json", true, &length_);
    }

Here is the call graph for this function:

TearDown()

virtual void EncodedStreamTest::TearDown ( )

inlinevirtual

Reimplemented from testing::Test.

Definition at line 34 of file encodedstreamtest.cpp.

                            {
        free(json_);
        json_ = 0;
    }

TestAutoUTFInputStream()

void EncodedStreamTest::TestAutoUTFInputStream ( const char * filename, bool expectHasBOM )

inlineprotected

Definition at line 121 of file encodedstreamtest.cpp.

                                                                         {
        // Test FileReadStream
        {
            char buffer[16];
            FILE *fp = Open(filename);
            ASSERT_TRUE(fp != 0);
            FileReadStream fs(fp, buffer, sizeof(buffer));
            AutoUTFInputStream<unsigned, FileReadStream> eis(fs);
            EXPECT_EQ(expectHasBOM, eis.HasBOM());
            StringStream s(json_);
            while (eis.Peek() != '\0') {
                unsigned expected, actual;
                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
                EXPECT_TRUE(AutoUTF<unsigned>::Decode(eis, &actual));
                EXPECT_EQ(expected, actual);
            }
            EXPECT_EQ('\0', s.Peek());
            fclose(fp);
        }
 
        // Test MemoryStream
        {
            size_t size;
            char* data = ReadFile(filename, true, &size);
            MemoryStream ms(data, size);
            AutoUTFInputStream<unsigned, MemoryStream> eis(ms);
            EXPECT_EQ(expectHasBOM, eis.HasBOM());
            StringStream s(json_);
 
            while (eis.Peek() != '\0') {
                unsigned expected, actual;
                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
                EXPECT_TRUE(AutoUTF<unsigned>::Decode(eis, &actual));
                EXPECT_EQ(expected, actual);
            }
            EXPECT_EQ('\0', s.Peek());
            free(data);
            EXPECT_EQ(size, eis.Tell());
        }
    }

Here is the call graph for this function:

TestAutoUTFOutputStream()

void EncodedStreamTest::TestAutoUTFOutputStream ( UTFType type, bool putBOM, const char * expectedFilename )

inlineprotected

Definition at line 196 of file encodedstreamtest.cpp.

                                                                                          {
        // Test FileWriteStream
        {
            char filename[L_tmpnam];
            FILE* fp = TempFile(filename);
 
            char buffer[16];
            FileWriteStream os(fp, buffer, sizeof(buffer));
            AutoUTFOutputStream<unsigned, FileWriteStream> eos(os, type, putBOM);
            StringStream s(json_);
            while (s.Peek() != '\0') {
                bool success = Transcoder<UTF8<>, AutoUTF<unsigned> >::Transcode(s, eos);
                EXPECT_TRUE(success);
            }
            eos.Flush();
            fclose(fp);
            EXPECT_TRUE(CompareFile(filename, expectedFilename));
            remove(filename);
        }
 
        // Test MemoryBuffer
        {
            MemoryBuffer mb;
            AutoUTFOutputStream<unsigned, MemoryBuffer> eos(mb, type, putBOM);
            StringStream s(json_);
            while (s.Peek() != '\0') {
                bool success = Transcoder<UTF8<>, AutoUTF<unsigned> >::Transcode(s, eos);
                EXPECT_TRUE(success);
            }
            eos.Flush();
            EXPECT_TRUE(CompareBufferFile(mb.GetBuffer(), mb.GetSize(), expectedFilename));
        }
    }

Here is the call graph for this function:

TestEncodedInputStream()

template<typename FileEncoding, typename MemoryEncoding>

void EncodedStreamTest::TestEncodedInputStream ( const char * filename )

inlineprotected

Definition at line 81 of file encodedstreamtest.cpp.

                                                      {
        // Test FileReadStream
        {
            char buffer[16];
            FILE *fp = Open(filename);
            ASSERT_TRUE(fp != 0);
            FileReadStream fs(fp, buffer, sizeof(buffer));
            EncodedInputStream<FileEncoding, FileReadStream> eis(fs);
            StringStream s(json_);
 
            while (eis.Peek() != '\0') {
                unsigned expected, actual;
                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
                EXPECT_TRUE(MemoryEncoding::Decode(eis, &actual));
                EXPECT_EQ(expected, actual);
            }
            EXPECT_EQ('\0', s.Peek());
            fclose(fp);
        }
 
        // Test MemoryStream
        {
            size_t size;
            char* data = ReadFile(filename, true, &size);
            MemoryStream ms(data, size);
            EncodedInputStream<FileEncoding, MemoryStream> eis(ms);
            StringStream s(json_);
 
            while (eis.Peek() != '\0') {
                unsigned expected, actual;
                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
                EXPECT_TRUE(MemoryEncoding::Decode(eis, &actual));
                EXPECT_EQ(expected, actual);
            }
            EXPECT_EQ('\0', s.Peek());
            free(data);
            EXPECT_EQ(size, eis.Tell());
        }
    }

Here is the call graph for this function:

TestEncodedOutputStream()

template<typename FileEncoding, typename MemoryEncoding>

void EncodedStreamTest::TestEncodedOutputStream ( const char * expectedFilename, bool putBOM )

inlineprotected

Definition at line 163 of file encodedstreamtest.cpp.

                                                                            {
        // Test FileWriteStream
        {
            char filename[L_tmpnam];
            FILE* fp = TempFile(filename);
            char buffer[16];
            FileWriteStream os(fp, buffer, sizeof(buffer));
            EncodedOutputStream<FileEncoding, FileWriteStream> eos(os, putBOM);
            StringStream s(json_);
            while (s.Peek() != '\0') {
                bool success = Transcoder<UTF8<>, MemoryEncoding>::Transcode(s, eos);
                EXPECT_TRUE(success);
            }
            eos.Flush();
            fclose(fp);
            EXPECT_TRUE(CompareFile(filename, expectedFilename));
            remove(filename);
        }
 
        // Test MemoryBuffer
        {
            MemoryBuffer mb;
            EncodedOutputStream<FileEncoding, MemoryBuffer> eos(mb, putBOM);
            StringStream s(json_);
            while (s.Peek() != '\0') {
                bool success = Transcoder<UTF8<>, MemoryEncoding>::Transcode(s, eos);
                EXPECT_TRUE(success);
            }
            eos.Flush();
            EXPECT_TRUE(CompareBufferFile(mb.GetBuffer(), mb.GetSize(), expectedFilename));
        }
    }

Here is the call graph for this function:

Member Data Documentation

json_

char* EncodedStreamTest::json_

protected

Definition at line 248 of file encodedstreamtest.cpp.

length_

size_t EncodedStreamTest::length_

protected

Definition at line 249 of file encodedstreamtest.cpp.

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/external/rapidjson/test/unittest/encodedstreamtest.cpp