activemq-cpp/src/test/activemq/util/MarshallingSupportTest.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 "MarshallingSupportTest.h"

#include <activemq/util/MarshallingSupport.h>
#include <activemq/util/PrimitiveValueNode.h>

#include <decaf/io/ByteArrayInputStream.h>
#include <decaf/io/ByteArrayOutputStream.h>
#include <decaf/io/DataInputStream.h>
#include <decaf/io/DataOutputStream.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Short.h>

using namespace std;
using namespace decaf;
using namespace decaf::io;
using namespace decaf::lang;
using namespace activemq;
using namespace activemq::util;

////////////////////////////////////////////////////////////////////////////////
MarshallingSupportTest::MarshallingSupportTest() {
}

////////////////////////////////////////////////////////////////////////////////
MarshallingSupportTest::~MarshallingSupportTest() {
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::writeTestHelper( unsigned char* input, int inputLength,
                                              unsigned char* expect, int expectLength ) {

    std::string testStr( (char*)input, inputLength );
    std::string result = MarshallingSupport::asciiToModifiedUtf8( testStr );

    for( int i = 0; i < expectLength; ++i ) {
        CPPUNIT_ASSERT( (unsigned char)result[i] == expect[i] );
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testAsciiToModifiedUtf8() {

    // Test data with 1-byte UTF8 encoding.
    {
        unsigned char input[] = {0x00, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64};
        unsigned char expect[] = {0xC0, 0x80, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64};

        writeTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                         expect, (int) sizeof(expect) / (int) sizeof(unsigned char) );
    }

    // Test data with 2-byte UT8 encoding.
    {
        unsigned char input[] = {0x00, 0xC2, 0xA9, 0xC3, 0xA6 };
        unsigned char expect[] = {0xC0, 0x80, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC2, 0xA6 };
        writeTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                         expect, (int) sizeof(expect) / (int) sizeof(unsigned char)  );
    }

    // Test data with 1-byte and 2-byte encoding with embedded NULL's.
    {
        unsigned char input[] = {0x00, 0x04, 0xC2, 0xA9, 0xC3, 0x00, 0xA6 };
        unsigned char expect[] = {0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };

        writeTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                         expect, (int) sizeof(expect) / (int) sizeof(unsigned char) );
    }

}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::readTestHelper( unsigned char* input, int inputLength,
                                             unsigned char* expect, int expectLength ) {

    std::string inputString( (char*)input, inputLength );
    std::string result = MarshallingSupport::modifiedUtf8ToAscii( inputString );

    for( std::size_t i = 0; i < result.length(); ++i ) {
        CPPUNIT_ASSERT( (unsigned char)result[i] == expect[i] );
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testModifiedUtf8ToAscii() {

    // Test data with 1-byte UTF8 encoding.
    {
        unsigned char expect[] = { 0x00, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 };
        unsigned char input[] = { 0xC0, 0x80, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 };

        readTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                        expect, (int) sizeof(expect)/ (int) sizeof(unsigned char) );
    }

    // Test data with 2-byte UT8 encoding.
    {
        unsigned char expect[] = { 0x00, 0xC2, 0xA9, 0xC3, 0xA6 };
        unsigned char input[] = { 0xC0, 0x80, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC2, 0xA6 };
        readTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                        expect, (int) sizeof(expect) / (int) sizeof(unsigned char)  );
    }

    // Test data with 1-byte and 2-byte encoding with embedded NULL's.
    {
        unsigned char expect[] = { 0x00, 0x04, 0xC2, 0xA9, 0xC3, 0x00, 0xA6 };
        unsigned char input[] = { 0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };

        readTestHelper( input, (int) sizeof(input) / (int) sizeof(unsigned char),
                        expect, (int) sizeof(expect) / (int) sizeof(unsigned char) );
    }

    // Test with bad UTF-8 encoding, missing 2nd byte of two byte value
    {
        unsigned char input[] = { 0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xC2, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };
        std::string inputString( (char*)input, (int) sizeof(input) / (int) sizeof(unsigned char) );

        CPPUNIT_ASSERT_THROW_MESSAGE(
            "Should throw a UTFDataFormatException",
            MarshallingSupport::modifiedUtf8ToAscii( inputString ),
            UTFDataFormatException );
    }

    // Test with bad UTF-8 encoding, encoded value greater than 255
    {
        unsigned char input[] = { 0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xC2, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };
        std::string inputString( (char*)input, (int) sizeof(input) / (int) sizeof(unsigned char) );

        CPPUNIT_ASSERT_THROW_MESSAGE(
            "Should throw a UTFDataFormatException",
            MarshallingSupport::modifiedUtf8ToAscii( inputString ),
            UTFDataFormatException );
    }

    // Test data with value greater than 255 in 2-byte encoding.
    {
        unsigned char input[] = { 0xC8, 0xA9, 0xC3, 0xA6};
        std::string inputString( (char*)input, (int) sizeof(input) / (int) sizeof(unsigned char) );

        CPPUNIT_ASSERT_THROW_MESSAGE(
            "Should throw a UTFDataFormatException",
            MarshallingSupport::modifiedUtf8ToAscii( inputString ),
            UTFDataFormatException );
    }

    // Test data with value greater than 255 in 3-byte encoding.
    {
        unsigned char input[] = { 0xE8, 0xA8, 0xA9, 0xC3, 0xA6};
        std::string inputString( (char*)input, (int) sizeof(input) / (int) sizeof(unsigned char) );

        CPPUNIT_ASSERT_THROW_MESSAGE(
            "Should throw a UTFDataFormatException",
            MarshallingSupport::modifiedUtf8ToAscii( inputString ),
            UTFDataFormatException );
    }

    // Test with three byte encode that's missing a last byte.
    {
        unsigned char input[] = { 0x00, 0x00, 0x00, 0x02, 0xE8, 0xA8};
        std::string inputString( (char*)input, (int) sizeof(input) / (int) sizeof(unsigned char) );

        CPPUNIT_ASSERT_THROW_MESSAGE(
            "Should throw a UTFDataFormatException",
            MarshallingSupport::modifiedUtf8ToAscii( inputString ),
            UTFDataFormatException );
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testWriteString() {

    {
        ByteArrayOutputStream baos;
        ByteArrayInputStream bais;
        DataOutputStream writer( &baos );
        DataInputStream dataIn( &bais );

        MarshallingSupport::writeString( writer, "" );

        std::pair<const unsigned char*, int> array = baos.toByteArray();
        bais.setByteArray( array.first, array.second );

        CPPUNIT_ASSERT( dataIn.read() == PrimitiveValueNode::STRING_TYPE );
        CPPUNIT_ASSERT( dataIn.readShort() == 0 );

        delete [] array.first;
    }
    {
        ByteArrayOutputStream baos;
        ByteArrayInputStream bais;
        DataOutputStream writer( &baos );
        DataInputStream dataIn( &bais );

        MarshallingSupport::writeString( writer, "Hello World" );

        std::pair<const unsigned char*, int> array = baos.toByteArray();
        bais.setByteArray( array.first, array.second );

        CPPUNIT_ASSERT( dataIn.read() == PrimitiveValueNode::STRING_TYPE );
        CPPUNIT_ASSERT( dataIn.readShort() == 11 );

        delete [] array.first;
    }
    {
        ByteArrayOutputStream baos;
        ByteArrayInputStream bais;
        DataOutputStream writer( &baos );
        DataInputStream dataIn( &bais );

        MarshallingSupport::writeString( writer, std::string( Short::MAX_VALUE, 'A' ) );

        std::pair<const unsigned char*, int> array = baos.toByteArray();
        bais.setByteArray( array.first, array.second );

        CPPUNIT_ASSERT( dataIn.read() == PrimitiveValueNode::BIG_STRING_TYPE );
        CPPUNIT_ASSERT( dataIn.readInt() == Short::MAX_VALUE );

        delete [] array.first;
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testWriteString16() {

    {
        ByteArrayOutputStream baos;
        ByteArrayInputStream bais;
        DataOutputStream writer( &baos );
        DataInputStream dataIn( &bais );

        MarshallingSupport::writeString16( writer, "Hello World" );

        std::pair<const unsigned char*, int> array = baos.toByteArray();
        bais.setByteArray( array.first, array.second );

        CPPUNIT_ASSERT( dataIn.readShort() == 11 );

        delete [] array.first;
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testWriteString32() {

    {
        ByteArrayOutputStream baos;
        ByteArrayInputStream bais;
        DataOutputStream writer( &baos );
        DataInputStream dataIn( &bais );

        MarshallingSupport::writeString32( writer, "Hello World" );

        std::pair<const unsigned char*, int> array = baos.toByteArray();
        bais.setByteArray( array.first, array.second );

        CPPUNIT_ASSERT( dataIn.readInt() == 11 );

        delete [] array.first;
    }
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testReadString16() {

    ByteArrayInputStream bytesIn;
    ByteArrayOutputStream bytesOut;

    DataInputStream dataIn( &bytesIn );
    DataOutputStream dataOut( &bytesOut );

    string testStr = "This is a test string for Openwire";

    MarshallingSupport::writeString( dataOut, testStr );

    // Move the output back to the input.
    std::pair<const unsigned char*, int> array = bytesOut.toByteArray();
    bytesIn.setByteArray( array.first, array.second );

    string resultStr = "";
    int type = dataIn.read();

    CPPUNIT_ASSERT( type == PrimitiveValueNode::STRING_TYPE );

    CPPUNIT_ASSERT_NO_THROW_MESSAGE(
        "Should not have thrown a message for valid String type",
        resultStr = MarshallingSupport::readString16( dataIn ) );

    CPPUNIT_ASSERT( testStr == resultStr );

    delete [] array.first;
}

////////////////////////////////////////////////////////////////////////////////
void MarshallingSupportTest::testReadString32() {

    ByteArrayInputStream bytesIn;
    ByteArrayOutputStream bytesOut;

    DataInputStream dataIn( &bytesIn );
    DataOutputStream dataOut( &bytesOut );

    string testStr( (std::size_t)Short::MAX_VALUE, 'a' );

    MarshallingSupport::writeString( dataOut, testStr );

    // Move the output back to the input.
    std::pair<const unsigned char*, int> array = bytesOut.toByteArray();
    bytesIn.setByteArray( array.first, array.second );

    string resultStr = "";
    int type = dataIn.read();

    CPPUNIT_ASSERT( type == PrimitiveValueNode::BIG_STRING_TYPE );

    CPPUNIT_ASSERT_NO_THROW_MESSAGE(
        "Should not have thrown a message for valid Big String type",
        resultStr = MarshallingSupport::readString32( dataIn ) );

    CPPUNIT_ASSERT( testStr == resultStr );

    delete [] array.first;
}