corelib/tests/srd-text-writer.cc

#include <ebcl/SRDText.hh>
#include <ebcl/MemoryStreams.hh>
#include <cmath>
#include <cppunit/extensions/HelperMacros.h>
using namespace ebcl;


class SRDTextWriterTest : public CppUnit::TestFixture
{
	CPPUNIT_TEST_SUITE( SRDTextWriterTest );
		CPPUNIT_TEST( testEmpty );

		CPPUNIT_TEST( testList );
		CPPUNIT_TEST( testListRecursive );
		CPPUNIT_TEST( testListUnbalanced );

		CPPUNIT_TEST( testWord );
		CPPUNIT_TEST( testString );
		CPPUNIT_TEST( testStringEscapes );
		CPPUNIT_TEST( testStringUTF8Short );
		CPPUNIT_TEST( testStringUTF8Long );

		CPPUNIT_TEST( testTextWord );
		CPPUNIT_TEST( testTextString );

		CPPUNIT_TEST( testCommentLine );
		CPPUNIT_TEST( testCommentMultiLines );

		CPPUNIT_TEST( testVar );

		CPPUNIT_TEST( testInt );
		CPPUNIT_TEST( testInt32 );
		CPPUNIT_TEST( testInt64 );
		CPPUNIT_TEST( testFloat );

		CPPUNIT_TEST( testBinaryEmpty );
		CPPUNIT_TEST( testBinaryShort );
		CPPUNIT_TEST( testBinaryLong );

		CPPUNIT_TEST( testIndentation );
	CPPUNIT_TEST_SUITE_END( );

	T_Buffer< char > buffer;
	OP_MemoryOutputStream stream;
	OP_SRDTextWriter writer;
	T_String result;

	T_String getResult( );

public:
	void setUp( ) override;
	void tearDown( ) override;

	void testEmpty( );

	void testList( );
	void testListRecursive( );
	void testListUnbalanced( );

	void testWord( );
	void testString( );
	void testStringEscapes( );
	void testStringUTF8Short( );
	void testStringUTF8Long( );

	void testTextWord( );
	void testTextString( );

	void testCommentLine( );
	void testCommentMultiLines( );

	void testVar( );

	void testInt( );
	void testInt32( );
	void testInt64( );
	void testFloat( );

	void testBinaryEmpty( );
	void testBinaryShort( );
	void testBinaryLong( );

	void testIndentation( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDTextWriterTest );

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::setUp( )
{
	stream = NewOwned< T_MemoryOutputStream >( buffer );
	writer = NewOwned< T_SRDTextWriter >( *stream );
	writer->start( );
}

void SRDTextWriterTest::tearDown( )
{
	writer.clear( );
	stream.clear( );
	buffer.resize( 0 );
}

T_String SRDTextWriterTest::getResult( )
{
	if ( writer ) {
		writer->end( );
		writer.clear( );
		stream.clear( );
		if ( buffer.size( ) != 0 ) {
			return T_String( &buffer[ 0 ] , buffer.size( ) );
		}
		return T_String( );
	}
	CPPUNIT_FAIL( "error in test" );
	return T_String( );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testEmpty( )
{
	CPPUNIT_ASSERT( getResult( ) == "" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testList( )
{
	writer->startList( );
	writer->endList( );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "()\r\n" );
}

void SRDTextWriterTest::testListRecursive( )
{
	writer->startList( );
	writer->startList( );
	writer->endList( );
	writer->endList( );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "(())\r\n" );
}

void SRDTextWriterTest::testListUnbalanced( )
{
	writer->startList( );
	writer->startList( );
	writer->endList( );
	try {
		getResult( );
		CPPUNIT_FAIL( "X_SRDWriterError not thrown" );
	} catch ( X_SRDWriterError const& ) {
		// OK
	}
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testWord( )
{
	writer->putWord( T_String( "this-is-a-word" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "this-is-a-word\r\n" );
}

void SRDTextWriterTest::testString( )
{
	writer->putString( T_String( "just a string" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "\"just a string\"\r\n" );
}

void SRDTextWriterTest::testStringEscapes( )
{
	writer->putString( T_String( "\n\r\t\x08\x0c\"\\" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "\"\\n\\r\\t\\b\\f\\\"\\\\\"\r\n" );
}

void SRDTextWriterTest::testStringUTF8Short( )
{
	writer->putString( T_String( "\x01\xc3\x81\xc7\x81\xe2\x82\xac" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "\"\\u0001\\u00C1\\u01C1\\u20AC\"\r\n" );
}

void SRDTextWriterTest::testStringUTF8Long( )
{
	writer->putString( T_String( "\xf0\x91\x87\x81" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "\"\\U000111C1\"\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testTextWord( )
{
	writer->putText( T_String( "-whatever-that-is" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "-whatever-that-is\r\n" );
}

void SRDTextWriterTest::testTextString( )
{
	writer->putText( T_String( "-whatever-that-is\x01" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "\"-whatever-that-is\\u0001\"\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testCommentLine( )
{
	writer->putComment( T_String( " a comment" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "# a comment\r\n" );
}

void SRDTextWriterTest::testCommentMultiLines( )
{
	writer->putComment( T_String( " a comment\n with a few\r\n lines" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "# a comment\r\n# with a few\r\n# lines\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testVar( )
{
	writer->putVariable( T_String( "thingmabob" ) );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "$thingmabob\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testInt( )
{
	writer->putInteger( 123 );
	writer->putInteger( 12345678000 );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "123 12345678000\r\n" );
}

void SRDTextWriterTest::testInt32( )
{
	writer->putInt32( 123 );
	writer->putInt32( -123 );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "123 -123\r\n" );
}

void SRDTextWriterTest::testInt64( )
{
	writer->putInt64( 12345678000 );
	writer->putInt64( -12345678000 );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "12345678000 -12345678000\r\n" );
}

void SRDTextWriterTest::testFloat( )
{
	writer->putFloat( 1.5 );
	writer->putFloat( M_PI );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "1.5 3.141592653589793115997963\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testBinaryEmpty( )
{
	T_Buffer< uint8_t > buf( 0 );
	writer->putBinary( buf );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "[]\r\n" );
}

void SRDTextWriterTest::testBinaryShort( )
{
	T_Buffer< uint8_t > buf( 8 );
	for ( auto i = 0u ; i < 8 ; i ++ ) {
		buf[ i ] = i << 3;
	}
	writer->putBinary( buf );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result == "[ 00 08 10 18 20 28 30 38 ]\r\n" );
}

void SRDTextWriterTest::testBinaryLong( )
{
	T_Buffer< uint8_t > buf( 18 );
	for ( auto i = 0u ; i < 18 ; i ++ ) {
		buf[ i ] = i;
	}
	writer->putBinary( buf );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result ==
			"[\r\n"
			"  00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\r\n"
			"  10 11\r\n"
			"]\r\n" );
}

/*----------------------------------------------------------------------------*/

void SRDTextWriterTest::testIndentation( )
{
	writer->startList( )
		.putText( T_String( "this" ) )
		.putText( T_String( "is" ) )
		.startList( )
			.putText( T_String( "just" ) )
			.putText( T_String( "a" ) )
		.endList( )
		.putComment( T_String( " very, very, very...\n BAD!" ) )
		.putText( T_String( "test" ) )
		.putComment( T_String( " and then some." ) )
		.putComment( T_String( " Twice, even." ) )
	.endList( );
	const T_String result( getResult( ) );
	CPPUNIT_ASSERT( result ==
			"(this is\r\n"
			"  (just a) # very, very, very...\r\n"
			"  # BAD!\r\n"
			"  test # and then some.\r\n"
			"  # Twice, even.\r\n"
			"  )\r\n" );
}