tseeker-pub/corelib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Finished importing the good bits from LW's library

Browse source
This commit is contained in:
Emmanuel BENOîT 2017-11-01 23:21:01 +01:00
parent b9d77922ed
commit 4ab3dc1b29
82 changed files with 177 additions and 24084 deletions

6
tests/alloc-pool.cc
View file

@ -1,7 +1,7 @@
#include <lw/lib/Alloc.hh>
#include <lw/lib/Pointers.hh>
#include <ebcl/Alloc.hh>
#include <ebcl/Pointers.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class AllocPoolTest : public CppUnit::TestFixture

468
tests/console-edit.cc
View file

@ -1,468 +0,0 @@
#include <lw/lib/Console.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
class ConsoleEditTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( ConsoleEditTest );
CPPUNIT_TEST( testEmpty );
CPPUNIT_TEST( testSetContents );
CPPUNIT_TEST( testReset );
CPPUNIT_TEST( testCursorStart );
CPPUNIT_TEST( testCursorStartEmpty );
CPPUNIT_TEST( testCursorEnd );
CPPUNIT_TEST( testCursorEndEmpty );
CPPUNIT_TEST( testCursorLeft );
CPPUNIT_TEST( testCursorLeftStart );
CPPUNIT_TEST( testCursorRight );
CPPUNIT_TEST( testCursorRightEnd );
CPPUNIT_TEST( testAppendCharacter );
CPPUNIT_TEST( testInsertCharacter );
CPPUNIT_TEST( testAppendBuffer );
CPPUNIT_TEST( testInsertBuffer );
CPPUNIT_TEST( testPrevWordStart );
CPPUNIT_TEST( testPrevWordInWord );
CPPUNIT_TEST( testPrevWordSpaces );
CPPUNIT_TEST( testNextWordEnd );
CPPUNIT_TEST( testNextWordInWord );
CPPUNIT_TEST( testNextWordSpaces );
CPPUNIT_TEST( testRmCharAtEnd );
CPPUNIT_TEST( testRmCharLast );
CPPUNIT_TEST( testRmCharMiddle );
CPPUNIT_TEST( testRmWordAtEnd );
CPPUNIT_TEST( testRmWordMiddle );
CPPUNIT_TEST( testRmWordAtStart );
CPPUNIT_TEST( testRmRestAtStart );
CPPUNIT_TEST( testRmRestMiddle );
CPPUNIT_TEST( testRmRestAtEnd );
CPPUNIT_TEST_SUITE_END( );
public:
void testEmpty( );
void testSetContents( );
void testReset( );
void testCursorStart( );
void testCursorStartEmpty( );
void testCursorEnd( );
void testCursorEndEmpty( );
void testCursorLeft( );
void testCursorLeftStart( );
void testCursorRight( );
void testCursorRightEnd( );
void testAppendCharacter( );
void testInsertCharacter( );
void testAppendBuffer( );
void testInsertBuffer( );
void testPrevWordStart( );
void testPrevWordInWord( );
void testPrevWordSpaces( );
void testNextWordEnd( );
void testNextWordInWord( );
void testNextWordSpaces( );
void testRmCharAtEnd( );
void testRmCharLast( );
void testRmCharMiddle( );
void testRmWordAtEnd( );
void testRmWordMiddle( );
void testRmWordAtStart( );
void testRmRestAtStart( );
void testRmRestMiddle( );
void testRmRestAtEnd( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( ConsoleEditTest );
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testEmpty( )
{
T_ConsoleLineState s;
CPPUNIT_ASSERT( s.getContents( ) == "" );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
void ConsoleEditTest::testSetContents( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 1 );
CPPUNIT_ASSERT( s.getContents( ) == str );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 1u , s.historyIndex( ) );
}
void ConsoleEditTest::testReset( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 1 );
s.reset( );
CPPUNIT_ASSERT( s.getContents( ) == "" );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testCursorStart( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
void ConsoleEditTest::testCursorStartEmpty( )
{
T_ConsoleLineState s;
s.toStart( );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
void ConsoleEditTest::testCursorEnd( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.toEnd( );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
}
void ConsoleEditTest::testCursorEndEmpty( )
{
T_ConsoleLineState s;
s.toEnd( );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
void ConsoleEditTest::testCursorLeft( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.left( );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 3u , s.pos( ) );
}
void ConsoleEditTest::testCursorLeftStart( )
{
T_ConsoleLineState s;
s.left( );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
void ConsoleEditTest::testCursorRight( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.right( );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 1u , s.pos( ) );
}
void ConsoleEditTest::testCursorRightEnd( )
{
T_ConsoleLineState s;
s.right( );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testAppendCharacter( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.insert( 't' );
s.insert( 0x20ac );
s.insert( 's' );
s.insert( 't' );
CPPUNIT_ASSERT( s.getContents( ) == str );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
void ConsoleEditTest::testInsertCharacter( )
{
const T_String str( "t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.insert( 0x20ac );
s.insert( 's' );
s.insert( 't' );
s.toStart( );
s.insert( 't' );
CPPUNIT_ASSERT( s.getContents( ) == str );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 1u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
void ConsoleEditTest::testAppendBuffer( )
{
const T_String str( "t\xe2\x82\xacst" );
T_Buffer< uint32_t > b( 4 );
b[ 0 ] = b[ 3 ] = 't';
b[ 1 ] = 0x20ac;
b[ 2 ] = 's';
T_ConsoleLineState s;
s.insert( b , 4 );
CPPUNIT_ASSERT( s.getContents( ) == str );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
void ConsoleEditTest::testInsertBuffer( )
{
const T_String str( "t\xe2\x82\xacst" );
T_Buffer< uint32_t > b( 3 );
b[ 0 ] = 't';
b[ 1 ] = 0x20ac;
b[ 2 ] = 's';
T_ConsoleLineState s;
s.insert( 't' );
s.toStart( );
s.insert( b , 3 );
CPPUNIT_ASSERT( s.getContents( ) == str );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 3u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.historyIndex( ) );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testPrevWordStart( )
{
const T_String str( "t\xe2\x82\xacst " );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.prevWord( );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
}
void ConsoleEditTest::testPrevWordInWord( )
{
const T_String str( " t\xe2\x82\xacst" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.prevWord( );
CPPUNIT_ASSERT_EQUAL( 1u , s.pos( ) );
}
void ConsoleEditTest::testPrevWordSpaces( )
{
const T_String str( " t\xe2\x82\xacst " );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.prevWord( );
CPPUNIT_ASSERT_EQUAL( 1u , s.pos( ) );
}
void ConsoleEditTest::testNextWordEnd( )
{
const T_String str( "t\xe2\x82\xacst " );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.nextWord( );
CPPUNIT_ASSERT_EQUAL( s.size( ) , s.pos( ) );
}
void ConsoleEditTest::testNextWordInWord( )
{
const T_String str( "t\xe2\x82\xacst " );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.nextWord( );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
}
void ConsoleEditTest::testNextWordSpaces( )
{
const T_String str( " t\xe2\x82\xacst " );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.nextWord( );
CPPUNIT_ASSERT_EQUAL( 6u , s.pos( ) );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testRmCharAtEnd( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.removeCharacter( );
CPPUNIT_ASSERT( s.getContents( ) == "test" );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
}
void ConsoleEditTest::testRmCharLast( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.left( );
s.removeCharacter( );
CPPUNIT_ASSERT( s.getContents( ) == "tes" );
CPPUNIT_ASSERT_EQUAL( 3u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 3u , s.size( ) );
}
void ConsoleEditTest::testRmCharMiddle( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
s.removeCharacter( );
CPPUNIT_ASSERT( s.getContents( ) == "est" );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 3u , s.size( ) );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testRmWordAtEnd( )
{
const T_String str( "test blah" );
T_ConsoleLineState s;
s.setContents( str , 0 );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeWord( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "test " );
CPPUNIT_ASSERT_EQUAL( 5u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 5u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , cpl );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'b' ) , cpb[ 0 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'l' ) , cpb[ 1 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'a' ) , cpb[ 2 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'h' ) , cpb[ 3 ] );
}
void ConsoleEditTest::testRmWordMiddle( )
{
const T_String str( "test blah" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.left( );
s.left( );
s.left( );
s.left( );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeWord( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "blah" );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 5u , cpl );
CPPUNIT_ASSERT_EQUAL( uint32_t( 't' ) , cpb[ 0 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'e' ) , cpb[ 1 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 's' ) , cpb[ 2 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 't' ) , cpb[ 3 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( ' ' ) , cpb[ 4 ] );
}
void ConsoleEditTest::testRmWordAtStart( )
{
const T_String str( "test blah" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeWord( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "test blah" );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 9u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 572u , cpl );
}
/*----------------------------------------------------------------------------*/
void ConsoleEditTest::testRmRestAtStart( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.toStart( );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeRestOfLine( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "" );
CPPUNIT_ASSERT_EQUAL( 0u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 0u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 4u , cpl );
CPPUNIT_ASSERT_EQUAL( uint32_t( 't' ) , cpb[ 0 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 'e' ) , cpb[ 1 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 's' ) , cpb[ 2 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 't' ) , cpb[ 3 ] );
}
void ConsoleEditTest::testRmRestMiddle( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
s.left( );
s.left( );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeRestOfLine( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "te" );
CPPUNIT_ASSERT_EQUAL( 2u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 2u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 2u , cpl );
CPPUNIT_ASSERT_EQUAL( uint32_t( 's' ) , cpb[ 0 ] );
CPPUNIT_ASSERT_EQUAL( uint32_t( 't' ) , cpb[ 1 ] );
}
void ConsoleEditTest::testRmRestAtEnd( )
{
const T_String str( "test" );
T_ConsoleLineState s;
s.setContents( str , 0 );
T_Buffer< uint32_t > cpb;
uint32_t cpl( 572 );
s.removeRestOfLine( cpb , cpl );
CPPUNIT_ASSERT( s.getContents( ) == "test" );
CPPUNIT_ASSERT_EQUAL( 4u , s.pos( ) );
CPPUNIT_ASSERT_EQUAL( 4u , s.size( ) );
CPPUNIT_ASSERT_EQUAL( 572u , cpl );
}

405
tests/console-text.cc
View file

@ -1,405 +0,0 @@
#include <lw/lib/Console.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
class ConsoleTextTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( ConsoleTextTest );
CPPUNIT_TEST( testEmpty );
CPPUNIT_TEST( testSimpleString );
CPPUNIT_TEST( testChangeStyle );
CPPUNIT_TEST( testChangeStyleTwice );
CPPUNIT_TEST( testChangeStyleAtEnd );
CPPUNIT_TEST( testChangeColor );
CPPUNIT_TEST( testChangeColorTwice );
CPPUNIT_TEST( testChangeColorAtEnd );
CPPUNIT_TEST( testChangeColorAndStyle );
CPPUNIT_TEST( testTextCopyCons );
CPPUNIT_TEST( testTextCopyAss );
CPPUNIT_TEST( testTextMoveCons );
CPPUNIT_TEST( testTextMoveAss );
CPPUNIT_TEST( testTextSwap );
CPPUNIT_TEST( testBuilderCopyCons );
CPPUNIT_TEST( testBuilderCopyAss );
CPPUNIT_TEST( testBuilderMoveCons );
CPPUNIT_TEST( testBuilderMoveAss );
CPPUNIT_TEST( testBuilderSwap );
CPPUNIT_TEST_SUITE_END( );
public:
void testEmpty( );
void testSimpleString( );
void testChangeStyle( );
void testChangeStyleTwice( );
void testChangeStyleAtEnd( );
void testChangeColor( );
void testChangeColorTwice( );
void testChangeColorAtEnd( );
void testChangeColorAndStyle( );
void testTextCopyCons( );
void testTextCopyAss( );
void testTextMoveCons( );
void testTextMoveAss( );
void testTextSwap( );
void testBuilderCopyCons( );
void testBuilderCopyAss( );
void testBuilderMoveCons( );
void testBuilderMoveAss( );
void testBuilderSwap( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( ConsoleTextTest );
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testEmpty( )
{
T_TextBuilder tb;
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "" );
}
void ConsoleTextTest::testSimpleString( )
{
T_TextBuilder tb;
tb << "test";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
}
}
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testChangeStyle( )
{
T_TextBuilder tb;
tb << "te";
tb.addStyle( E_TextStyle::BOLD );
tb << "st";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
if ( i < 2 ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
} else {
CPPUNIT_ASSERT_EQUAL( uint8_t( E_TextStyle::BOLD ) , t.styleAt( i ) );
}
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
}
}
void ConsoleTextTest::testChangeStyleTwice( )
{
T_TextBuilder tb;
tb << "te";
tb.addStyle( E_TextStyle::BOLD );
tb.addStyle( E_TextStyle::ITALIC );
tb << "st";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
if ( i < 2 ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
} else {
CPPUNIT_ASSERT_EQUAL(
uint8_t( uint8_t( E_TextStyle::BOLD ) | uint8_t( E_TextStyle::ITALIC ) ) ,
t.styleAt( i ) );
}
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
}
}
void ConsoleTextTest::testChangeStyleAtEnd( )
{
T_TextBuilder tb;
tb << "test";
tb.addStyle( E_TextStyle::BOLD );
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
}
}
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testChangeColor( )
{
T_TextBuilder tb;
tb << "te";
tb.setColor( E_TextColor::RED );
tb << "st";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
if ( i < 2 ) {
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
} else {
CPPUNIT_ASSERT( E_TextColor::RED == t.colorAt( i ).type );
}
}
}
void ConsoleTextTest::testChangeColorTwice( )
{
T_TextBuilder tb;
tb << "te";
tb.setColor( E_TextColor::RED );
tb.setColor( E_TextColor::GREEN );
tb << "st";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
if ( i < 2 ) {
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
} else {
CPPUNIT_ASSERT( E_TextColor::GREEN == t.colorAt( i ).type );
}
}
}
void ConsoleTextTest::testChangeColorAtEnd( )
{
T_TextBuilder tb;
tb << "test";
tb.setColor( E_TextColor::GREEN );
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
}
}
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testChangeColorAndStyle( )
{
T_TextBuilder tb;
tb.addStyle( E_TextStyle::BOLD );
tb << "te";
tb.removeStyle( E_TextStyle::BOLD );
tb.setColor( E_TextColor::GREEN );
tb << "st";
T_Text t( tb );
CPPUNIT_ASSERT( t.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
if ( i < 2 ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( E_TextStyle::BOLD ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
} else {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::GREEN == t.colorAt( i ).type );
}
}
}
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testTextCopyCons( )
{
T_TextBuilder tb;
tb << "test";
T_Text t( tb );
T_Text t2( t );
CPPUNIT_ASSERT( t.string( ) == "test" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testTextCopyAss( )
{
T_TextBuilder tb;
tb << "test";
T_Text t( tb );
tb.clear( );
tb << "blargh";
T_Text t2( tb );
t2 = t;
CPPUNIT_ASSERT( t.string( ) == "test" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testTextMoveCons( )
{
T_TextBuilder tb;
tb << "test";
T_Text t( tb );
T_Text t2( std::move( t ) );
CPPUNIT_ASSERT( t.string( ) == "" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testTextMoveAss( )
{
T_TextBuilder tb;
tb << "te";
T_Text t2( tb );
tb << "st";
T_Text t( tb );
t2 = std::move( t );
CPPUNIT_ASSERT( t.string( ) == "" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testTextSwap( )
{
T_TextBuilder tb;
tb << "test";
T_Text t( tb );
tb.clear( );
tb << E_TextStyle::BOLD << "blah";
T_Text t2( tb );
swap( t , t2 );
CPPUNIT_ASSERT( t.string( ) == "blah" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( E_TextStyle::BOLD ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
/*----------------------------------------------------------------------------*/
void ConsoleTextTest::testBuilderCopyCons( )
{
T_TextBuilder tb;
tb << "test";
T_TextBuilder tb2( tb );
T_Text t( tb ) , t2( tb2 );
CPPUNIT_ASSERT( t.string( ) == "test" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testBuilderCopyAss( )
{
T_TextBuilder tb , tb2;
tb << "test";
tb2 << "blah";
tb2 = tb;
T_Text t( tb ) , t2( tb2 );
CPPUNIT_ASSERT( t.string( ) == "test" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testBuilderMoveCons( )
{
T_TextBuilder tb;
tb << "test";
T_TextBuilder tb2( std::move( tb ) );
T_Text t( tb ) , t2( tb2 );
CPPUNIT_ASSERT( t.string( ) == "" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testBuilderMoveAss( )
{
T_TextBuilder tb , tb2;
tb << "test";
tb2 << "blah";
tb2 = std::move( tb );
T_Text t( tb ) , t2( tb2 );
CPPUNIT_ASSERT( t.string( ) == "" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}
void ConsoleTextTest::testBuilderSwap( )
{
T_TextBuilder tb , tb2;
tb << "test";
tb2 << E_TextStyle::BOLD << "blah";
swap( tb , tb2 );
T_Text t( tb ) , t2( tb2 );
CPPUNIT_ASSERT( t.string( ) == "blah" );
CPPUNIT_ASSERT( t2.string( ) == "test" );
for ( int i = 0 ; i < 4 ; i ++ ) {
CPPUNIT_ASSERT_EQUAL( uint8_t( E_TextStyle::BOLD ) , t.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t.colorAt( i ).type );
CPPUNIT_ASSERT_EQUAL( uint8_t( 0 ) , t2.styleAt( i ) );
CPPUNIT_ASSERT( E_TextColor::WHITE == t2.colorAt( i ).type );
}
}

42
tests/list.mk
View file

@ -1,4 +1,6 @@
TESTS = \
alloc-pool \
ring-buffer \
buffers \
ptr-owned \
ptr-shared \
@ -22,34 +24,12 @@ TESTS = \
hash-index \
key-value-table \
object-table \
#TESTS = \
# alloc-pool \
# ring-buffer \
# stream-file-input \
# srd-bin-reader \
# srd-bin-writer \
# srd-lexer \
# srd-text-writer \
# srd-mem-target \
# srd-parser \
# srd-parser-defs \
# srd-parser-cfg \
# srd-preproc-core \
# srd-preproc-cmd-core \
# srd-preproc-cmd-variables \
# srd-preproc-cmd-functions \
# srd-preproc-cmd-macros \
# srd-preproc-cmd-introspect \
# srd-preproc-cmd-compare \
# srd-preproc-cmd-casts \
# srd-preproc-cmd-arithmetic \
# srd-preproc-cmd-logic \
# srd-preproc-cmd-strings \
# srd-preproc-cmd-misc \
# srd-preproc-cmd-input \
# srd-preproc-tracking \
# log-data \
# console-text \
# console-edit \
# vfs
srd-mem-target \
srd-lexer \
srd-text-writer \
srd-bin-reader \
srd-bin-writer \
srd-parser-defs \
srd-parser-cfg \
srd-parser \
# END

649
tests/log-data.cc
View file

@ -1,649 +0,0 @@
#include <lw/lib/Log.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
class LogLevelTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( LogLevelTest );
CPPUNIT_TEST( testToString );
CPPUNIT_TEST_SUITE_END( );
public:
void testToString( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( LogLevelTest );
/*----------------------------------------------------------------------------*/
class LogPathTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( LogPathTest );
CPPUNIT_TEST( testEmpty );
CPPUNIT_TEST( testArrayCopy );
CPPUNIT_TEST( testArrayCopyEmpty );
CPPUNIT_TEST( testArrayCopyInvalidControl );
CPPUNIT_TEST( testArrayCopyInvalidSlash );
CPPUNIT_TEST( testArrayCopyInvalidEmpty );
CPPUNIT_TEST( testArrayMove );
CPPUNIT_TEST( testArrayMoveEmpty );
CPPUNIT_TEST( testArrayMoveInvalidControl );
CPPUNIT_TEST( testArrayMoveInvalidSlash );
CPPUNIT_TEST( testArrayMoveInvalidEmpty );
CPPUNIT_TEST( testInitList );
CPPUNIT_TEST( testInitListEmpty );
CPPUNIT_TEST( testInitListInvalidControl );
CPPUNIT_TEST( testInitListInvalidSlash );
CPPUNIT_TEST( testInitListInvalidEmpty );
CPPUNIT_TEST( testFromStringEmpty );
CPPUNIT_TEST( testFromStringSlash );
CPPUNIT_TEST( testFromStringSlashes );
CPPUNIT_TEST( testFromStringValid );
CPPUNIT_TEST( testFromStringValidSlashes );
CPPUNIT_TEST( testFromStringValidInitialSlash );
CPPUNIT_TEST( testFromStringValidTrailingSlash );
CPPUNIT_TEST( testFromStringInvalid );
CPPUNIT_TEST( testSwap );
CPPUNIT_TEST( testParentEmpty );
CPPUNIT_TEST( testParentOne );
CPPUNIT_TEST( testParentValid );
CPPUNIT_TEST( testParentInvalidChild );
CPPUNIT_TEST( testParentInvalid );
CPPUNIT_TEST( testChildValid );
CPPUNIT_TEST( testChildInvalidName );
CPPUNIT_TEST( testChildInvalidParent );
CPPUNIT_TEST( testToStringEmpty );
CPPUNIT_TEST( testToStringValid );
CPPUNIT_TEST( testToStringInvalidSlash );
CPPUNIT_TEST( testToStringInvalidControl );
CPPUNIT_TEST( testToStringInvalidEmpty );
CPPUNIT_TEST( testIsParentYes );
CPPUNIT_TEST( testIsParentNo );
CPPUNIT_TEST( testIsParentYesInvalidParent );
CPPUNIT_TEST( testIsParentYesInvalidChild );
CPPUNIT_TEST( testIsParentNoInvalidParent );
CPPUNIT_TEST( testIsParentNoInvalidChild );
CPPUNIT_TEST( testEquals );
CPPUNIT_TEST( testNotEquals );
CPPUNIT_TEST_SUITE_END( );
public:
void testEmpty( );
void testArrayCopy( );
void testArrayCopyEmpty( );
void testArrayCopyInvalidControl( );
void testArrayCopyInvalidSlash( );
void testArrayCopyInvalidEmpty( );
void testArrayMove( );
void testArrayMoveEmpty( );
void testArrayMoveInvalidControl( );
void testArrayMoveInvalidSlash( );
void testArrayMoveInvalidEmpty( );
void testInitList( );
void testInitListEmpty( );
void testInitListInvalidControl( );
void testInitListInvalidSlash( );
void testInitListInvalidEmpty( );
void testFromStringEmpty( );
void testFromStringSlash( );
void testFromStringSlashes( );
void testFromStringValid( );
void testFromStringValidSlashes( );
void testFromStringValidInitialSlash( );
void testFromStringValidTrailingSlash( );
void testFromStringInvalid( );
void testSwap( );
void testParentEmpty( );
void testParentOne( );
void testParentValid( );
void testParentInvalidChild( );
void testParentInvalid( );
void testChildValid( );
void testChildInvalidName( );
void testChildInvalidParent( );
void testToStringEmpty( );
void testToStringValid( );
void testToStringInvalidSlash( );
void testToStringInvalidControl( );
void testToStringInvalidEmpty( );
void testIsParentYes( );
void testIsParentNo( );
void testIsParentYesInvalidParent( );
void testIsParentYesInvalidChild( );
void testIsParentNoInvalidParent( );
void testIsParentNoInvalidChild( );
void testEquals( );
void testNotEquals( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( LogPathTest );
/*----------------------------------------------------------------------------*/
void LogLevelTest::testToString( )
{
T_StringBuilder sb;
sb << E_LogLevel::TRACE << ' ' << E_LogLevel::DEBUG << ' '
<< E_LogLevel::INFO << ' ' << E_LogLevel::NOTICE << ' '
<< E_LogLevel::WARNING << ' ' << E_LogLevel::ERROR << ' '
<< E_LogLevel::CRITICAL;
T_String s( std::move( sb ) );
CPPUNIT_ASSERT( s == "trace debug info notice warning error critical" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testEmpty( )
{
T_LogPath lp;
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testArrayCopy( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c" ) );
T_LogPath lp( test );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testArrayCopyEmpty( )
{
T_Array< T_String > test;
T_LogPath lp( test );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testArrayCopyInvalidControl( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c\n" ) );
T_LogPath lp( test );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c\n" );
}
void LogPathTest::testArrayCopyInvalidSlash( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c/" ) );
T_LogPath lp( test );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c/" );
}
void LogPathTest::testArrayCopyInvalidEmpty( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "" ) );
T_LogPath lp( test );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testArrayMove( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c" ) );
RPC_String s0( &test[ 0 ] );
RPC_String s1( &test[ 1 ] );
RPC_String s2( &test[ 2 ] );
T_LogPath lp( std::move( test ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
CPPUNIT_ASSERT_EQUAL( s0 , &lp[ 0 ] );
CPPUNIT_ASSERT_EQUAL( s1 , &lp[ 1 ] );
CPPUNIT_ASSERT_EQUAL( s2 , &lp[ 2 ] );
}
void LogPathTest::testArrayMoveEmpty( )
{
T_Array< T_String > test;
T_LogPath lp( std::move( test ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testArrayMoveInvalidControl( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c\n" ) );
T_LogPath lp( std::move( test ) );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c\n" );
}
void LogPathTest::testArrayMoveInvalidSlash( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "c/" ) );
T_LogPath lp( std::move( test ) );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c/" );
}
void LogPathTest::testArrayMoveInvalidEmpty( )
{
T_Array< T_String > test;
test.add( T_String::Pooled( "a" ) );
test.add( T_String::Pooled( "b" ) );
test.add( T_String::Pooled( "" ) );
T_LogPath lp( std::move( test ) );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testInitList( )
{
T_LogPath lp{ "a" , "b" , "c" };
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testInitListEmpty( )
{
T_LogPath lp{ };
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testInitListInvalidControl( )
{
T_LogPath lp{ "a" , "b" , "c\n" };
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c\n" );
}
void LogPathTest::testInitListInvalidSlash( )
{
T_LogPath lp{ "a" , "b" , "c/" };
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c/" );
}
void LogPathTest::testInitListInvalidEmpty( )
{
T_LogPath lp{ "a" , "b" , "" };
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testFromStringEmpty( )
{
T_LogPath lp( T_LogPath::FromString( "" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testFromStringSlash( )
{
T_LogPath lp( T_LogPath::FromString( "/" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testFromStringSlashes( )
{
T_LogPath lp( T_LogPath::FromString( "/////" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , lp.size( ) );
}
void LogPathTest::testFromStringValid( )
{
T_LogPath lp( T_LogPath::FromString( "a/b/c" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testFromStringValidSlashes( )
{
T_LogPath lp( T_LogPath::FromString( "a//b////c" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testFromStringValidInitialSlash( )
{
T_LogPath lp( T_LogPath::FromString( "/a/b/c" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testFromStringValidTrailingSlash( )
{
T_LogPath lp( T_LogPath::FromString( "a/b/c/" ) );
CPPUNIT_ASSERT( lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
void LogPathTest::testFromStringInvalid( )
{
T_LogPath lp( T_LogPath::FromString( "a/b\n/c" ) );
CPPUNIT_ASSERT( !lp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , lp.size( ) );
CPPUNIT_ASSERT( lp[ 0 ] == "a" );
CPPUNIT_ASSERT( lp[ 1 ] == "b\n" );
CPPUNIT_ASSERT( lp[ 2 ] == "c" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testSwap( )
{
T_LogPath lp1{ "a" };
T_LogPath lp2{ "b" , "c" };
RPC_String p[] = {
&lp1[ 0 ] , &lp2[ 0 ] , &lp2[ 1 ]
};
swap( lp1 , lp2 );
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , lp1.size( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , lp2.size( ) );
CPPUNIT_ASSERT_EQUAL( p[ 0 ] , &lp2[ 0 ] );
CPPUNIT_ASSERT_EQUAL( p[ 1 ] , &lp1[ 0 ] );
CPPUNIT_ASSERT_EQUAL( p[ 2 ] , &lp1[ 1 ] );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testParentEmpty( )
{
T_LogPath lp;
T_LogPath plp( lp.parent( ) );
CPPUNIT_ASSERT( plp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , plp.size( ) );
}
void LogPathTest::testParentOne( )
{
T_LogPath lp{ "a" };
T_LogPath plp( lp.parent( ) );
CPPUNIT_ASSERT( plp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , plp.size( ) );
}
void LogPathTest::testParentValid( )
{
T_LogPath lp{ "a" , "b" };
T_LogPath plp( lp.parent( ) );
CPPUNIT_ASSERT( plp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , plp.size( ) );
CPPUNIT_ASSERT( plp[ 0 ] == "a" );
}
void LogPathTest::testParentInvalidChild( )
{
T_LogPath lp{ "a" , "b/" };
T_LogPath plp( lp.parent( ) );
CPPUNIT_ASSERT( plp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , plp.size( ) );
CPPUNIT_ASSERT( plp[ 0 ] == "a" );
}
void LogPathTest::testParentInvalid( )
{
T_LogPath lp{ "a/" , "b" };
T_LogPath plp( lp.parent( ) );
CPPUNIT_ASSERT( !plp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , plp.size( ) );
CPPUNIT_ASSERT( plp[ 0 ] == "a/" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testChildValid( )
{
T_LogPath lp{ "a" };
T_LogPath clp( lp.child( "b" ) );
CPPUNIT_ASSERT( clp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , clp.size( ) );
CPPUNIT_ASSERT( clp[ 0 ] == "a" );
CPPUNIT_ASSERT( clp[ 1 ] == "b" );
}
void LogPathTest::testChildInvalidName( )
{
T_LogPath lp{ "a" };
T_LogPath clp( lp.child( "b\n" ) );
CPPUNIT_ASSERT( !clp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , clp.size( ) );
CPPUNIT_ASSERT( clp[ 0 ] == "a" );
CPPUNIT_ASSERT( clp[ 1 ] == "b\n" );
}
void LogPathTest::testChildInvalidParent( )
{
T_LogPath lp{ "a\n" };
T_LogPath clp( lp.child( "b" ) );
CPPUNIT_ASSERT( !clp.isValid( ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , clp.size( ) );
CPPUNIT_ASSERT( clp[ 0 ] == "a\n" );
CPPUNIT_ASSERT( clp[ 1 ] == "b" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testToStringEmpty( )
{
T_LogPath lp;
CPPUNIT_ASSERT( lp.toString( ) == "/" );
}
void LogPathTest::testToStringValid( )
{
T_LogPath lp{ "a" , "b" , "c" };
CPPUNIT_ASSERT( lp.toString( ) == "/a/b/c" );
}
void LogPathTest::testToStringInvalidSlash( )
{
T_LogPath lp{ "a" , "/b" , "c" };
CPPUNIT_ASSERT( lp.toString( ) == "/a//b/c" );
}
void LogPathTest::testToStringInvalidControl( )
{
T_LogPath lp{ "a" , "b\n" , "c" };
CPPUNIT_ASSERT( lp.toString( ) == "/a/b\n/c" );
}
void LogPathTest::testToStringInvalidEmpty( )
{
T_LogPath lp{ "a" , "" , "c" };
CPPUNIT_ASSERT( lp.toString( ) == "/a//c" );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testIsParentYes( )
{
T_LogPath gc{ "a" , "b" };
T_LogPath c{ "a" };
T_LogPath p;
CPPUNIT_ASSERT( p.isParentOf( c ) );
CPPUNIT_ASSERT( c.isParentOf( gc ) );
CPPUNIT_ASSERT( c.isChildOf( p ) );
CPPUNIT_ASSERT( gc.isChildOf( c ) );
}
void LogPathTest::testIsParentNo( )
{
T_LogPath p1{ "a" , "b" , "c" };
T_LogPath p2{ "a" , "b" , "d" , "e" };
CPPUNIT_ASSERT( !p1.isParentOf( p2 ) );
CPPUNIT_ASSERT( !p2.isParentOf( p1 ) );
CPPUNIT_ASSERT( !p1.isChildOf( p2 ) );
CPPUNIT_ASSERT( !p2.isChildOf( p1 ) );
}
void LogPathTest::testIsParentYesInvalidParent( )
{
T_LogPath p1{ "a\n" };
T_LogPath p2{ "a\n" , "b" };
CPPUNIT_ASSERT( p1.isParentOf( p2 ) );
CPPUNIT_ASSERT( p2.isChildOf( p1 ) );
}
void LogPathTest::testIsParentYesInvalidChild( )
{
T_LogPath p1{ "a" };
T_LogPath p2{ "a" , "b\n" };
CPPUNIT_ASSERT( p1.isParentOf( p2 ) );
CPPUNIT_ASSERT( p2.isChildOf( p1 ) );
}
void LogPathTest::testIsParentNoInvalidParent( )
{
T_LogPath p1{ "b\n" };
T_LogPath p2{ "c" , "b" };
CPPUNIT_ASSERT( !p1.isParentOf( p2 ) );
CPPUNIT_ASSERT( !p2.isParentOf( p1 ) );
CPPUNIT_ASSERT( !p1.isChildOf( p2 ) );
CPPUNIT_ASSERT( !p2.isChildOf( p1 ) );
}
void LogPathTest::testIsParentNoInvalidChild( )
{
T_LogPath p1{ "b" };
T_LogPath p2{ "c" , "b\n" };
CPPUNIT_ASSERT( !p1.isParentOf( p2 ) );
CPPUNIT_ASSERT( !p2.isParentOf( p1 ) );
CPPUNIT_ASSERT( !p1.isChildOf( p2 ) );
CPPUNIT_ASSERT( !p2.isChildOf( p1 ) );
}
/*----------------------------------------------------------------------------*/
void LogPathTest::testEquals( )
{
T_LogPath p1{ "a" };
T_LogPath p2( p1 );
T_LogPath p3{ "b" , "c" };
T_LogPath p4{ "d" };
CPPUNIT_ASSERT( p1 == p1 );
CPPUNIT_ASSERT( p1 == p2 );
CPPUNIT_ASSERT( !( p1 == p3 ) );
CPPUNIT_ASSERT( !( p1 == p4 ) );
}
void LogPathTest::testNotEquals( )
{
T_LogPath p1{ "a" };
T_LogPath p2( p1 );
T_LogPath p3{ "b" , "c" };
T_LogPath p4{ "d" };
CPPUNIT_ASSERT( !( p1 != p1 ) );
CPPUNIT_ASSERT( !( p1 != p2 ) );
CPPUNIT_ASSERT( p1 != p3 );
CPPUNIT_ASSERT( p1 != p4 );
}

4
tests/ring-buffer.cc
View file

@ -1,6 +1,6 @@
#include <lw/lib/Threading.hh>
#include <ebcl/Threading.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class RingBufferTest : public CppUnit::TestFixture

2
tests/run-test.cc
View file

@ -2,7 +2,7 @@
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TextTestRunner.h>
int main( int argc , char * argv[] )
int main( int , char *[] )
{
CppUnit::TextTestRunner runner;
runner.addTest( CppUnit::TestFactoryRegistry::getRegistry( )

6
tests/srd-bin-reader.cc
View file

@ -1,7 +1,7 @@
#include <lw/lib/SRDBinary.hh>
#include <lw/lib/MemoryStreams.hh>
#include <ebcl/SRDBinary.hh>
#include <ebcl/MemoryStreams.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
#define V1PROLOGUE_ \

6
tests/srd-bin-writer.cc
View file

@ -1,7 +1,7 @@
#include <lw/lib/SRDBinary.hh>
#include <lw/lib/MemoryStreams.hh>
#include <ebcl/SRDBinary.hh>
#include <ebcl/MemoryStreams.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDBinWriterTest : public CppUnit::TestFixture

4
tests/srd-lexer.cc
View file

@ -1,6 +1,6 @@
#include <lw/lib/SRDText.hh>
#include <ebcl/SRDText.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDLexerTest : public CppUnit::TestFixture

4
tests/srd-mem-target.cc
View file

@ -1,6 +1,6 @@
#include <lw/lib/SRDIO.hh>
#include <ebcl/SRDIO.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
/* - SRDMemTargetTest ---------------------------------------------------{{{-*/
class SRDMemTargetTest : public CppUnit::TestFixture

4
tests/srd-parser-cfg.cc
View file

@ -1,6 +1,6 @@
#include <lw/lib/SRDParserConfig.hh>
#include <ebcl/SRDParserConfig.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDParserConfigTest : public CppUnit::TestFixture

4
tests/srd-parser-defs.cc
View file

@ -1,6 +1,6 @@
#include <lw/lib/SRDDefinitions.hh>
#include <ebcl/SRDDefinitions.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDInputItemTest : public CppUnit::TestFixture

8
tests/srd-parser.cc
View file

@ -1,7 +1,7 @@
#include <lw/lib/SRDParser.hh>
#include <lw/lib/SRDText.hh>
#include <ebcl/SRDParser.hh>
#include <ebcl/SRDText.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDParserTest : public CppUnit::TestFixture
@ -302,7 +302,7 @@ T_SRDParserDefs SRDParserTest::makeOLBCDefs( )
void SRDParserTest::testTokenTypes( )
{
using F_InitRule = std::function< void( T_SRDContext& ) >;
using namespace lw::SRD;
using namespace ebcl::SRD;
const F_InitRule rules[] = {
[]( T_SRDContext& c ) { c << ( Rule() << Word( ) ); } ,
[]( T_SRDContext& c ) { c << ( Rule() << String( ) ); } ,

877
tests/srd-preproc-cmd-arithmetic.cc
View file

@ -1,877 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdArithmeticTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdArithmeticTest );
CPPUNIT_TEST( testAddNoArgs );
CPPUNIT_TEST( testAddOneArg );
CPPUNIT_TEST( testAddIntInt );
CPPUNIT_TEST( testAddIntLong );
CPPUNIT_TEST( testAddLongInt );
CPPUNIT_TEST( testAddLongLong );
CPPUNIT_TEST( testAddIntFloat );
CPPUNIT_TEST( testAddLongFloat );
CPPUNIT_TEST( testAddFloatInt );
CPPUNIT_TEST( testAddFloatLong );
CPPUNIT_TEST( testAddFloatFloat );
CPPUNIT_TEST( testAddManyInt );
CPPUNIT_TEST( testAddManyFloat );
CPPUNIT_TEST( testAddManyWithError );
CPPUNIT_TEST( testSubNoArgs );
CPPUNIT_TEST( testSubOneArg );
CPPUNIT_TEST( testSubIntInt );
CPPUNIT_TEST( testSubIntLong );
CPPUNIT_TEST( testSubLongInt );
CPPUNIT_TEST( testSubLongLong );
CPPUNIT_TEST( testSubIntFloat );
CPPUNIT_TEST( testSubLongFloat );
CPPUNIT_TEST( testSubFloatInt );
CPPUNIT_TEST( testSubFloatLong );
CPPUNIT_TEST( testSubFloatFloat );
CPPUNIT_TEST( testSubManyInt );
CPPUNIT_TEST( testSubManyFloat );
CPPUNIT_TEST( testSubManyWithError );
CPPUNIT_TEST( testMulNoArgs );
CPPUNIT_TEST( testMulOneArg );
CPPUNIT_TEST( testMulIntInt );
CPPUNIT_TEST( testMulIntLong );
CPPUNIT_TEST( testMulLongInt );
CPPUNIT_TEST( testMulLongLong );
CPPUNIT_TEST( testMulIntFloat );
CPPUNIT_TEST( testMulLongFloat );
CPPUNIT_TEST( testMulFloatInt );
CPPUNIT_TEST( testMulFloatLong );
CPPUNIT_TEST( testMulFloatFloat );
CPPUNIT_TEST( testMulManyInt );
CPPUNIT_TEST( testMulManyFloat );
CPPUNIT_TEST( testMulManyWithError );
CPPUNIT_TEST( testDivNoArgs );
CPPUNIT_TEST( testDivOneArg );
CPPUNIT_TEST( testDivIntInt );
CPPUNIT_TEST( testDivIntLong );
CPPUNIT_TEST( testDivLongInt );
CPPUNIT_TEST( testDivLongLong );
CPPUNIT_TEST( testDivIntFloat );
CPPUNIT_TEST( testDivLongFloat );
CPPUNIT_TEST( testDivFloatInt );
CPPUNIT_TEST( testDivFloatLong );
CPPUNIT_TEST( testDivFloatFloat );
CPPUNIT_TEST( testDivIntZero );
CPPUNIT_TEST( testDivFloatZero );
CPPUNIT_TEST( testDivManyInt );
CPPUNIT_TEST( testDivManyFloat );
CPPUNIT_TEST( testDivManyWithError );
CPPUNIT_TEST( testModNoArgs );
CPPUNIT_TEST( testModOneArg );
CPPUNIT_TEST( testModIntInt );
CPPUNIT_TEST( testModIntLong );
CPPUNIT_TEST( testModLongInt );
CPPUNIT_TEST( testModLongLong );
CPPUNIT_TEST( testModIntFloat );
CPPUNIT_TEST( testModLongFloat );
CPPUNIT_TEST( testModFloatInt );
CPPUNIT_TEST( testModFloatLong );
CPPUNIT_TEST( testModFloatFloat );
CPPUNIT_TEST( testModIntZero );
CPPUNIT_TEST( testModFloatZero );
CPPUNIT_TEST( testModManyInt );
CPPUNIT_TEST( testModManyFloat );
CPPUNIT_TEST( testModManyWithError );
CPPUNIT_TEST( testNegNoArgs );
CPPUNIT_TEST( testNegTooManyArgs );
CPPUNIT_TEST( testNegBadArg );
CPPUNIT_TEST( testNegInt );
CPPUNIT_TEST( testNegLong );
CPPUNIT_TEST( testNegReal );
CPPUNIT_TEST_SUITE_END( );
public:
void testAddNoArgs( );
void testAddOneArg( );
void testAddIntInt( );
void testAddIntLong( );
void testAddLongInt( );
void testAddLongLong( );
void testAddIntFloat( );
void testAddLongFloat( );
void testAddFloatInt( );
void testAddFloatLong( );
void testAddFloatFloat( );
void testAddManyInt( );
void testAddManyFloat( );
void testAddManyWithError( );
void testSubNoArgs( );
void testSubOneArg( );
void testSubIntInt( );
void testSubIntLong( );
void testSubLongInt( );
void testSubLongLong( );
void testSubIntFloat( );
void testSubLongFloat( );
void testSubFloatInt( );
void testSubFloatLong( );
void testSubFloatFloat( );
void testSubManyInt( );
void testSubManyFloat( );
void testSubManyWithError( );
void testMulNoArgs( );
void testMulOneArg( );
void testMulIntInt( );
void testMulIntLong( );
void testMulLongInt( );
void testMulLongLong( );
void testMulIntFloat( );
void testMulLongFloat( );
void testMulFloatInt( );
void testMulFloatLong( );
void testMulFloatFloat( );
void testMulManyInt( );
void testMulManyFloat( );
void testMulManyWithError( );
void testDivNoArgs( );
void testDivOneArg( );
void testDivIntInt( );
void testDivIntLong( );
void testDivLongInt( );
void testDivLongLong( );
void testDivIntFloat( );
void testDivLongFloat( );
void testDivFloatInt( );
void testDivFloatLong( );
void testDivFloatFloat( );
void testDivIntZero( );
void testDivFloatZero( );
void testDivManyInt( );
void testDivManyFloat( );
void testDivManyWithError( );
void testModNoArgs( );
void testModOneArg( );
void testModIntInt( );
void testModIntLong( );
void testModLongInt( );
void testModLongLong( );
void testModIntFloat( );
void testModLongFloat( );
void testModFloatInt( );
void testModFloatLong( );
void testModFloatFloat( );
void testModIntZero( );
void testModFloatZero( );
void testModManyInt( );
void testModManyFloat( );
void testModManyWithError( );
void testNegNoArgs( );
void testNegTooManyArgs( );
void testNegBadArg( );
void testNegInt( );
void testNegLong( );
void testNegReal( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdArithmeticTest );
/*----------------------------------------------------------------------------*/
#define M_MKTEST_( OP , A1 , A2 ) \
"( -set out ( -" OP " " A1 " " A2 " ) )\n" \
"( -type-of $out )\n" \
"( -if ( -eq ( -type-of $out ) long ) ( (-to-best-integer $out) ) ($out) )"
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testAddNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -add )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddOneArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -add 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddIntInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "1" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 2" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddIntLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "1" , "12123456789" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12123456790" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddLongInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "12123456789" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12123456790" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddLongLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "12123456789" , "( -to-long 1 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12123456790" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddIntFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "1" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddLongFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , "( -to-long 1 )" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddFloatInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , ".5" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddFloatLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , ".5" , "( -to-long 1 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddFloatFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "add" , ".5" , "1.5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 2.0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddManyInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -add 1 2 3 4 5 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "15" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddManyFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -add 1 .5 .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1.75" , output ) );
}
void SRDPreprocCmdArithmeticTest::testAddManyWithError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -add 1 ( ) .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real number expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "1.25" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testSubNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -sub )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubOneArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -sub 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubIntInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "1" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubIntLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "1" , "12123456789" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long -12123456788" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubLongInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "12123456789" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12123456788" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubLongLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "12123456789" , "( -to-long 1 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12123456788" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubIntFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "1" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubLongFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , "( -to-long 1 )" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubFloatInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , ".5" , "1" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real -.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubFloatLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , ".5" , "( -to-long 1 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real -.5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubFloatFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "sub" , ".5" , "1.5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real -1.0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubManyInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -sub 20 1 2 3 4 5 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubManyFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -sub 1 .5 .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( ".25" , output ) );
}
void SRDPreprocCmdArithmeticTest::testSubManyWithError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -sub 1 ( ) .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real number expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( ".75" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testMulNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mul )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulOneArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mul 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulIntInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "2" , "3" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 6" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulIntLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "2" , "6000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulLongInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "6000000000" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulLongLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "6000000000" , "( -to-long 2 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 12000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulIntFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "2" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulLongFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , "( -to-long 2 )" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulFloatInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , ".5" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulFloatLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , ".5" , "( -to-long 2 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulFloatFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mul" , ".5" , "1.5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .75" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulManyInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mul 2 3 4 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "24" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulManyFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mul 2. .5 .1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( ".1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testMulManyWithError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mul 2 ( ) .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real number expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( ".5" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testDivNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivOneArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivIntInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "4" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 2" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivIntLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "200" , "( -to-long 10 )" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 20" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivLongInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "12000000000" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 6000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivLongLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "12000000000" , "6000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 2" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivIntFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "2" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 4." , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivLongFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "6000000000" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 12e9" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivFloatInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , ".5" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .25" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivFloatLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "12e9" , "6000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 2." , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivFloatFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "div" , "1.5" , ".5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 3." , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivIntZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 10 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "non-zero argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "10" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivFloatZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 2. 0. )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "non-zero argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "2." , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivManyInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 20 2 5 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "2" , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivManyFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 2. .5 4. )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testDivManyWithError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -div 2 ( ) .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real number expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "8." , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testModNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModOneArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModIntInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "4" , "3" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModIntLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "20" , "6000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 20" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModLongInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "6000000000" , "7" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int 1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModLongLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "12000000000" , "7000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long 5000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModIntFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "2" , "1.5" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .5" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModLongFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "6000000000" , "1e10" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 6e9" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModFloatInt( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "3.0" , "2" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 1." , output ) );
}
void SRDPreprocCmdArithmeticTest::testModFloatLong( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "12e9" , "7000000000" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real 5e9" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModFloatFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( M_MKTEST_( "mod" , "1.5" , ".6" ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real .3" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModIntZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 10 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "non-zero argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "10" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModFloatZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 2. 0. )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "non-zero argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "2." , output ) );
}
void SRDPreprocCmdArithmeticTest::testModManyInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 23 5 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModManyFloat( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 2. .6 .15 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( ".05" , output ) );
}
void SRDPreprocCmdArithmeticTest::testModManyWithError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -mod 2 ( ) .25 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real number expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "0." , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdArithmeticTest::testNegNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg )" , errors ) );
CPPUNIT_ASSERT( check( "0" , output ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
}
void SRDPreprocCmdArithmeticTest::testNegTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg 1 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "-1" , output ) );
}
void SRDPreprocCmdArithmeticTest::testNegBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg nope )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer or real argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdArithmeticTest::testNegInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-12" , output ) );
}
void SRDPreprocCmdArithmeticTest::testNegLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg 12000000000 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-12000000000" , output ) );
}
void SRDPreprocCmdArithmeticTest::testNegReal( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -neg -1.2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1.2" , output ) );
}

1100
tests/srd-preproc-cmd-casts.cc
View file

File diff suppressed because it is too large Load diff

108
tests/srd-preproc-cmd-common.hh
View file

@ -1,108 +0,0 @@
#ifndef TESTS_SRDPREPROCCMDCOMMON_H_
#define TESTS_SRDPREPROCCMDCOMMON_H_
#include <lw/lib/SRDPreproc.hh>
#include <lw/lib/SRDText.hh>
#include <lw/lib/SRDIO.hh>
#include <lw/lib/MemoryStreams.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
// M_PRINTERR_( index ) - Print an error message
#define M_PRINTERR_( IDX ) \
do { \
auto const& _e( errors[ IDX ] ); \
char err[ _e.error( ).size( ) + 1 ]; \
err[ sizeof( err ) - 1 ] = 0; \
memcpy( err , _e.error( ).data( ) , \
sizeof( err ) - 1 ); \
printf( "ERR %s l. %u c. %lu\n" , err , \
_e.location( ).line( ) , \
_e.location( ).character( ) ); \
} while ( 0 )
// M_CKERR_( index , string , line , character ) - Check an error
#define M_CKERR_( IDX , STR , L , C ) \
do { \
auto const& _e( errors[ IDX ] ); \
CPPUNIT_ASSERT( T_String( STR ) == _e.error( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( L ) , \
_e.location( ).line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( C ) , \
_e.location( ).character( ) ); \
} while ( 0 )
namespace {
void process( char const* input , T_SRDPreprocessor& preproc , T_SRDErrors& errors )
{
T_SRDLexer lexer( T_String( "test" ) , errors , preproc );
preproc.start( errors );
char const* ptr = input;
while ( *ptr != 0 ) {
lexer.processCharacter( *ptr ++ );
}
lexer.processEnd( );
}
T_SRDList process( char const* input , T_SRDErrors& errors )
{
T_SRDMemoryTarget mt( false );
mt.clearFlushToken( true );
mt.start( errors );
T_SRDPreprocessorConfig emptyConfig;
emptyConfig.addBuiltinCommands( );
T_SRDPreprocessor pp( emptyConfig , mt );
process( input , pp , errors );
mt.end( errors );
return mt.list( );
}
bool checkMatch( T_SRDList const& expected , T_SRDList const& actual )
{
const size_t nExpected( expected.size( ) );
const size_t nActual( actual.size( ) );
bool ok( nExpected == nActual );
const size_t nCheck( std::min( nExpected , nActual ) );
for ( size_t i = 0 ; i < nCheck ; i ++ ) {
T_SRDToken const& tExpected( expected[ i ] );
T_SRDToken const& tActual( actual[ i ] );
if ( tExpected.type( ) != tActual.type( ) ) {
ok = false;
} else if ( tExpected.stringValue( ) != tActual.stringValue( ) ) {
ok = false;
}
}
return ok;
}
bool check( char const* expected , T_SRDList const& actual )
{
T_SRDMemoryTarget mt( false );
T_SRDErrors errors;
T_SRDLexer lexer( T_String( "expected" ) , errors , mt );
mt.start( errors );
char const* ptr = expected;
while ( *ptr != 0 ) {
lexer.processCharacter( *ptr ++ );
}
lexer.processEnd( );
const bool ok( checkMatch( mt.list( ) , actual ) );
if ( ok ) {
return true;
}
T_Buffer< char > output;
T_MemoryOutputStream stream{ output };
lw::SRDWriteAsText( stream , actual );
stream.write( "" , 1 );
std::cerr << "\nExpected:\n\t" << expected << "\nActual:\n" << output.data( ) << '\n';
return false;
}
}
#endif // TESTS_SRDPREPROCCMDCOMMON_H_

340
tests/srd-preproc-cmd-compare.cc
View file

@ -1,340 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdCompareTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdCompareTest );
CPPUNIT_TEST( testCmpMissingArgs );
CPPUNIT_TEST( testCmpExtraArgs );
CPPUNIT_TEST( testCmp );
CPPUNIT_TEST( testEqMissingArgs );
CPPUNIT_TEST( testEqExtraArgs );
CPPUNIT_TEST( testEq );
CPPUNIT_TEST( testNeMissingArgs );
CPPUNIT_TEST( testNeExtraArgs );
CPPUNIT_TEST( testNe );
CPPUNIT_TEST( testLtMissingArgs );
CPPUNIT_TEST( testLtExtraArgs );
CPPUNIT_TEST( testLt );
CPPUNIT_TEST( testGtMissingArgs );
CPPUNIT_TEST( testGtExtraArgs );
CPPUNIT_TEST( testGt );
CPPUNIT_TEST( testLeMissingArgs );
CPPUNIT_TEST( testLeExtraArgs );
CPPUNIT_TEST( testLe );
CPPUNIT_TEST( testGeMissingArgs );
CPPUNIT_TEST( testGeExtraArgs );
CPPUNIT_TEST( testGe );
CPPUNIT_TEST_SUITE_END( );
public:
void testCmpMissingArgs( );
void testCmpExtraArgs( );
void testCmp( );
void testEqMissingArgs( );
void testEqExtraArgs( );
void testEq( );
void testNeMissingArgs( );
void testNeExtraArgs( );
void testNe( );
void testLtMissingArgs( );
void testLtExtraArgs( );
void testLt( );
void testGtMissingArgs( );
void testGtExtraArgs( );
void testGt( );
void testLeMissingArgs( );
void testLeExtraArgs( );
void testLe( );
void testGeMissingArgs( );
void testGeExtraArgs( );
void testGe( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdCompareTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testCmpMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -cmp )\n( -cmp a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "0 0" , output ) );
}
void SRDPreprocCmdCompareTest::testCmpExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -cmp a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
CPPUNIT_ASSERT( check( "-1" , output ) );
}
void SRDPreprocCmdCompareTest::testCmp( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -cmp a a )\n"
"( -cmp a b )\n"
"( -cmp ((a)) b )\n"
"( -cmp a ((b)) )\n"
"( -cmp ((a)) ((b)) )\n"
"( -cmp ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0 -1 -1 1 -1 0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testEqMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -eq )\n( -eq a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "1 1" , output ) );
}
void SRDPreprocCmdCompareTest::testEqExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -eq a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdCompareTest::testEq( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -eq a a )\n"
"( -eq a b )\n"
"( -eq ((a)) b )\n"
"( -eq a ((b)) )\n"
"( -eq ((a)) ((b)) )\n"
"( -eq ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1 0 0 0 0 1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testNeMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ne )\n( -ne a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "0 0" , output ) );
}
void SRDPreprocCmdCompareTest::testNeExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ne a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdCompareTest::testNe( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -ne a a )\n"
"( -ne a b )\n"
"( -ne ((a)) b )\n"
"( -ne a ((b)) )\n"
"( -ne ((a)) ((b)) )\n"
"( -ne ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0 1 1 1 1 0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testLtMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -lt )\n( -lt a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "0 0" , output ) );
}
void SRDPreprocCmdCompareTest::testLtExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -lt a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdCompareTest::testLt( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -lt a a )\n"
"( -lt a b )\n"
"( -lt ((a)) b )\n"
"( -lt a ((b)) )\n"
"( -lt ((a)) ((b)) )\n"
"( -lt ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0 1 1 0 1 0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testGtMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -gt )\n( -gt a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "0 0" , output ) );
}
void SRDPreprocCmdCompareTest::testGtExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -gt a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdCompareTest::testGt( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -gt a a )\n"
"( -gt a b )\n"
"( -gt ((a)) b )\n"
"( -gt a ((b)) )\n"
"( -gt ((a)) ((b)) )\n"
"( -gt ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0 0 0 1 0 0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testLeMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -le )\n( -le a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "1 1" , output ) );
}
void SRDPreprocCmdCompareTest::testLeExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -le a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdCompareTest::testLe( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -le a a )\n"
"( -le a b )\n"
"( -le ((a)) b )\n"
"( -le a ((b)) )\n"
"( -le ((a)) ((b)) )\n"
"( -le ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1 1 1 0 1 1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdCompareTest::testGeMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ge )\n( -ge a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
M_CKERR_( 2 , "not enough arguments" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 9 );
CPPUNIT_ASSERT( check( "1 1" , output ) );
}
void SRDPreprocCmdCompareTest::testGeExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ge a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdCompareTest::testGe( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -ge a a )\n"
"( -ge a b )\n"
"( -ge ((a)) b )\n"
"( -ge a ((b)) )\n"
"( -ge ((a)) ((b)) )\n"
"( -ge ((a)) ((a)) )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1 0 0 1 0 1" , output ) );
}

1303
tests/srd-preproc-cmd-core.cc
View file

File diff suppressed because it is too large Load diff

441
tests/srd-preproc-cmd-functions.cc
View file

@ -1,441 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdFunctionsTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdFunctionsTest );
CPPUNIT_TEST( testBlessNoArgs );
CPPUNIT_TEST( testBlessMissing );
CPPUNIT_TEST( testBlessEmpty );
CPPUNIT_TEST( testBlessInvalid1 );
CPPUNIT_TEST( testBlessInvalid2 );
CPPUNIT_TEST( testBlessInvalid3 );
CPPUNIT_TEST( testBlessInvalid4 );
CPPUNIT_TEST( testBlessEmptyFunction );
CPPUNIT_TEST( testBlessFnWithArgs );
CPPUNIT_TEST( testBlessFnWithDupArgs );
CPPUNIT_TEST( testBlessFnWithOptArgs );
CPPUNIT_TEST( testBlessFnWithDupOptArgs );
CPPUNIT_TEST( testBlessFnWithOptArgsOnly );
CPPUNIT_TEST( testBlessFnWithDupArgsAll );
CPPUNIT_TEST( testCallNoArg );
CPPUNIT_TEST( testCallBlessedVar );
CPPUNIT_TEST( testCallBadArg );
CPPUNIT_TEST( testCallInvalidFunction );
CPPUNIT_TEST( testCallValidFunction );
CPPUNIT_TEST( testCallTooManyArgs );
CPPUNIT_TEST( testCallNotEnoughArgs );
CPPUNIT_TEST( testCallNotEnoughArgsOpt );
CPPUNIT_TEST( testBodyInnerList );
CPPUNIT_TEST( testDashFunction );
CPPUNIT_TEST( testBug00 );
CPPUNIT_TEST( testBug01 );
CPPUNIT_TEST( testBug02 );
CPPUNIT_TEST( testBug03 );
CPPUNIT_TEST_SUITE_END( );
public:
void testBlessNoArgs( );
void testBlessMissing( );
void testBlessEmpty( );
void testBlessInvalid1( );
void testBlessInvalid2( );
void testBlessInvalid3( );
void testBlessInvalid4( );
void testBlessEmptyFunction( );
void testBlessFnWithArgs( );
void testBlessFnWithDupArgs( );
void testBlessFnWithOptArgs( );
void testBlessFnWithDupOptArgs( );
void testBlessFnWithOptArgsOnly( );
void testBlessFnWithDupArgsAll( );
void testCallNoArg( );
void testCallBlessedVar( );
void testCallBadArg( );
void testCallInvalidFunction( );
void testCallValidFunction( );
void testCallTooManyArgs( );
void testCallNotEnoughArgs( );
void testCallNotEnoughArgsOpt( );
void testBodyInnerList( );
void testDashFunction( );
void testBug00( );
void testBug01( );
void testBug02( );
void testBug03( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdFunctionsTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdFunctionsTest::testBlessNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bless )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessMissing( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bless a ) " , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a )\n"
"( -bless a )\n"
"( $a ) " ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "( )" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessInvalid1( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set x\n"
"nope\n"
")\n"
"( -bless x )\n"
"($x)" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 4 , 3 );
M_CKERR_( 1 , "previous error cause" , 4 , 10 );
CPPUNIT_ASSERT( check( "(nope)" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessInvalid2( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set x\n"
"()\n"
")\n"
"( -bless x )\n"
"($x)" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 4 , 3 );
M_CKERR_( 1 , "previous error cause" , 4 , 10 );
CPPUNIT_ASSERT( check( "(())" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessInvalid3( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set x\n"
"(nope)\n"
")\n"
"( -bless x )\n"
"($x)" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 4 , 3 );
M_CKERR_( 1 , "previous error cause" , 4 , 10 );
CPPUNIT_ASSERT( check( "((nope))" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessInvalid4( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set x\n"
"(()) nope\n"
")\n"
"( -bless x )\n"
"($x)" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 4 , 3 );
M_CKERR_( 1 , "previous error cause" , 4 , 10 );
CPPUNIT_ASSERT( check( "((()) nope)" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessEmptyFunction( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( ) x ) )\n"
"( -bless a )\n"
"( $a ) " ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "x" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( u v w ) ( -raw $u $v $w ) ) )\n"
"( -bless a )\n"
"( $a b c d ) " ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "b c d" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithDupArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( u v u ) ( -raw $u $v ) ) )\n"
"( -bless a )\n"
"( $a b c d ) " ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "( ( ( u v u ) $u $v ) b c d )" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithOptArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( u ( v ) ) ( -raw ( $u ) ( $v ) ) ) )\n"
"( -bless a )\n"
"($a b c d)\n"
"($a e)\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( b ) ( c d ) ( e ) ( )" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithDupOptArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( u ( v v ) ) ( -raw ( $u ) ( $v ) ) ) )\n"
"( -bless a )\n"
"( $a b )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "( ( ( u ( v v ) ) ( $u ) ( $v ) ) b )" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithOptArgsOnly( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( ( v ) ) ( -raw ( $v ) ) ) )\n"
"( -bless a )\n"
"( $a ) ( $a b ) ( $a c d )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( ) ( b ) ( c d )" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBlessFnWithDupArgsAll( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set a ( ( u ( v u ) ) ( -raw ( $u ) ( $v ) ) ) )\n"
"( -bless a )\n"
"( $a b )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid function" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "( ( ( u ( v u ) ) ( $u ) ( $v ) ) b )" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdFunctionsTest::testCallNoArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 9 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallBlessedVar( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set f (() x))\n"
"(-bless f)\n"
"( -call $f )"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "x" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "list expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 9 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallInvalidFunction( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call ( nope ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "list expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallValidFunction( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call ( -raw ( ( x ( y ) ) $y $x ) ) a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "b c a" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call ( -raw ( ( x ) $x ) ) a b )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 33 );
CPPUNIT_ASSERT( check( "a" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call ( -raw ( ( x ) $x ) ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 31 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdFunctionsTest::testCallNotEnoughArgsOpt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -call ( -raw ( ( x y ( z ) ) $x ) ) a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 41 );
CPPUNIT_ASSERT( check( "" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdFunctionsTest::testBodyInnerList( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set x (-raw ( () ) ) )\n"
"( -bless x )\n"
"( -call ( -raw ( () -not-a-command ) ) )\n"
"( -call ( -raw ( () $x ) ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-not-a-command (())" , output ) );
}
void SRDPreprocCmdFunctionsTest::testDashFunction( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set -f ((x) (-raw yo $x)))\n"
"(-bless -f)\n"
"(-f bob)\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "yo bob" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdFunctionsTest::testBug00( )
{
/* A bug with tail calls - the code below would output "y x" */
T_SRDErrors errors;
T_SRDList output( process(
"(-set f1 ((-raw (a) $a)))\n"
"(-set f2 ((-raw (a) ($f1 $a))))\n"
"(-bless f1 f2)\n"
"($f2 x) y\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "x y" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBug01( )
{
/* Similar to bug 00, except with an ending parens. */
T_SRDErrors errors;
T_SRDList output( process(
"(-set f1 ((-raw (a) $a)))\n"
"(-set f2 ((-raw (a) ($f1 $a))))\n"
"(-bless f1 f2)\n"
"(($f2 x))\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "(x)" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBug02( )
{
/* Causes a crash due to a missing location */
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw (((list))\n"
"(-set (first rest) $list)\n"
"(-if (-length ($first)) (\n"
"($first ($fn $rest))\n"
"))\n"
")))\n"
"(-bless fn)\n"
"($fn a b)\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "(a (b))" , output ) );
}
void SRDPreprocCmdFunctionsTest::testBug03( )
{
/* More tail-call problems (interaction between the "unswallow"
* part of the evaluator/function feeders and stuff that stands
* between them).
*/
T_SRDErrors errors;
T_SRDList output( process(
"(-set (f1 f2) (-raw\n"
"(() (-if 1 ()))\n"
"(() ($f1))\n"
"))\n"
"(-bless f1 f2)\n"
"(-eval ((-raw -eval) ((-raw $f2))))\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "(a (b))" , output ) );
}

543
tests/srd-preproc-cmd-input.cc
View file

@ -1,543 +0,0 @@
#include "srd-preproc-cmd-common.hh"
#include "srd-preproc-location.hh"
class SRDPreprocCmdInputTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdInputTest );
CPPUNIT_TEST( testFromSourceNoName );
CPPUNIT_TEST( testFromSourceNamed );
CPPUNIT_TEST( testFromSourceError );
CPPUNIT_TEST( testFromSourceErrorNamed );
CPPUNIT_TEST( testFromSourceTooManyErrors );
CPPUNIT_TEST( testFromSourceLocation );
CPPUNIT_TEST( testFromSourceLocationNamed );
CPPUNIT_TEST( testFromSourceLocationChaining );
CPPUNIT_TEST( testFromSourceLocationRewind );
CPPUNIT_TEST( testFromSourceLocationRewindTooMuch );
CPPUNIT_TEST( testFromSourceArgsNone );
CPPUNIT_TEST( testFromSourceArgsExtra );
CPPUNIT_TEST( testFromSourceArgsBadSource );
CPPUNIT_TEST( testFromSourceArgsBadName );
CPPUNIT_TEST( testFromSourceArgsBadChaining );
CPPUNIT_TEST( testFromSourceArgsBadRewind );
CPPUNIT_TEST( testFromSRBNoName );
CPPUNIT_TEST( testFromSRBNamed );
CPPUNIT_TEST( testFromSRBError );
CPPUNIT_TEST( testFromSRBErrorNamed );
CPPUNIT_TEST( testFromSRBLocation );
CPPUNIT_TEST( testFromSRBLocationNamed );
CPPUNIT_TEST( testFromSRBLocationChaining );
CPPUNIT_TEST( testFromSRBLocationRewind );
CPPUNIT_TEST( testFromSRBLocationRewindTooMuch );
CPPUNIT_TEST( testFromSRBArgsNone );
CPPUNIT_TEST( testFromSRBArgsExtra );
CPPUNIT_TEST( testFromSRBArgsBadInput );
CPPUNIT_TEST( testFromSRBArgsBadName );
CPPUNIT_TEST( testFromSRBArgsBadChaining );
CPPUNIT_TEST( testFromSRBArgsBadRewind );
CPPUNIT_TEST_SUITE_END( );
public:
void testFromSourceNoName( );
void testFromSourceNamed( );
void testFromSourceError( );
void testFromSourceErrorNamed( );
void testFromSourceTooManyErrors( );
void testFromSourceLocation( );
void testFromSourceLocationNamed( );
void testFromSourceLocationChaining( );
void testFromSourceLocationRewind( );
void testFromSourceLocationRewindTooMuch( );
void testFromSourceArgsNone( );
void testFromSourceArgsExtra( );
void testFromSourceArgsBadSource( );
void testFromSourceArgsBadName( );
void testFromSourceArgsBadChaining( );
void testFromSourceArgsBadRewind( );
void testFromSRBNoName( );
void testFromSRBNamed( );
void testFromSRBError( );
void testFromSRBErrorNamed( );
void testFromSRBLocation( );
void testFromSRBLocationNamed( );
void testFromSRBLocationChaining( );
void testFromSRBLocationRewind( );
void testFromSRBLocationRewindTooMuch( );
void testFromSRBArgsNone( );
void testFromSRBArgsExtra( );
void testFromSRBArgsBadInput( );
void testFromSRBArgsBadName( );
void testFromSRBArgsBadChaining( );
void testFromSRBArgsBadRewind( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdInputTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdInputTest::testFromSourceNoName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"word \\\"string\\\" 123 5000000000 1.2 $x ( some list )\" )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "word \"string\" 123 5000000000 1.2 $x ( some list )" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceNamed( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-source \"word \\\"string\\\" 123 5000000000 1.2 $x ( some list )\"\n"
"\"some_random_file.srd\" )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "word \"string\" 123 5000000000 1.2 $x ( some list )" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source\n\"( a\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unterminated list" , 1 , 1 );
CPPUNIT_ASSERT( errors[ 0 ].location( ).source( ) == "-from-source" );
CPPUNIT_ASSERT( check( "( a )" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceErrorNamed( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source\n\"( a\" \"some_random_file.srd\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unterminated list" , 1 , 1 );
CPPUNIT_ASSERT( errors[ 0 ].location( ).source( ) == "some_random_file.srd" );
CPPUNIT_ASSERT( check( "( a )" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceTooManyErrors( )
{
T_StringBuilder sb( "( -from-source \"" );
for ( auto i = 0u ; i < T_SRDErrors::MAX_ERRORS + 1 ; i ++ ) {
sb << "(\\u00a1";
}
sb << "\" )" << '\0';
try {
T_SRDErrors errors;
T_SRDList output( process( sb.data( ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( T_SRDErrors::MAX_ERRORS + 1 ) , errors.size( ) );
for ( auto i = 0u ; i < T_SRDErrors::MAX_ERRORS ; i ++ ) {
M_CKERR_( i , "unexpected character" , 1 , ( i + 1 ) * 2 );
}
M_CKERR_( T_SRDErrors::MAX_ERRORS , "too many errors" , 1 , 80 );
sb.clear( );
for ( auto i = 0u ; i < T_SRDErrors::MAX_ERRORS ; i ++ ) {
sb << '(';
}
for ( auto i = 0u ; i < T_SRDErrors::MAX_ERRORS ; i ++ ) {
sb << ')';
}
sb << '\0';
CPPUNIT_ASSERT( check( sb.data( ) , output ) );
} catch ( X_SRDErrors const& e ) {
auto const& errors( e.errors );
for ( auto i = 0u ; i < errors.size( ) ; i ++ ) {
M_PRINTERR_( i );
}
CPPUNIT_FAIL( "Shouldn't fail with exception" );
}
}
void SRDPreprocCmdInputTest::testFromSourceLocation( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"test\\ntest\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "test test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "-from-source" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "-from-source" , 2 , 1 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceLocationNamed( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"test\\ntest\" \"test.srd\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "test test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test.srd" , 2 , 1 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceLocationChaining( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"test\\ntest\" \"test.srd\" loaded )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "test test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test.srd" , 2 , 1 );
M_CKTOKCHAIN_( 1 , 0 , LOADED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceLocationRewind( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set doit ((-raw ()\n"
"( -from-source \"test\" \"test.srd\" loaded 2 )\n"
")))\n"
"(-set tfn ((-raw (x)\n"
"(-if (-lt $x 1) (\n"
"($doit)\n"
")(\n"
"($tfn (-sub $x 1))\n"
"))\n"
")))\n"
"(-bless tfn doit)\n"
"($tfn 5)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 12 , 2 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceLocationRewindTooMuch( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"test\" \"test.srd\" loaded 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 1 , 3 , 0 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdInputTest::testFromSourceArgsNone( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceArgsExtra( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source \"x\" \"y\" generated 0 c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 36 );
CPPUNIT_ASSERT( check( "x" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceArgsBadSource( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-source 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSourceArgsBadName( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-source \"test\"\n"
"12 )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
CPPUNIT_ASSERT( check( "test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "-from-source" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceArgsBadChaining( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-source \"test\" \"test.srd\"\n"
"nope )\n"
"( -from-source \"test\" \"test2.srd\"\n"
"12 )\n" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "'generated', 'included' or 'loaded' expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
M_CKERR_( 2 , "'generated', 'included' or 'loaded' expected" , 3 , 3 );
M_CKERR_( 3 , "previous error cause" , 4 , 1 );
CPPUNIT_ASSERT( check( "test test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test2.srd" , 1 , 1 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 3 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSourceArgsBadRewind( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-source \"test\" \"test.srd\" generated\n"
"-1 )\n"
"( -from-source \"test\" \"test2.srd\" generated\n"
"nope )\n" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
M_CKERR_( 2 , "integer argument expected" , 3 , 3 );
M_CKERR_( 3 , "previous error cause" , 4 , 1 );
CPPUNIT_ASSERT( check( "test test" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 1 , 1 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test2.srd" , 1 , 1 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 3 , 3 , 0 );
}
/*----------------------------------------------------------------------------*/
#define SRB_PROLOGUE_ \
"ce a1 7c ea " \
"00 ee ff c0"
#define SRB_DATA_ \
"[ " \
SRB_PROLOGUE_ \
"02 03 00 00 00 4c 4f 4c" \
"00" \
"]"
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdInputTest::testFromSRBNoName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBNamed( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-srb " SRB_DATA_ "\n"
"\"some_random_file.srb\" )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBError( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb\n[ " SRB_PROLOGUE_ " ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unexpected end of file" , 0 , 8 );
CPPUNIT_ASSERT( errors[ 0 ].location( ).source( ) == "-from-srb" );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBErrorNamed( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-srb\n[ "
SRB_PROLOGUE_
" ] \"some_random_file.srb\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unexpected end of file" , 0 , 8 );
CPPUNIT_ASSERT( errors[ 0 ].location( ).source( ) == "some_random_file.srb" );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBLocation( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " )\n" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "-from-srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSRBLocationNamed( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " \"test.srb\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSRBLocationChaining( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " \"test.srb\" loaded )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 1 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSRBLocationRewind( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set doit ((-raw ()\n"
"( -from-srb " SRB_DATA_ " \"test.srb\" loaded 2 )\n"
")))\n"
"(-set tfn ((-raw (x)\n"
"(-if (-lt $x 1) (\n"
"($doit)\n"
")(\n"
"($tfn (-sub $x 1))\n"
"))\n"
")))\n"
"(-bless tfn doit)\n"
"($tfn 5)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 12 , 2 , 0 );
}
void SRDPreprocCmdInputTest::testFromSRBLocationRewindTooMuch( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " \"test.srb\" loaded 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , LOADED , "test" , 1 , 3 , 0 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdInputTest::testFromSRBArgsNone( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBArgsExtra( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb " SRB_DATA_ " a loaded 0\nnope )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
CPPUNIT_ASSERT( check( "LOL" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBArgsBadInput( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -from-srb \"x\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBArgsBadName( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-srb " SRB_DATA_ "\n12 )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
CPPUNIT_ASSERT( check( "LOL" , output ) );
}
void SRDPreprocCmdInputTest::testFromSRBArgsBadChaining( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-srb " SRB_DATA_ " \"test.srb\"\n"
"nope )\n"
"( -from-srb " SRB_DATA_ " \"test2.srb\"\n"
"12 )\n" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "'generated', 'included' or 'loaded' expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
M_CKERR_( 2 , "'generated', 'included' or 'loaded' expected" , 3 , 3 );
M_CKERR_( 3 , "previous error cause" , 4 , 1 );
CPPUNIT_ASSERT( check( "LOL LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srb" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test2.srb" , 0 , 8 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 3 , 3 , 0 );
}
void SRDPreprocCmdInputTest::testFromSRBArgsBadRewind( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -from-srb " SRB_DATA_ " \"test.srd\" generated\n"
"-1 )\n"
"( -from-srb " SRB_DATA_ " \"test2.srd\" generated\n"
"nope )\n" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
M_CKERR_( 2 , "integer argument expected" , 3 , 3 );
M_CKERR_( 3 , "previous error cause" , 4 , 1 );
CPPUNIT_ASSERT( check( "LOL LOL" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test.srd" , 0 , 8 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 3 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test2.srd" , 0 , 8 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 3 , 3 , 0 );
}

322
tests/srd-preproc-cmd-introspect.cc
View file

@ -1,322 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdIntrospectTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdIntrospectTest );
CPPUNIT_TEST( testIsSetMissingArgs );
CPPUNIT_TEST( testIsSetExtraArgs );
CPPUNIT_TEST( testIsSetBadArg );
CPPUNIT_TEST( testIsSetTrue );
CPPUNIT_TEST( testIsSetFalse );
CPPUNIT_TEST( testIsMacroMissingArgs );
CPPUNIT_TEST( testIsMacroExtraArgs );
CPPUNIT_TEST( testIsMacroBadArg );
CPPUNIT_TEST( testIsMacroTrue );
CPPUNIT_TEST( testIsMacroFalse );
CPPUNIT_TEST( testIsBlessedMissingArgs );
CPPUNIT_TEST( testIsBlessedExtraArgs );
CPPUNIT_TEST( testIsBlessedBadArg );
CPPUNIT_TEST( testIsBlessedUnset );
CPPUNIT_TEST( testIsBlessedUnblessed );
CPPUNIT_TEST( testIsBlessedTrue );
CPPUNIT_TEST( testTypeOfMissingArg );
CPPUNIT_TEST( testTypeOfExtraArgs );
CPPUNIT_TEST( testTypeOfList );
CPPUNIT_TEST( testTypeOfWord );
CPPUNIT_TEST( testTypeOfString );
CPPUNIT_TEST( testTypeOfInt );
CPPUNIT_TEST( testTypeOfLong );
CPPUNIT_TEST( testTypeOfReal );
CPPUNIT_TEST( testTypeOfVar );
CPPUNIT_TEST( testTypeOfBinary );
CPPUNIT_TEST( testTypeOfComment );
CPPUNIT_TEST_SUITE_END( );
public:
void testIsSetMissingArgs( );
void testIsSetExtraArgs( );
void testIsSetBadArg( );
void testIsSetTrue( );
void testIsSetFalse( );
void testIsMacroMissingArgs( );
void testIsMacroExtraArgs( );
void testIsMacroBadArg( );
void testIsMacroTrue( );
void testIsMacroFalse( );
void testIsBlessedMissingArgs( );
void testIsBlessedExtraArgs( );
void testIsBlessedBadArg( );
void testIsBlessedUnset( );
void testIsBlessedUnblessed( );
void testIsBlessedTrue( );
void testTypeOfMissingArg( );
void testTypeOfExtraArgs( );
void testTypeOfList( );
void testTypeOfWord( );
void testTypeOfString( );
void testTypeOfInt( );
void testTypeOfLong( );
void testTypeOfReal( );
void testTypeOfVar( );
void testTypeOfBinary( );
void testTypeOfComment( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdIntrospectTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdIntrospectTest::testIsSetMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-set )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsSetExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-set a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsSetBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-set 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsSetTrue( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set x 1)( -is-set x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsSetFalse( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-set x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdIntrospectTest::testIsMacroMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-macro )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsMacroExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-macro a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsMacroBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-macro 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsMacroTrue( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set-macro x (()))( -is-macro x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsMacroFalse( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-macro x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdIntrospectTest::testIsBlessedMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-blessed )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsBlessedExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-blessed a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 17 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsBlessedBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-blessed 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsBlessedUnset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -is-blessed x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsBlessedUnblessed( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set x 1)( -is-blessed x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdIntrospectTest::testIsBlessedTrue( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set x (()) )\n"
"( -bless x )\n"
"( -is-blessed x )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdIntrospectTest::testTypeOfMissingArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
CPPUNIT_ASSERT( check( "none" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "word" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfList( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "list" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfWord( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of w )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "word" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of \"w\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "string" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "int" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of 12123456789 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "long" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfReal( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of 0. )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "real" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfVar( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of ( -raw $x ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "var" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfBinary( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of [] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "binary" , output ) );
}
void SRDPreprocCmdIntrospectTest::testTypeOfComment( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -type-of (-from-source \"{x}\") )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "comment" , output ) );
}

609
tests/srd-preproc-cmd-logic.cc
View file

@ -1,609 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdLogicTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdLogicTest );
CPPUNIT_TEST( testNotNoArgs );
CPPUNIT_TEST( testNotTooManyArgs );
CPPUNIT_TEST( testNotBadArg );
CPPUNIT_TEST( testNotZero );
CPPUNIT_TEST( testNotNonZeroInt );
CPPUNIT_TEST( testNotNonZeroLong );
CPPUNIT_TEST( testBwNotNoArgs );
CPPUNIT_TEST( testBwNotTooManyArgs );
CPPUNIT_TEST( testBwNotBadArg );
CPPUNIT_TEST( testBwNotInt );
CPPUNIT_TEST( testBwNotLong );
CPPUNIT_TEST( testAndNoArgs );
CPPUNIT_TEST( testAndBadArgs );
CPPUNIT_TEST( testAnd00 );
CPPUNIT_TEST( testAnd01 );
CPPUNIT_TEST( testAnd10 );
CPPUNIT_TEST( testAnd11 );
CPPUNIT_TEST( testAndMultiple );
CPPUNIT_TEST( testAndLong );
CPPUNIT_TEST( testAndSillyValues );
CPPUNIT_TEST( testBwAndNoArgs );
CPPUNIT_TEST( testBwAndBadArgs );
CPPUNIT_TEST( testBwAndInts );
CPPUNIT_TEST( testBwAndLongs );
CPPUNIT_TEST( testBwAndMultiple );
CPPUNIT_TEST( testOrNoArgs );
CPPUNIT_TEST( testOrBadArgs );
CPPUNIT_TEST( testOr00 );
CPPUNIT_TEST( testOr01 );
CPPUNIT_TEST( testOr10 );
CPPUNIT_TEST( testOr11 );
CPPUNIT_TEST( testOrMultiple );
CPPUNIT_TEST( testOrLong );
CPPUNIT_TEST( testOrSillyValues );
CPPUNIT_TEST( testBwOrNoArgs );
CPPUNIT_TEST( testBwOrBadArgs );
CPPUNIT_TEST( testBwOrInts );
CPPUNIT_TEST( testBwOrLongs );
CPPUNIT_TEST( testBwOrMultiple );
CPPUNIT_TEST( testXorNoArgs );
CPPUNIT_TEST( testXorBadArgs );
CPPUNIT_TEST( testXor00 );
CPPUNIT_TEST( testXor01 );
CPPUNIT_TEST( testXor10 );
CPPUNIT_TEST( testXor11 );
CPPUNIT_TEST( testXorMultiple );
CPPUNIT_TEST( testXorLong );
CPPUNIT_TEST( testXorSillyValues );
CPPUNIT_TEST( testBwXorNoArgs );
CPPUNIT_TEST( testBwXorBadArgs );
CPPUNIT_TEST( testBwXorInts );
CPPUNIT_TEST( testBwXorLongs );
CPPUNIT_TEST( testBwXorMultiple );
CPPUNIT_TEST_SUITE_END( );
public:
void testNotNoArgs( );
void testNotTooManyArgs( );
void testNotBadArg( );
void testNotZero( );
void testNotNonZeroInt( );
void testNotNonZeroLong( );
void testBwNotNoArgs( );
void testBwNotTooManyArgs( );
void testBwNotBadArg( );
void testBwNotInt( );
void testBwNotLong( );
void testAndNoArgs( );
void testAndBadArgs( );
void testAnd00( );
void testAnd01( );
void testAnd10( );
void testAnd11( );
void testAndMultiple( );
void testAndLong( );
void testAndSillyValues( );
void testBwAndNoArgs( );
void testBwAndBadArgs( );
void testBwAndInts( );
void testBwAndLongs( );
void testBwAndMultiple( );
void testOrNoArgs( );
void testOrBadArgs( );
void testOr00( );
void testOr01( );
void testOr10( );
void testOr11( );
void testOrMultiple( );
void testOrLong( );
void testOrSillyValues( );
void testBwOrNoArgs( );
void testBwOrBadArgs( );
void testBwOrInts( );
void testBwOrLongs( );
void testBwOrMultiple( );
void testXorNoArgs( );
void testXorBadArgs( );
void testXor00( );
void testXor01( );
void testXor10( );
void testXor11( );
void testXorMultiple( );
void testXorLong( );
void testXorSillyValues( );
void testBwXorNoArgs( );
void testBwXorBadArgs( );
void testBwXorInts( );
void testBwXorLongs( );
void testBwXorMultiple( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdLogicTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testNotNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -not )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testNotTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -not 0 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testNotBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -not 0. )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testNotZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -not 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testNotNonZeroInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -not 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testNotNonZeroLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set x ( -not 12000000000 ))(-to-integer $x)(-type-of $x)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0 long" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testBwNotNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-not )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testBwNotTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-not 1 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "-2" , output ) );
}
void SRDPreprocCmdLogicTest::testBwNotBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-not 2.2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "-3" , output ) );
}
void SRDPreprocCmdLogicTest::testBwNotInt( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-not 129 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-130" , output ) );
}
void SRDPreprocCmdLogicTest::testBwNotLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-not 12000000000 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-12000000001" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testAndNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testAndBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 1 1. ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testAnd00( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 0 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testAnd01( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 0 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testAnd10( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 1 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testAnd11( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 1 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testAndMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 1 1 1 1 )( -and 1 0 1 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1 0" , output ) );
}
void SRDPreprocCmdLogicTest::testAndLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and 1 ( -to-long 1 ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testAndSillyValues( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -and -42384 35845 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testBwAndNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-and )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testBwAndBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-and 1.2 ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testBwAndInts( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-and 5 6 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "4" , output ) );
}
void SRDPreprocCmdLogicTest::testBwAndLongs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-and 12884901888 4294967296 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "4294967296" , output ) );
}
void SRDPreprocCmdLogicTest::testBwAndMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-and 15 7 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "3" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testOrNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 7 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testOrBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 1 1. ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 9 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testOr00( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 0 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testOr01( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 0 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testOr10( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 1 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testOr11( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 1 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testOrMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 1 1 1 1 )( -or 1 0 1 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1 1" , output ) );
}
void SRDPreprocCmdLogicTest::testOrLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 1 ( -to-long 1 ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testOrSillyValues( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -or 0 35845 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testBwOrNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-or )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testBwOrBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-or 1.2 ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testBwOrInts( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-or 5 6 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "7" , output ) );
}
void SRDPreprocCmdLogicTest::testBwOrLongs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-or 8589934592 4294967296 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "12884901888" , output ) );
}
void SRDPreprocCmdLogicTest::testBwOrMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-or 2 4 8 6 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "14" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testXorNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testXorBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 1 1. ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testXor00( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 0 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testXor01( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 0 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testXor10( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 1 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testXor11( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 1 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testXorMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 1 0 0 0 )( -xor 1 0 1 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1 0" , output ) );
}
void SRDPreprocCmdLogicTest::testXorLong( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 1 ( -to-long 1 ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testXorSillyValues( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -xor 0 35845 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdLogicTest::testBwXorNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-xor )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdLogicTest::testBwXorBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-xor 1.2 ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdLogicTest::testBwXorInts( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-xor 5 6 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "3" , output ) );
}
void SRDPreprocCmdLogicTest::testBwXorLongs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-xor 21474836480 25769803776 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "12884901888" , output ) );
}
void SRDPreprocCmdLogicTest::testBwXorMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -bw-xor 2 4 8 6 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "8" , output ) );
}

243
tests/srd-preproc-cmd-macros.cc
View file

@ -1,243 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdMacrosTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdMacrosTest );
CPPUNIT_TEST( testSetMacroEmpty );
CPPUNIT_TEST( testSetMacroMissingArgs );
CPPUNIT_TEST( testSetMacroExtraArgs );
CPPUNIT_TEST( testSetMacroBadName );
CPPUNIT_TEST( testSetMacroBadBody );
CPPUNIT_TEST( testSetMacroInvalidBody );
CPPUNIT_TEST( testSetMacroSuccess );
CPPUNIT_TEST( testSetMacroDuplicate );
CPPUNIT_TEST( testUnsetMacroNoArgs );
CPPUNIT_TEST( testUnsetMacro );
CPPUNIT_TEST( testUnsetMacroMissing );
CPPUNIT_TEST( testUnsetMacroMultiple );
CPPUNIT_TEST( testListMacros );
CPPUNIT_TEST( testListMacrosArgs );
CPPUNIT_TEST( testMacroBodyInnerList );
CPPUNIT_TEST( testMacroOutputInnerList );
CPPUNIT_TEST_SUITE_END( );
public:
void testSetMacroEmpty( );
void testSetMacroMissingArgs( );
void testSetMacroExtraArgs( );
void testSetMacroBadName( );
void testSetMacroBadBody( );
void testSetMacroInvalidBody( );
void testSetMacroSuccess( );
void testSetMacroDuplicate( );
void testUnsetMacroNoArgs( );
void testUnsetMacro( );
void testUnsetMacroMissing( );
void testUnsetMacroMultiple( );
void testListMacros( );
void testListMacrosArgs( );
void testMacroBodyInnerList( );
void testMacroOutputInnerList( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdMacrosTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMacrosTest::testSetMacroEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroMissingArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid macro" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro a ( () ) x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 23 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroBadName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro 1 ( () ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroBadBody( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro a x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid macro" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroInvalidBody( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set-macro a ( nope ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid macro" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroSuccess( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro test ( -raw ( ((list)) ( (-raw -raw) $list ) ) ) )\n"
"(test $x $y $z (-set x 1))",
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "$x $y $z (-set x 1)" , output ) );
}
void SRDPreprocCmdMacrosTest::testSetMacroDuplicate( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro a (()) )\n"
"( -set-macro a (()) )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "duplicate macro" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 14 );
CPPUNIT_ASSERT( check( "" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMacrosTest::testUnsetMacroNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unset-macro ) " , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMacrosTest::testUnsetMacro( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro a (()1) )\n"
"(a)\n"
"( -unset-macro a )\n"
"(a)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "1 (a)" , output ) );
}
void SRDPreprocCmdMacrosTest::testUnsetMacroMissing( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unset-macro a )(a)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "(a)" , output ) );
}
void SRDPreprocCmdMacrosTest::testUnsetMacroMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro a (()1) )\n"
"( -set-macro b (()2) )\n"
"( -set-macro c (()3) )\n"
"( -unset-macro a c d )\n"
"(a)(b)(c)\n" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "(a) 2 (c)" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMacrosTest::testListMacros( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set x )\n"
"( -set-macro y ( ( ) ) )\n"
"( -set f (-raw (() ((-ls-macros))) ))\n"
"( -bless f )\n"
"( ( -ls-macros ) )\n"
"( -scope\n"
"( -unset-macro y )\n"
"( ( -ls-macros ) )\n"
")\n"
"($f)\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( y ) ( ) ( y )" , output ) );
}
void SRDPreprocCmdMacrosTest::testListMacrosArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro y ( ( ) ) )\n"
"( -ls-macros blah )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 14 );
CPPUNIT_ASSERT( check( "y" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMacrosTest::testMacroBodyInnerList( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro x (-raw ( () -not-a-command ) ) )\n"
"( -set x (-raw ( () ) ) )\n"
"( -bless x )\n"
"( -set-macro y (-raw ( () $x ) ) )\n"
"(x)(y)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-not-a-command (())" , output ) );
}
void SRDPreprocCmdMacrosTest::testMacroOutputInnerList( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set-macro x (-raw ( () (-raw -not-a-command) ) ) )\n"
"( -set x (-raw ( () ) ) )\n"
"( -bless x )\n"
"( -set-macro y (-raw ( () (-raw $x ) ) ) )\n"
"(x)(y)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-not-a-command (())" , output ) );
}

165
tests/srd-preproc-cmd-misc.cc
View file

@ -1,165 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdMiscTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdMiscTest );
CPPUNIT_TEST( testIgnore );
CPPUNIT_TEST( testUnwrapMissingArg );
CPPUNIT_TEST( testUnwrapBadArg );
CPPUNIT_TEST( testUnwrapEmptyList );
CPPUNIT_TEST( testUnwrapList );
CPPUNIT_TEST( testUnwrapExtraArgs );
CPPUNIT_TEST( testLengthMissingArg );
CPPUNIT_TEST( testLengthExtraArgs );
CPPUNIT_TEST( testLengthBadArg );
CPPUNIT_TEST( testLengthList );
CPPUNIT_TEST( testLengthWord );
CPPUNIT_TEST( testLengthString );
CPPUNIT_TEST( testLengthBinary );
CPPUNIT_TEST_SUITE_END( );
public:
void testIgnore( );
void testUnwrapMissingArg( );
void testUnwrapBadArg( );
void testUnwrapEmptyList( );
void testUnwrapList( );
void testUnwrapExtraArgs( );
void testLengthMissingArg( );
void testLengthExtraArgs( );
void testLengthBadArg( );
void testLengthList( );
void testLengthWord( );
void testLengthString( );
void testLengthBinary( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdMiscTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMiscTest::testIgnore( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ignore $does-not-exist ( -fail ) bleh )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMiscTest::testUnwrapMissingArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unwrap )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMiscTest::testUnwrapBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unwrap a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "list expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMiscTest::testUnwrapEmptyList( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unwrap ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdMiscTest::testUnwrapList( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unwrap ( a b c ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "a b c" , output ) );
}
void SRDPreprocCmdMiscTest::testUnwrapExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unwrap ( a ) ( b c ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 17 );
CPPUNIT_ASSERT( check( "a" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdMiscTest::testLengthMissingArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "-1" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthExtraArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 13 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "list, word, string or binary array expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "-1" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthList( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length ( a ( b ) ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "2" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthWord( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length abc )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "3" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length \"some string\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "11" , output ) );
}
void SRDPreprocCmdMiscTest::testLengthBinary( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -length [ 01 02 03 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "3" , output ) );
}

931
tests/srd-preproc-cmd-strings.cc
View file

@ -1,931 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdStringsTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdStringsTest );
CPPUNIT_TEST( testConcatNoArgs );
CPPUNIT_TEST( testConcatBadArgs );
CPPUNIT_TEST( testConcatOneString );
CPPUNIT_TEST( testConcatStrings );
CPPUNIT_TEST( testConcatStringWord );
CPPUNIT_TEST( testConcatStringNumeric );
CPPUNIT_TEST( testConcatStringBinary );
CPPUNIT_TEST( testConcatOneBinary );
CPPUNIT_TEST( testConcatBinary );
CPPUNIT_TEST( testSubstrNotEnoughArgs );
CPPUNIT_TEST( testSubstrStringNotEnoughArgs );
CPPUNIT_TEST( testSubstrBinaryNotEnoughArgs );
CPPUNIT_TEST( testSubstrStringTooManyArgs );
CPPUNIT_TEST( testSubstrBinaryTooManyArgs );
CPPUNIT_TEST( testSubstrBadTooManyArgs );
CPPUNIT_TEST( testSubstrStringOffset );
CPPUNIT_TEST( testSubstrBinaryOffset );
CPPUNIT_TEST( testSubstrBadOffset );
CPPUNIT_TEST( testSubstrStringBad );
CPPUNIT_TEST( testSubstrStringInvalid );
CPPUNIT_TEST( testSubstrStringHigh );
CPPUNIT_TEST( testSubstrStringOffsetLength );
CPPUNIT_TEST( testSubstrBinaryOffsetLength );
CPPUNIT_TEST( testSubstrStringOffsetBad );
CPPUNIT_TEST( testSubstrStringOffsetToOffset );
CPPUNIT_TEST( testSubstrBinaryOffsetToOffset );
CPPUNIT_TEST( testSubstrStringRangeInverted );
CPPUNIT_TEST( testSubstrBinaryRangeInverted );
CPPUNIT_TEST( testSubstrStringOffsetBadOffset );
CPPUNIT_TEST( testSubstrStringOffsetToBad );
CPPUNIT_TEST( testSubstrRangeInvalidStart );
CPPUNIT_TEST( testSubstrRangeInvalidEnd );
CPPUNIT_TEST( testSplitNotEnoughArgs );
CPPUNIT_TEST( testSplitTooManyArgs );
CPPUNIT_TEST( testSplitBadString );
CPPUNIT_TEST( testSplitStringBad );
CPPUNIT_TEST( testSplitStringEmpty );
CPPUNIT_TEST( testSplitStringStringBad );
CPPUNIT_TEST( testSplitStringStringNegative );
CPPUNIT_TEST( testSplitSingleNormal );
CPPUNIT_TEST( testSplitSingleStart );
CPPUNIT_TEST( testSplitSingleEnd );
CPPUNIT_TEST( testSplitSingleNowhere );
CPPUNIT_TEST( testSplitMultiNormal );
CPPUNIT_TEST( testSplitMultiStart );
CPPUNIT_TEST( testSplitMultiEnd );
CPPUNIT_TEST( testSplitMultiNowhere );
CPPUNIT_TEST( testSplitMultiLonger );
CPPUNIT_TEST( testSplitLimitZero );
CPPUNIT_TEST( testSplitLimit );
CPPUNIT_TEST( testSplitLimitGreater );
CPPUNIT_TEST( testSWNotEnoughArgs );
CPPUNIT_TEST( testSWTooManyArgs );
CPPUNIT_TEST( testSWStringYes );
CPPUNIT_TEST( testSWStringYesEqual );
CPPUNIT_TEST( testSWStringYesEmpty );
CPPUNIT_TEST( testSWStringNoShorter );
CPPUNIT_TEST( testSWStringNoLonger );
CPPUNIT_TEST( testSWBinaryYes );
CPPUNIT_TEST( testSWBinaryYesEqual );
CPPUNIT_TEST( testSWBinaryYesEmpty );
CPPUNIT_TEST( testSWBinaryNoShorter );
CPPUNIT_TEST( testSWBinaryNoLonger );
CPPUNIT_TEST( testSWWordString );
CPPUNIT_TEST( testSWStringWord );
CPPUNIT_TEST( testSWStringBad );
CPPUNIT_TEST( testSWBadString );
CPPUNIT_TEST( testEWNotEnoughArgs );
CPPUNIT_TEST( testEWTooManyArgs );
CPPUNIT_TEST( testEWStringYes );
CPPUNIT_TEST( testEWStringYesEqual );
CPPUNIT_TEST( testEWStringYesEmpty );
CPPUNIT_TEST( testEWStringNoShorter );
CPPUNIT_TEST( testEWStringNoLonger );
CPPUNIT_TEST( testEWBinaryYes );
CPPUNIT_TEST( testEWBinaryYesEqual );
CPPUNIT_TEST( testEWBinaryYesEmpty );
CPPUNIT_TEST( testEWBinaryNoShorter );
CPPUNIT_TEST( testEWBinaryNoLonger );
CPPUNIT_TEST( testEWWordString );
CPPUNIT_TEST( testEWStringWord );
CPPUNIT_TEST( testEWStringBad );
CPPUNIT_TEST( testEWBadString );
CPPUNIT_TEST_SUITE_END( );
public:
// -concat
void testConcatNoArgs( );
void testConcatBadArgs( );
void testConcatOneString( );
void testConcatStrings( );
void testConcatStringWord( );
void testConcatStringNumeric( );
void testConcatStringBinary( );
void testConcatOneBinary( );
void testConcatBinary( );
// -substr
void testSubstrNotEnoughArgs( ); // Not enough arguments
void testSubstrStringNotEnoughArgs( ); // String
void testSubstrBinaryNotEnoughArgs( ); // Binary
void testSubstrStringTooManyArgs( ); // String + too many arguments
void testSubstrBinaryTooManyArgs( ); // Binary + too many arguments
void testSubstrBadTooManyArgs( ); // Invalid argument + too many arguments
void testSubstrStringOffset( ); // String and offset arguments
void testSubstrBinaryOffset( ); // Binary data and offset arguments
void testSubstrBadOffset( ); // Invalid argument + offset
void testSubstrStringBad( ); // String + invalid argument
void testSubstrStringInvalid( ); // String, offset < 0
void testSubstrStringHigh( ); // String, offset > length
void testSubstrStringOffsetLength( ); // String, offset and length arguments
void testSubstrBinaryOffsetLength( ); // Binary, offset and length arguments
void testSubstrStringOffsetBad( ); // String and offset followed by invalid argument
void testSubstrStringOffsetToOffset( ); // String, range mode
void testSubstrBinaryOffsetToOffset( ); // Binary, range mode
void testSubstrStringRangeInverted( ); // String, range mode, end < start
void testSubstrBinaryRangeInverted( ); // Binary, range mode, end < start
void testSubstrStringOffsetBadOffset( );
// String, range mode, wrong "to" argument
void testSubstrStringOffsetToBad( ); // String, range mode, wrong end argument
void testSubstrRangeInvalidStart( ); // String, range mode, start < 0
void testSubstrRangeInvalidEnd( ); // String, range mode, end < 0
// -str-split
void testSplitNotEnoughArgs( ); // Not enough arguments
void testSplitTooManyArgs( ); // Too many arguments
void testSplitBadString( ); // Invalid argument, string
void testSplitStringBad( ); // String, invalid argument
void testSplitStringEmpty( ); // String, empty string
void testSplitStringStringBad( ); // String, string, invalid argument
void testSplitStringStringNegative( ); // String, string, negative integer
void testSplitSingleNormal( ); // Single-character delimiter, inside string
void testSplitSingleStart( ); // Single-character delimiter, start of string
void testSplitSingleEnd( ); // Single-character delimiter, end of string
void testSplitSingleNowhere( ); // Single-character delimiter, not in string
void testSplitMultiNormal( ); // Multi-character delimiter, inside string
void testSplitMultiStart( ); // Multi-character delimiter, start of string
void testSplitMultiEnd( ); // Multi-character delimiter, end of string
void testSplitMultiNowhere( ); // Multi-character delimiter, not in string
void testSplitMultiLonger( ); // Multi-character delimiter, longer than string
void testSplitLimitZero( ); // With limit set to 0
void testSplitLimit( ); // With a non-zero limit
void testSplitLimitGreater( ); // With a limit higher than the result count
// -starts-with
void testSWNotEnoughArgs( );
void testSWTooManyArgs( );
void testSWStringYes( );
void testSWStringYesEqual( );
void testSWStringYesEmpty( );
void testSWStringNoShorter( );
void testSWStringNoLonger( );
void testSWBinaryYes( );
void testSWBinaryYesEqual( );
void testSWBinaryYesEmpty( );
void testSWBinaryNoShorter( );
void testSWBinaryNoLonger( );
void testSWWordString( );
void testSWStringWord( );
void testSWStringBad( );
void testSWBadString( );
// -ends-with
void testEWNotEnoughArgs( );
void testEWTooManyArgs( );
void testEWStringYes( );
void testEWStringYesEqual( );
void testEWStringYesEmpty( );
void testEWStringNoShorter( );
void testEWStringNoLonger( );
void testEWBinaryYes( );
void testEWBinaryYesEqual( );
void testEWBinaryYesEmpty( );
void testEWBinaryNoShorter( );
void testEWBinaryNoLonger( );
void testEWWordString( );
void testEWStringWord( );
void testEWStringBad( );
void testEWBadString( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdStringsTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdStringsTest::testConcatNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatBadArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat ( nope ) [ 01 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array, text or numeric argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "[ 01 ]" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatOneString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat \"string\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "\"string\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatStrings( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat \"str\" \"ing\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "\"string\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatStringWord( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat \"str\" ing )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "\"string\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatStringNumeric( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat \"i\" 2 \"l\" ( -to-long 2 ) \"f\" 1.2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "\"i2l2f1.2\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatStringBinary( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat \"string\"\n[ 01 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text or numeric argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 1 );
CPPUNIT_ASSERT( check( "\"string\"" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatOneBinary( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat [ ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "[ ]" , output ) );
}
void SRDPreprocCmdStringsTest::testConcatBinary( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -concat [ 01 ] [] [ 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "[ 01 02 ]" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdStringsTest::testSubstrNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 33 );
CPPUNIT_ASSERT( check( "[]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 1 to 2 blah )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 27 );
CPPUNIT_ASSERT( check( "\"bc\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] 1 to 2 blah )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 40 );
CPPUNIT_ASSERT( check( "[]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBadTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr -12 1 to 2 blah )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array or text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"def\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "[ 04 05 06 ]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBadOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr 12 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array or text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 11 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"\" \"\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringInvalid( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" -1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringHigh( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 7 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffsetLength( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"cde\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryOffsetLength( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] 2 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "[ 03 04 05 ]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffsetBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 nope )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "'to' or integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 22 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffsetToOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 to 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"cd\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryOffsetToOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] 2 to 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "[ 03 04 ]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringRangeInverted( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 3 to 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrBinaryRangeInverted( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr [ 01 02 03 04 05 06 ] 3 to 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "[ ]" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffsetBadOffset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 ot 3 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "'to' or integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 22 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrStringOffsetToBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 to meh )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 25 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrRangeInvalidStart( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" -2 to 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSubstrRangeInvalidEnd( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -substr \"abcdef\" 2 to -2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 25 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdStringsTest::testSplitNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"x\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 18 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"b\" 12 a b c )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 25 );
CPPUNIT_ASSERT( check( "\"b\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitBadString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split 12 \"x\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitStringBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"x\" 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 18 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitStringEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"\" \"...\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "\"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitStringStringBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"...\" x )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "integer argument or end of list expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 24 );
CPPUNIT_ASSERT( check( "\"...\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitStringStringNegative( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"bab\" -1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "invalid argument value" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 24 );
CPPUNIT_ASSERT( check( "\"b\" \"b\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitSingleNormal( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"babaab\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"b\" \"b\" \"\" \"b\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitSingleStart( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"ab\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"\" \"b\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitSingleEnd( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"ba\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"b\" \"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitSingleNowhere( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"a\" \"nope\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"nope\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitMultiNormal( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"aba\" \"babaxabaababa\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"b\" \"x\" \"\" \"ba\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitMultiStart( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"aba\" \"abab\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"\" \"b\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitMultiEnd( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"aba\" \"baba\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"b\" \"\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitMultiNowhere( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"aba\" \"nope\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"nope\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitMultiLonger( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"moomoo\" \"nope\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"nope\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitLimitZero( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"x\" \"abababa\" 0 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"abababa\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitLimit( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"b\" \"abababa\" 2 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"a\" \"a\" \"aba\"" , output ) );
}
void SRDPreprocCmdStringsTest::testSplitLimitGreater( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -str-split \"b\" \"abababa\" 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "\"a\" \"a\" \"a\" \"a\"" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdStringsTest::testSWNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"x\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with x y z )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringYes( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"abc\" \"abcdef\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringYesEqual( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"abc\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringYesEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringNoShorter( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"abc\" \"defg\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringNoLonger( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"defg\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBinaryYes( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with [ 00 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBinaryYesEqual( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with [ 00 01 02 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBinaryYesEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with [ ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBinaryNoShorter( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with [ 01 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBinaryNoLonger( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with [ 00 01 02 ] [ 00 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWWordString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with abc \"abc d\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringWord( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"abc\" abc-d )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testSWStringBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with \"abc\" 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 22 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testSWBadString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -starts-with 12 \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array or text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdStringsTest::testEWNotEnoughArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"x\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 18 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWTooManyArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with x y z )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 18 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringYes( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"def\" \"abcdef\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringYesEqual( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"abc\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringYesEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringNoShorter( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"abc\" \"defg\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringNoLonger( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"defg\" \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBinaryYes( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with [ 02 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBinaryYesEqual( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with [ 00 01 02 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBinaryYesEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with [ ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBinaryNoShorter( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with [ 01 ] [ 00 01 02 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBinaryNoLonger( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with [ 00 01 02 ] [ 00 ] )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWWordString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with d \"abc d\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringWord( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"c-d\" abc-d )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdStringsTest::testEWStringBad( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with \"abc\" 12 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
CPPUNIT_ASSERT( check( "0" , output ) );
}
void SRDPreprocCmdStringsTest::testEWBadString( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -ends-with 12 \"abc\" )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "binary array or text argument expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
CPPUNIT_ASSERT( check( "0" , output ) );
}

372
tests/srd-preproc-cmd-variables.cc
View file

@ -1,372 +0,0 @@
#include "srd-preproc-cmd-common.hh"
class SRDPreprocCmdVariablesTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCmdVariablesTest );
CPPUNIT_TEST( testSetVarNoArgs );
CPPUNIT_TEST( testSetVarBadName );
CPPUNIT_TEST( testSetVarEmpty );
CPPUNIT_TEST( testSetVarBasic );
CPPUNIT_TEST( testSetVarList );
CPPUNIT_TEST( testSetVarExisting );
CPPUNIT_TEST( testSetVarsNoNames );
CPPUNIT_TEST( testSetVarsBadName );
CPPUNIT_TEST( testSetVarsEmpty );
CPPUNIT_TEST( testSetVarsMissing );
CPPUNIT_TEST( testSetVarsMultiple );
CPPUNIT_TEST( testSetVarsRest );
CPPUNIT_TEST( testSetVarsRepeatName );
CPPUNIT_TEST( testSetVarsExisting );
CPPUNIT_TEST( testSetVarsExistingAndRepeated );
CPPUNIT_TEST( testUnsetNoArgs );
CPPUNIT_TEST( testUnset );
CPPUNIT_TEST( testUnsetMissing );
CPPUNIT_TEST( testUnsetMultiple );
CPPUNIT_TEST( testUnsetFromVarBeingUnset );
CPPUNIT_TEST( testGetEmpty );
CPPUNIT_TEST( testGetBadArg );
CPPUNIT_TEST( testGetMissing );
CPPUNIT_TEST( testGetVar );
CPPUNIT_TEST( testGetVars );
CPPUNIT_TEST( testGetVarsWithErrors );
CPPUNIT_TEST( testListVariables );
CPPUNIT_TEST( testListVariablesArgs );
CPPUNIT_TEST_SUITE_END( );
public:
void testSetVarNoArgs( );
void testSetVarBadName( );
void testSetVarEmpty( );
void testSetVarBasic( );
void testSetVarList( );
void testSetVarExisting( );
void testSetVarsNoNames( );
void testSetVarsBadName( );
void testSetVarsEmpty( );
void testSetVarsMissing( );
void testSetVarsMultiple( );
void testSetVarsRest( );
void testSetVarsRepeatName( );
void testSetVarsExisting( );
void testSetVarsExistingAndRepeated( );
void testUnsetNoArgs( );
void testUnset( );
void testUnsetMissing( );
void testUnsetMultiple( );
void testUnsetFromVarBeingUnset( );
void testGetEmpty( );
void testGetBadArg( );
void testGetMissing( );
void testGetVar( );
void testGetVars( );
void testGetVarsWithErrors( );
void testListVariables( );
void testListVariablesArgs( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdVariablesTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdVariablesTest::testSetVarNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "not enough arguments" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarBadName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set 1 )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "word or list expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set x )\n$x" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarBasic( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set x y )\n$x" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "y" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarList( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set x y z )\n$x" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "y z" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarExisting( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set x a )\n$x\n( -set x b )\n$x" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "duplicate variable name" , 3 , 3 );
M_CKERR_( 1 , "previous error cause" , 3 , 8 );
CPPUNIT_ASSERT( check( "a a" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdVariablesTest::testSetVarsNoNames( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "no variable names" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsBadName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( 1 ( ) ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
M_CKERR_( 2 , "word expected" , 1 , 3 );
M_CKERR_( 3 , "previous error cause" , 1 , 12 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( a b ) )\n( $b ) ( $a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "()()" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsMissing( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( a b ) a )\n( $b ) ( $a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( ) ( a )" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( a b ) a b )\n( $b ) ( $a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( b ) ( a )" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsRest( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( a b ) a b c )\n( $b ) ( $a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( b c ) ( a )" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsRepeatName( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set ( a a ) a b c )\n( $a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 3u , errors.size( ) );
M_CKERR_( 0 , "duplicate variable name" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 10 );
M_CKERR_( 2 , "unknown variable" , 2 , 3 );
CPPUNIT_ASSERT( check( "( )" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsExisting( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set b x )\n( -set ( a b ) u v )\n( $a )( $b )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 3u , errors.size( ) );
M_CKERR_( 0 , "duplicate variable name" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 12 );
M_CKERR_( 2 , "unknown variable" , 3 , 3 );
CPPUNIT_ASSERT( check( "( )( x )" , output ) );
}
void SRDPreprocCmdVariablesTest::testSetVarsExistingAndRepeated( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set b x )\n( -set ( a b b a ) u v )\n( $a )( $b )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 5u , errors.size( ) );
M_CKERR_( 0 , "duplicate variable name" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
M_CKERR_( 2 , "duplicate variable name" , 2 , 3 );
M_CKERR_( 3 , "previous error cause" , 2 , 12 );
M_CKERR_( 4 , "unknown variable" , 3 , 3 );
CPPUNIT_ASSERT( check( "( )( x )" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdVariablesTest::testUnsetNoArgs( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unset ) " , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testUnset( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -set a 1 )\n$a\n( -unset a )\n$a" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 4 , 1 );
CPPUNIT_ASSERT( check( "1" , output ) );
}
void SRDPreprocCmdVariablesTest::testUnsetMissing( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -unset a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testUnsetMultiple( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set ( a b c ) 1 2 3)\n"
"( -unset a c )\n"
"( $a $b $c )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 3 , 3 );
M_CKERR_( 1 , "unknown variable" , 3 , 9 );
CPPUNIT_ASSERT( check( "( 2 )" , output ) );
}
void SRDPreprocCmdVariablesTest::testUnsetFromVarBeingUnset( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set ( c b a ) d c a b)\n"
"( -unset $a $b )\n"
"( $a $b $c )" ,
errors ) );
CPPUNIT_ASSERT_EQUAL( 3u , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 2 , 13 );
M_CKERR_( 1 , "unknown variable" , 3 , 3 );
M_CKERR_( 2 , "unknown variable" , 3 , 6 );
CPPUNIT_ASSERT( check( "( d )" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdVariablesTest::testGetEmpty( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -get )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testGetBadArg( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -get 1 ( ) )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 4u , errors.size( ) );
M_CKERR_( 0 , "word expected" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
M_CKERR_( 2 , "word expected" , 1 , 3 );
M_CKERR_( 3 , "previous error cause" , 1 , 10 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testGetMissing( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -get a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 1 , 3 );
M_CKERR_( 1 , "previous error cause" , 1 , 8 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCmdVariablesTest::testGetVar( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set a x)\n( -get a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "x" , output ) );
}
void SRDPreprocCmdVariablesTest::testGetVars( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set ( a b c ) x y z w )\n( -get c b a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "z w y x" , output ) );
}
void SRDPreprocCmdVariablesTest::testGetVarsWithErrors( )
{
T_SRDErrors errors;
T_SRDList output( process( "(-set ( a b ) x y )\n( -get b c a )" , errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 10 );
CPPUNIT_ASSERT( check( "y x" , output ) );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCmdVariablesTest::testListVariables( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set x )\n"
"( -set-macro y ( ( ) ) )\n"
"( -set f (-raw (() ((-ls-variables))) ))\n"
"( -bless f )\n"
"( ( -ls-variables ) )\n"
"( -scope\n"
"( -unset x )\n"
"( ( -ls-variables ) )\n"
")\n"
"($f)\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "( x f ) ( f ) ( f )" , output ) );
}
void SRDPreprocCmdVariablesTest::testListVariablesArgs( )
{
T_SRDErrors errors;
T_SRDList output( process(
"( -set x )\n"
"( -ls-variables blah )\n"
, errors ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "too many arguments" , 2 , 3 );
M_CKERR_( 1 , "previous error cause" , 2 , 17 );
CPPUNIT_ASSERT( check( "x" , output ) );
}

245
tests/srd-preproc-core.cc
View file

@ -1,245 +0,0 @@
#include <lw/lib/SRDPreproc.hh>
#include <lw/lib/SRDText.hh>
#include <lw/lib/SRDIO.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
class SRDPreprocCoreTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocCoreTest );
CPPUNIT_TEST( testEmptyInput );
CPPUNIT_TEST( testBasicInput );
CPPUNIT_TEST( testCommentsSkipped );
CPPUNIT_TEST( testCommandWordInInput );
CPPUNIT_TEST( testBadCommand );
CPPUNIT_TEST( testBadVariable );
CPPUNIT_TEST( testUnterminatedLists );
CPPUNIT_TEST( testTooManyErrorsInside );
CPPUNIT_TEST( testTooManyErrorsAtEnd );
CPPUNIT_TEST_SUITE_END( );
public:
void testEmptyInput( );
void testBasicInput( );
void testCommentsSkipped( );
void testCommandWordInInput( );
void testBadCommand( );
void testBadVariable( );
void testUnterminatedLists( );
void testTooManyErrorsInside( );
void testTooManyErrorsAtEnd( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCoreTest );
/*----------------------------------------------------------------------------*/
// M_PRINTERR_( index ) - Print an error message
#define M_PRINTERR_( IDX ) \
do { \
auto const& _e( errors[ IDX ] ); \
char err[ _e.error( ).size( ) + 1 ]; \
err[ sizeof( err ) - 1 ] = 0; \
memcpy( err , _e.error( ).data( ) , \
sizeof( err ) - 1 ); \
printf( "ERR %s l. %u c. %lu\n" , err , \
_e.location( ).line( ) , \
_e.location( ).character( ) ); \
} while ( 0 )
// M_CKERR_( index , string , line , character ) - Check an error
#define M_CKERR_( IDX , STR , L , C ) \
do { \
auto const& _e( errors[ IDX ] ); \
CPPUNIT_ASSERT( T_String( STR ) == _e.error( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( L ) , \
_e.location( ).line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( C ) , \
_e.location( ).character( ) ); \
} while ( 0 )
namespace {
T_SRDList process(
char const* const input ,
T_SRDErrors& errors ,
const bool clearFlushToken = true )
{
T_SRDMemoryTarget mt( false );
mt.clearFlushToken( clearFlushToken );
mt.start( errors );
T_SRDPreprocessorConfig cmd;
cmd.addBuiltinCommands( );
T_SRDPreprocessor pp( cmd , mt );
T_SRDLexer lexer( T_String( "test" ) , errors , pp );
pp.start( errors );
char const* ptr = input;
while ( *ptr != 0 ) {
lexer.processCharacter( *ptr ++ );
}
lexer.processEnd( );
mt.end( errors );
return mt.list( );
}
bool checkMatch( T_SRDList const& expected , T_SRDList const& actual )
{
const uint32_t nExpected( expected.size( ) );
const uint32_t nActual( actual.size( ) );
bool ok( nExpected == nActual );
const uint32_t nCheck( std::min( nExpected , nActual ) );
for ( uint32_t i = 0 ; i < nCheck ; i ++ ) {
T_SRDToken const& tExpected( expected[ i ] );
T_SRDToken const& tActual( actual[ i ] );
if ( tExpected.type( ) != tActual.type( ) ) {
std::cerr << "Expected token at "
<< tExpected.location( ).line( ) << ":"
<< tExpected.location( ).character( )
<< " has type " << int( tExpected.type( ) ) << "; actual token has type "
<< int( tActual.type( ) ) << "\n";
ok = false;
} else if ( tExpected.stringValue( ) != tActual.stringValue( ) ) {
std::cerr << "Expected token at "
<< tExpected.location( ).line( ) << ":"
<< tExpected.location( ).character( )
<< " has different text\n";
ok = false;
}
}
if ( nExpected != nActual ) {
std::cerr << "List size mismatch (" << nExpected << " expected, "
<< nActual << " found)\n";
}
return ok;
}
bool check( char const* expected , T_SRDList const& actual )
{
T_SRDMemoryTarget mt( false );
T_SRDErrors errors;
T_SRDLexer lexer( T_String( "expected" ) , errors , mt );
mt.start( errors );
char const* ptr = expected;
while ( *ptr != 0 ) {
lexer.processCharacter( *ptr ++ );
}
lexer.processEnd( );
return checkMatch( mt.list( ) , actual );
}
}
/*----------------------------------------------------------------------------*/
void SRDPreprocCoreTest::testEmptyInput( )
{
T_SRDErrors errors;
T_SRDList output( process( "" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCoreTest::testBasicInput( )
{
T_SRDErrors errors;
T_SRDList output( process( "this is a simple test 123 \"yes\" ( a test )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "this is a simple test 123 \"yes\" ( a test )" , output ) );
}
void SRDPreprocCoreTest::testCommentsSkipped( )
{
T_SRDErrors errors;
T_SRDList output( process( "a {comment!} ( is #skipped!\n)" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "a ( is )" , output ) );
}
void SRDPreprocCoreTest::testCommandWordInInput( )
{
T_SRDErrors errors;
T_SRDList output( process( "-blah" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
CPPUNIT_ASSERT( check( "-blah" , output ) );
}
void SRDPreprocCoreTest::testBadCommand( )
{
T_SRDErrors errors;
T_SRDList output( process( "( -blah )" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unknown command" , 1 , 3 );
CPPUNIT_ASSERT( check( "( -blah )" , output ) );
}
void SRDPreprocCoreTest::testBadVariable( )
{
T_SRDErrors errors;
T_SRDList output( process( "$blah does not exist" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , errors.size( ) );
M_CKERR_( 0 , "unknown variable" , 1 , 1 );
CPPUNIT_ASSERT( check( "does not exist" , output ) );
}
void SRDPreprocCoreTest::testUnterminatedLists( )
{
T_SRDErrors errors;
T_SRDList output( process( "( ( ) ( (" , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , errors.size( ) );
M_CKERR_( 0 , "unterminated list" , 1 , 1 );
M_CKERR_( 1 , "unterminated list" , 1 , 7 );
M_CKERR_( 2 , "unterminated list" , 1 , 9 );
CPPUNIT_ASSERT( check( "( ( ) ( ( ) ) )" , output ) );
}
namespace {
T_StringBuilder RepeatError_( char const* string )
{
T_StringBuilder sb;
for ( uint32_t i = 0 ; i < T_SRDErrors::MAX_ERRORS * 2 ; i ++ ) {
if ( i > 0 ) {
sb << ' ';
}
sb << string;
}
sb << " x" << '\0';
return sb;
}
}
void SRDPreprocCoreTest::testTooManyErrorsInside( )
{
T_StringBuilder input( RepeatError_( "$x" ) );
T_SRDErrors errors;
T_SRDList output( process( input.data( ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( T_SRDErrors::MAX_ERRORS + 1 ) , errors.size( ) );
M_CKERR_( T_SRDErrors::MAX_ERRORS , "too many errors" , 1 , T_SRDErrors::MAX_ERRORS * 3 - 2 );
CPPUNIT_ASSERT( check( "" , output ) );
}
void SRDPreprocCoreTest::testTooManyErrorsAtEnd( )
{
T_StringBuilder input( RepeatError_( "(" ) );
T_StringBuilder expectedOutput;
for ( uint32_t i = 0 ; i < T_SRDErrors::MAX_ERRORS * 2 ; i ++ ) {
expectedOutput << '(';
}
expectedOutput << 'x';
for ( uint32_t i = 0 ; i < T_SRDErrors::MAX_ERRORS * 2 ; i ++ ) {
expectedOutput << ')';
}
expectedOutput << '\0';
T_SRDErrors errors;
T_SRDList output( process( input.data( ) , errors ) );
CPPUNIT_ASSERT_EQUAL( uint32_t( T_SRDErrors::MAX_ERRORS + 1 ) , errors.size( ) );
M_CKERR_( T_SRDErrors::MAX_ERRORS , "too many errors" , 1 , T_SRDErrors::MAX_ERRORS * 2 - 1 );
CPPUNIT_ASSERT( check( expectedOutput.data( ) , output ) );
}

133
tests/srd-preproc-location.hh
View file

@ -1,133 +0,0 @@
#ifndef TESTS_SRDPREPROCLOCATION_H_
#define TESTS_SRDPREPROCLOCATION_H_
#include <lw/lib/SRDPreproc.hh>
#include <lw/lib/SRDText.hh>
#include <lw/lib/SRDIO.hh>
#include <lw/lib/MemoryStreams.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
namespace {
inline T_SRDLocationChaining const* NextChain_(
T_SRDLocation const* from ) noexcept
{
return (from && from->isChained( ) ) ? &from->chaining( ) : nullptr;
}
uint32_t LocationDepth_(
const RPC_SRDLocation location ) noexcept
{
uint32_t depth( 0 );
auto lc( NextChain_( location ) );
while ( lc ) {
depth ++;
lc = NextChain_( RPC_SRDLocation( lc->location ) );
}
return depth;
}
uint32_t ErrorDepth_(
T_SRDErrors const& errors ,
const size_t index ) noexcept
{
auto const& error( errors[ index ] );
return LocationDepth_( &error.location( ) );
}
uint32_t TokenDepth_(
T_SRDList const& tokens ,
const size_t index ) noexcept
{
auto const& tok( tokens[ index ] );
assert( tok.hasLocation( ) );
return LocationDepth_( &tok.location( ) );
}
T_SRDLocationChaining const& GetChain_(
RPC_SRDLocation const& top ,
uint32_t depth ) noexcept
{
auto lc( NextChain_( top ) );
assert( lc );
while ( depth ) {
depth --;
lc = NextChain_( RPC_SRDLocation( lc->location ) );
assert( lc );
}
return *lc;
}
void PrintLoc_( RPC_SRDLocation location ) noexcept
{
printf( "at %s, l. %d c. %lu\n" , location->source( ).toOSString( ).data( ) ,
location->line( ) , location->character( ) );
if ( location->isChained( ) ) {
auto const& chain( location->chaining( ) );
printf( "\tChain type %d, depth %d, " ,
int( chain.circumstances ) , chain.depth );
PrintLoc_( RPC_SRDLocation( chain.location ) );
}
}
}
#define M_CKTOKDEPTH_( IDX , DEPTH ) \
CPPUNIT_ASSERT_EQUAL( uint32_t( DEPTH ) , TokenDepth_( output , IDX ) )
#define M_CKTOKLOC_( IDX , NAME , LINE , CHAR ) \
do { \
auto const& loc( output[ IDX ].location( ) ); \
CPPUNIT_ASSERT( T_String{ NAME } == loc.source( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( LINE ) , loc.line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( CHAR ) , loc.character( ) ); \
} while ( 0 )
#define M_CKTOKFULL_( IDX , NAME , LINE , CHAR , DEPTH ) \
do { \
auto const& loc( output[ IDX ].location( ) ); \
CPPUNIT_ASSERT( T_String{ NAME } == loc.source( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( LINE ) , loc.line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( CHAR ) , loc.character( ) ); \
M_CKTOKDEPTH_( IDX , DEPTH ); \
} while ( 0 )
#define M_CKTOKCHAIN_( IDX , DEPTH , HOW , NAME , LINE , CHAR , REC ) \
do { \
auto const& chain( GetChain_( &output[ IDX ].location( ) , DEPTH ) ); \
CPPUNIT_ASSERT( E_SRDLocationChaining::HOW == chain.circumstances ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( REC ) , chain.depth ); \
CPPUNIT_ASSERT( T_String{ NAME } == chain.location->source( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( LINE ) , chain.location->line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( CHAR ) , chain.location->character( ) ); \
} while ( 0 )
#define M_CKERRDEPTH_( IDX , DEPTH ) \
CPPUNIT_ASSERT_EQUAL( uint32_t( DEPTH ) , ErrorDepth_( errors , IDX ) )
#define M_CKERRFULL_( IDX , TEXT , DETAILS , NAME , LINE , CHAR , DEPTH ) \
do { \
CPPUNIT_ASSERT( T_String{ TEXT } == errors[ IDX ].error( ) ); \
CPPUNIT_ASSERT_EQUAL( bool( DETAILS ) , errors[ IDX ].isDetails( ) ); \
auto const& loc( errors[ IDX ].location( ) ); \
CPPUNIT_ASSERT( T_String{ NAME } == loc.source( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( LINE ) , loc.line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( CHAR ) , loc.character( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( DEPTH ) , ErrorDepth_( errors , IDX ) ); \
} while ( 0 )
#define M_CKERRCHAIN_( IDX , DEPTH , HOW , NAME , LINE , CHAR , REC ) \
do { \
auto const& chain( GetChain_( &errors[ IDX ].location( ) , DEPTH ) ); \
CPPUNIT_ASSERT( E_SRDLocationChaining::HOW == chain.circumstances ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( REC ) , chain.depth ); \
CPPUNIT_ASSERT( T_String{ NAME } == chain.location->source( ) ); \
CPPUNIT_ASSERT_EQUAL( uint32_t( LINE ) , chain.location->line( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( CHAR ) , chain.location->character( ) ); \
} while ( 0 )
#endif // TESTS_SRDPREPROCLOCATION_H_

676
tests/srd-preproc-tracking.cc
View file

@ -1,676 +0,0 @@
#include "srd-preproc-cmd-common.hh"
#include "srd-preproc-location.hh"
using namespace lw;
class SRDPreprocTrackingTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SRDPreprocTrackingTest );
CPPUNIT_TEST( testTopLevel );
CPPUNIT_TEST( testVar );
CPPUNIT_TEST( testVarGet );
CPPUNIT_TEST( testCall );
CPPUNIT_TEST( testCalls );
CPPUNIT_TEST( testCallRecursive );
CPPUNIT_TEST( testEval );
CPPUNIT_TEST( testEvalCalls );
CPPUNIT_TEST( testCommandOutput );
#if 0
CPPUNIT_TEST( testMacroBody );
CPPUNIT_TEST( testMacroBodyCall );
CPPUNIT_TEST( testMacroBodyEval );
CPPUNIT_TEST( testCallMacroBody );
CPPUNIT_TEST( testEvalMacroBody );
CPPUNIT_TEST( testMacroOutput );
CPPUNIT_TEST( testMacroOutputCall );
CPPUNIT_TEST( testMacroOutputEval );
CPPUNIT_TEST( testCallMacroOutput );
CPPUNIT_TEST( testEvalMacroOutput );
#endif
// CPPUNIT_TEST( testErrorTopLevel );
#if 0
CPPUNIT_TEST( testErrorCall );
#endif
CPPUNIT_TEST_SUITE_END( );
public:
void testTopLevel( );
void testVar( );
void testVarGet( );
void testCall( );
void testCalls( );
void testCallRecursive( );
void testEval( );
void testEvalCalls( );
void testCommandOutput( );
#if 0
void testMacroBody( );
void testMacroBodyCall( );
void testMacroBodyEval( );
void testCallMacroBody( );
void testEvalMacroBody( );
void testMacroOutput( );
void testMacroOutputCall( );
void testMacroOutputEval( );
void testCallMacroOutput( );
void testEvalMacroOutput( );
#endif
void testErrorTopLevel( );
#if 0
void testErrorCall( );
#endif
};
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocTrackingTest );
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testTopLevel( )
{
T_SRDErrors errors;
T_SRDList output( process(
"a\n"
"(-scope b)\n"
, errors ) );
CPPUNIT_ASSERT( check( "a b" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 0 );
M_CKTOKLOC_( 0 , "test" , 1 , 1 );
M_CKTOKDEPTH_( 1 , 0 );
M_CKTOKLOC_( 1 , "test" , 2 , 9 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testVar( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set var value)\n"
"$var\n"
, errors ) );
CPPUNIT_ASSERT( check( "value" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "$var" , 0 , 0 );
M_CKTOKCHAIN_( 0 , 0 , SUBSTITUTED , "test" , 2 , 1 , 0 );
}
void SRDPreprocTrackingTest::testVarGet( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set (var vn) value var)\n"
"(-get var $vn)\n"
, errors ) );
CPPUNIT_ASSERT( check( "value value" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "$var" , 0 , 0 );
M_CKTOKCHAIN_( 0 , 0 , SUBSTITUTED , "test" , 2 , 2 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "$var" , 0 , 0 );
M_CKTOKCHAIN_( 1 , 0 , SUBSTITUTED , "test" , 2 , 2 , 0 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testCall( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( () b )))\n"
"(-bless fn)\n"
"a ($fn)\n"
, errors ) );
CPPUNIT_ASSERT( check( "a b" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 0 );
M_CKTOKLOC_( 0 , "test" , 3 , 1 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "test" , 1 , 21 );
M_CKTOKCHAIN_( 1 , 0 , CALLED , "test" , 3 , 4 , 0 );
}
void SRDPreprocTrackingTest::testCalls( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set ( fn1 fn2 ) (-raw\n"
"((d)\n"
"I ($fn2 $d) )\n"
"((d)\n"
"got $d)\n"
"))\n"
"(-bless fn1 fn2)\n"
"($fn1 it)\n"
, errors ) );
CPPUNIT_ASSERT( check( "I got it" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test" , 3 , 1 );
M_CKTOKCHAIN_( 0 , 0 , CALLED , "test" , 8 , 2 , 0 );
M_CKTOKDEPTH_( 1 , 2 );
M_CKTOKLOC_( 1 , "test" , 5 , 1 );
M_CKTOKCHAIN_( 1 , 0 , CALLED , "test" , 3 , 4 , 0 );
M_CKTOKCHAIN_( 1 , 1 , CALLED , "test" , 8 , 2 , 0 );
M_CKTOKDEPTH_( 2 , 3 );
M_CKTOKLOC_( 2 , "$d" , 0 , 0 );
M_CKTOKCHAIN_( 2 , 0 , SUBSTITUTED , "test" , 5 , 5 , 0 );
M_CKTOKCHAIN_( 2 , 1 , CALLED , "test" , 3 , 4 , 0 );
M_CKTOKCHAIN_( 2 , 2 , CALLED , "test" , 8 , 2 , 0 );
}
void SRDPreprocTrackingTest::testCallRecursive( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( (d)\n"
"$d\n"
"(-if (-gt $d 0) (\n"
"($fn (-sub $d 1))\n"
")))))\n"
"(-bless fn)\n"
"($fn 6)\n"
, errors ) );
CPPUNIT_ASSERT( check( "6 5 4 3 2 1 0" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 2 );
M_CKTOKCHAIN_( 0 , 0 , SUBSTITUTED , "test" , 2 , 1 , 0 );
M_CKTOKCHAIN_( 0 , 1 , CALLED , "test" , 7 , 2 , 0 );
for ( auto i = 1u ; i < 7 ; i ++ ) {
M_CKTOKDEPTH_( i , 3 );
M_CKTOKCHAIN_( i , 0 , SUBSTITUTED , "test" , 2 , 1 , 0 );
M_CKTOKCHAIN_( i , 1 , CALLED , "test" , 4 , 2 , i - 1 );
M_CKTOKCHAIN_( i , 2 , CALLED , "test" , 7 , 2 , 0 );
}
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testEval( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set (x y f)\n"
"(-raw $y)\n"
"x\n"
"(() (-raw a (-raw $y) b))\n"
")\n"
"(-bless f)\n"
"(-eval x $y $x ($f))\n"
, errors ) );
CPPUNIT_ASSERT( check( "x x x a x b" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 0 );
M_CKTOKLOC_( 0 , "test" , 7 , 8 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "$y" , 0 , 0 );
M_CKTOKCHAIN_( 1 , 0 , SUBSTITUTED , "test" , 7 , 10 , 0 );
M_CKTOKDEPTH_( 2 , 2 );
M_CKTOKLOC_( 2 , "$y" , 0 , 0 );
M_CKTOKCHAIN_( 2 , 0 , SUBSTITUTED , "$x" , 0 , 0 , 0 );
M_CKTOKCHAIN_( 2 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 3 , 1 );
M_CKTOKLOC_( 3 , "test" , 4 , 11 );
M_CKTOKCHAIN_( 3 , 0 , CALLED , "test" , 7 , 17 , 0 );
M_CKTOKDEPTH_( 4 , 2 );
M_CKTOKLOC_( 4 , "$y" , 0 , 0 );
M_CKTOKCHAIN_( 4 , 0 , SUBSTITUTED , "test" , 4 , 19 , 0 );
M_CKTOKCHAIN_( 4 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 5 , 1 );
M_CKTOKLOC_( 5 , "test" , 4 , 23 );
M_CKTOKCHAIN_( 5 , 0 , CALLED , "test" , 7 , 17 , 0 );
}
void SRDPreprocTrackingTest::testEvalCalls( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set (x y f)\n"
"(-raw ($f 2))\n"
"(-raw $x)\n"
"(-raw ((x) a $x b))\n"
")\n"
"(-bless f)\n"
"(-eval ($f 1) $x $y $x)\n"
, errors ) );
#if 0
printf( "\n\n" );
for ( auto i = 0u ; i < output.size( ) ; i ++ ) {
PrintLoc_( &output[ i ].location( ) );
printf( "\n" );
}
#endif
CPPUNIT_ASSERT( check( "a 1 b a 2 b ($f 2) a 2 b" , output ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "test" , 4 , 12 );
M_CKTOKCHAIN_( 0 , 0 , CALLED , "test" , 7 , 9 , 0 );
M_CKTOKDEPTH_( 1 , 2 );
M_CKTOKLOC_( 1 , "$x" , 0 , 0 );
M_CKTOKCHAIN_( 1 , 0 , SUBSTITUTED , "test" , 4 , 14 , 0 );
M_CKTOKCHAIN_( 1 , 1 , CALLED , "test" , 7 , 9 , 0 );
M_CKTOKDEPTH_( 2 , 1 );
M_CKTOKLOC_( 2 , "test" , 4 , 17 );
M_CKTOKCHAIN_( 2 , 0 , CALLED , "test" , 7 , 9 , 0 );
M_CKTOKDEPTH_( 3 , 2 );
M_CKTOKLOC_( 3 , "test" , 4 , 12 );
M_CKTOKCHAIN_( 3 , 0 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 3 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 4 , 3 );
M_CKTOKLOC_( 4 , "$x" , 0 , 0 );
M_CKTOKCHAIN_( 4 , 0 , SUBSTITUTED , "test" , 4 , 14 , 0 );
M_CKTOKCHAIN_( 4 , 1 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 4 , 2 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 5 , 2 );
M_CKTOKLOC_( 5 , "test" , 4 , 17 );
M_CKTOKCHAIN_( 5 , 0 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 5 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
for ( auto i = 0u ; i < 4 ; i ++ ) {
M_CKTOKDEPTH_( i + 6 , 2 );
M_CKTOKLOC_( i + 6 , "$x" , 0 , i );
M_CKTOKCHAIN_( i + 6 , 0 , SUBSTITUTED , "$y" , 0 , 0 , 0 );
M_CKTOKCHAIN_( i + 6 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
}
M_CKTOKDEPTH_( 10 , 2 );
M_CKTOKLOC_( 10 , "test" , 4 , 12 );
M_CKTOKCHAIN_( 10 , 0 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 10 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 11 , 3 );
M_CKTOKLOC_( 11 , "$x" , 0 , 0 );
M_CKTOKCHAIN_( 11 , 0 , SUBSTITUTED , "test" , 4 , 14 , 0 );
M_CKTOKCHAIN_( 11 , 1 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 11 , 2 , EVALUATED , "test" , 7 , 2 , 0 );
M_CKTOKDEPTH_( 12 , 2 );
M_CKTOKLOC_( 12 , "test" , 4 , 17 );
M_CKTOKCHAIN_( 12 , 0 , CALLED , "$x" , 0 , 1 , 0 );
M_CKTOKCHAIN_( 12 , 1 , EVALUATED , "test" , 7 , 2 , 0 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testCommandOutput( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-add 1 2)\n"
"(-is-set x)\n"
"(-type-of w)\n"
"(-eq a b)\n"
"(-to-string x \"x\")\n"
"(-length abcdef)\n"
, errors ) );
CPPUNIT_ASSERT( check( "3 0 word 0 \"x\" \"x\" 6" , output ) );
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
M_CKTOKDEPTH_( 0 , 1 );
M_CKTOKLOC_( 0 , "-add" , 0 , 0 );
M_CKTOKCHAIN_( 0 , 0 , GENERATED , "test" , 1 , 2 , 0 );
M_CKTOKDEPTH_( 1 , 1 );
M_CKTOKLOC_( 1 , "-is-set" , 0 , 0 );
M_CKTOKCHAIN_( 1 , 0 , GENERATED , "test" , 2 , 2 , 0 );
M_CKTOKDEPTH_( 2 , 1 );
M_CKTOKLOC_( 2 , "-type-of" , 0 , 0 );
M_CKTOKCHAIN_( 2 , 0 , GENERATED , "test" , 3 , 2 , 0 );
M_CKTOKDEPTH_( 3 , 1 );
M_CKTOKLOC_( 3 , "-eq" , 0 , 0 );
M_CKTOKCHAIN_( 3 , 0 , GENERATED , "test" , 4 , 2 , 0 );
M_CKTOKDEPTH_( 4 , 1 );
M_CKTOKLOC_( 4 , "-to-string" , 0 , 0 );
M_CKTOKCHAIN_( 4 , 0 , GENERATED , "test" , 5 , 2 , 0 );
M_CKTOKDEPTH_( 5 , 0 );
M_CKTOKLOC_( 5 , "test" , 5 , 15 );
M_CKTOKDEPTH_( 6 , 1 );
M_CKTOKLOC_( 6 , "-length" , 0 , 0 );
M_CKTOKCHAIN_( 6 , 0 , GENERATED , "test" , 6 , 2 , 0 );
}
#if 0
void SRDPreprocTrackingTest::testCallRecursive( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( (d)\n"
"(-if $d (\n"
"($fn (-sub $d 1))\n"
") (\n"
"(-error)\n"
")))))\n"
"(-bless fn)\n"
"($fn 6)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 5 , 1 );
M_CKERRDEPTH_( 0 , 2 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 3 , 1 , 6 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 8 , 1 , 1 );
}
void SRDPreprocTrackingTest::testCalls( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn1 (-raw ( (d)\n"
"(-if $d (\n"
"($fn1 (-sub $d 1))\n"
") (\n"
"($fn2 4)\n"
")))))\n"
"(-set fn2 (-raw ( (d)\n"
"(-if $d (\n"
"($fn2 (-sub $d 1))\n"
") (\n"
"(-error)\n"
")))))\n"
"(-bless fn1 fn2)\n"
"($fn1 6)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 11 , 1 );
M_CKERRDEPTH_( 0 , 4 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 9 , 1 , 4 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 5 , 1 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::CALLED , 3 , 1 , 6 );
M_CKERRCHAIN_( 0 , 3 , E_SRDLocationChaining::CALLED , 14 , 1 , 1 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testEval( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-eval\n"
"( (-raw -error ) )\n"
")\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 2 , 1 );
M_CKERRDEPTH_( 0 , 1 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 1 , 1 , 1 );
}
void SRDPreprocTrackingTest::testEvalCall( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( (d)\n"
"(-if $d (\n"
"($fn (-sub $d 1))\n"
") (\n"
"(-error)\n"
")))))\n"
"(-bless fn)\n"
"(-eval (-raw ($fn 6)))\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 5 , 1 );
M_CKERRDEPTH_( 0 , 3 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 3 , 1 , 6 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 8 , 14 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::EVALUATED , 8 , 1 , 1 );
}
void SRDPreprocTrackingTest::testCallEval( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( (d)\n"
"(-if $d (\n"
"($fn (-sub $d 1))\n"
") (\n"
"(-eval (-raw (-error)))\n"
")))))\n"
"(-bless fn)\n"
"($fn 6)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 5 , 14 );
M_CKERRDEPTH_( 0 , 3 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 5 , 1 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 3 , 1 , 6 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::CALLED , 8 , 1 , 1 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testMacroBody( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-error) )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 26 );
M_CKERRDEPTH_( 0 , 1 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 2 , 1 , 1 );
}
void SRDPreprocTrackingTest::testMacroBodyCall( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( () (-error) )))\n"
"(-bless fn)\n"
"(-set-macro m (-raw ( () ($fn) )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 21 );
M_CKERRDEPTH_( 0 , 2 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 3 , 26 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 4 , 1 , 1 );
}
void SRDPreprocTrackingTest::testMacroBodyEval( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-eval (-raw (-error))) )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 39 );
M_CKERRDEPTH_( 0 , 2 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 1 , 26 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 2 , 1 , 1 );
}
void SRDPreprocTrackingTest::testCallMacroBody( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-error) )))\n"
"(-set fn (-raw ( () (m))))\n"
"(-bless fn)\n"
"($fn)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 26 );
M_CKERRDEPTH_( 0 , 2 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 2 , 21 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::CALLED , 4 , 1 , 1 );
}
void SRDPreprocTrackingTest::testEvalMacroBody( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-error) )))\n"
"(-eval (-raw (m)))\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 26 );
M_CKERRDEPTH_( 0 , 2 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 2 , 14 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::EVALUATED , 2 , 1 , 1 );
}
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testMacroOutput( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-raw (-error)) )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 32 );
M_CKERRDEPTH_( 0 , 3 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 2 , 1 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::GENERATED , 1 , 32 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::CALLED , 2 , 1 , 1 );
}
void SRDPreprocTrackingTest::testMacroOutputCall( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set fn (-raw ( () (-error) )))\n"
"(-bless fn)\n"
"(-set-macro m (-raw ( () (-raw ($fn)) )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 21 );
M_CKERRDEPTH_( 0 , 4 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::CALLED , 3 , 32 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::EVALUATED , 4 , 1 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::GENERATED , 3 , 32 , 1 );
M_CKERRCHAIN_( 0 , 3 , E_SRDLocationChaining::CALLED , 4 , 1 , 1 );
}
void SRDPreprocTrackingTest::testMacroOutputEval( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-raw\n"
"(-eval (-raw (-error)))\n"
") )))\n"
"(m)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 2 , 14 );
M_CKERRDEPTH_( 0 , 4 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 2 , 1 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::EVALUATED , 4 , 1 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::GENERATED , 2 , 1 , 1 );
M_CKERRCHAIN_( 0 , 3 , E_SRDLocationChaining::CALLED , 4 , 1 , 1 );
}
void SRDPreprocTrackingTest::testCallMacroOutput( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-raw\n"
"(-error)\n"
") )))\n"
"(-set fn (-raw ( () (m) )))\n"
"(-bless fn)\n"
"($fn)\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 2 , 1 );
M_CKERRDEPTH_( 0 , 4 );
M_CKERRCHAIN_( 0 , 0 , E_SRDLocationChaining::EVALUATED , 4 , 21 , 1 );
M_CKERRCHAIN_( 0 , 1 , E_SRDLocationChaining::GENERATED , 2 , 1 , 1 );
M_CKERRCHAIN_( 0 , 2 , E_SRDLocationChaining::CALLED , 4 , 21 , 1 );
M_CKERRCHAIN_( 0 , 3 , E_SRDLocationChaining::CALLED , 6 , 1 , 1 );
}
void SRDPreprocTrackingTest::testEvalMacroOutput( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-set-macro m (-raw ( () (-raw\n"
"(-error)\n"
") )))\n"
"(-eval (-raw (m)))\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 1u , errors.size( ) );
M_CKERR_( 0 , "user error" , 2 , 1 );
M_CKERRDEPTH_( 0 , 4 );
M_CKERRCHAIN_( 0 , 0 , EVALUATED , 4 , 14 , 1 );
M_CKERRCHAIN_( 0 , 1 , GENERATED , 2 , 1 , 1 );
M_CKERRCHAIN_( 0 , 2 , CALLED , 4 , 14 , 1 );
M_CKERRCHAIN_( 0 , 3 , EVALUATED , 4 , 1 , 1 );
}
#endif
/*----------------------------------------------------------------------------*/
void SRDPreprocTrackingTest::testErrorTopLevel( )
{
T_SRDErrors errors;
T_SRDList output( process(
"(-error)\n"
"(-scope (-error))\n"
, errors ) );
CPPUNIT_ASSERT( check( "" , output ) );
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
M_CKERR_( 0 , "user error" , 1 , 2 );
M_CKERRDEPTH_( 0 , 0 );
M_CKERR_( 1 , "user error" , 2 , 10 );
M_CKERRDEPTH_( 1 , 0 );
}

6
tests/srd-text-writer.cc
View file

@ -1,8 +1,8 @@
#include <lw/lib/SRDText.hh>
#include <lw/lib/MemoryStreams.hh>
#include <ebcl/SRDText.hh>
#include <ebcl/MemoryStreams.hh>
#include <cmath>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
using namespace ebcl;
class SRDTextWriterTest : public CppUnit::TestFixture

268
tests/stream-file-input.cc
View file

@ -1,268 +0,0 @@
#include <lw/lib/Files.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
#if 0
/*= FileInputStreamTest =====================================================*/
class FileInputStreamTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( FileInputStreamTest );
CPPUNIT_TEST( testInitRealFile );
CPPUNIT_TEST( testInitBadFile );
CPPUNIT_TEST( testOpenRealFile );
CPPUNIT_TEST( testOpenBadFile );
CPPUNIT_TEST( testClose );
CPPUNIT_TEST( testReadOpensFile );
CPPUNIT_TEST( testReadAll );
CPPUNIT_TEST( testReadPartial );
CPPUNIT_TEST( testSetPosOpensFile );
CPPUNIT_TEST( testSetPosStart );
CPPUNIT_TEST( testSetPosEnd );
CPPUNIT_TEST( testSetPosEndBad );
CPPUNIT_TEST( testMoveOpensFile );
CPPUNIT_TEST( testMoveForward );
CPPUNIT_TEST( testMoveBack );
CPPUNIT_TEST( testMoveBad );
CPPUNIT_TEST_SUITE_END( );
T_String OK_FILE( )
{
return T_String::Pooled( "tests/data/inputstream.txt" );
}
T_String BAD_FILE( )
{
return T_String::Pooled( "tests/data/no_such_file.txt" );
}
char const* CONTENTS( )
{
return "THIS IS A TEST\n";
}
public:
void testInitRealFile( );
void testInitBadFile( );
void testOpenRealFile( );
void testOpenBadFile( );
void testClose( );
void testReadOpensFile( );
void testReadAll( );
void testReadPartial( );
void testSetPosOpensFile( );
void testSetPosStart( );
void testSetPosEnd( );
void testSetPosEndBad( );
void testMoveOpensFile( );
void testMoveForward( );
void testMoveBack( );
void testMoveBad( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( FileInputStreamTest );
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testInitRealFile( )
{
T_FileInputStream fis( OK_FILE( ) );
CPPUNIT_ASSERT( fis.path( ) == OK_FILE( ) );
CPPUNIT_ASSERT( fis.canUseSize( ) );
CPPUNIT_ASSERT( fis.canRead( ) );
CPPUNIT_ASSERT( fis.size( ) == 0 );
CPPUNIT_ASSERT( fis.position( ) == 0 );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testInitBadFile( )
{
T_FileInputStream fis( BAD_FILE( ) );
CPPUNIT_ASSERT( fis.path( ) == BAD_FILE( ) );
CPPUNIT_ASSERT( fis.canUseSize( ) );
CPPUNIT_ASSERT( fis.canRead( ) );
CPPUNIT_ASSERT( fis.size( ) == 0 );
CPPUNIT_ASSERT( fis.position( ) == 0 );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testOpenRealFile( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
CPPUNIT_ASSERT( fis.size( ) == 15 );
CPPUNIT_ASSERT( fis.position( ) == 0 );
CPPUNIT_ASSERT( fis.isOpen( ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testOpenBadFile( )
{
T_FileInputStream fis( BAD_FILE( ) );
try {
fis.open( );
CPPUNIT_FAIL( "No exception thrown" );
} catch ( X_StreamError const& e ) {
CPPUNIT_ASSERT( e.code( ) == E_StreamError::SYSTEM_ERROR );
CPPUNIT_ASSERT( e.systemError( ) == ENOENT );
}
CPPUNIT_ASSERT( fis.size( ) == 0 );
CPPUNIT_ASSERT( fis.position( ) == 0 );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testClose( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
fis.close( );
CPPUNIT_ASSERT( !fis.isOpen( ) );
CPPUNIT_ASSERT_EQUAL( size_t( 0 ) , fis.size( ) );
CPPUNIT_ASSERT_EQUAL( size_t( 0 ) , fis.position( ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testReadOpensFile( )
{
T_FileInputStream fis( OK_FILE( ) );
uint8_t x;
fis.read( &x , 0 );
CPPUNIT_ASSERT( fis.isOpen( ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testReadAll( )
{
T_FileInputStream fis( OK_FILE( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , sizeof( buffer ) ) );
CPPUNIT_ASSERT_EQUAL( fis.size( ) , rv );
CPPUNIT_ASSERT_EQUAL( fis.size( ) , fis.position( ) );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) , rv ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testReadPartial( )
{
T_FileInputStream fis( OK_FILE( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , 4 ) );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , rv );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , fis.position( ) );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) , 4 ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testSetPosOpensFile( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.position( 4 , false );
CPPUNIT_ASSERT( fis.isOpen( ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testSetPosStart( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
fis.position( 4 , false );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , fis.position( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , 3 ) );
CPPUNIT_ASSERT_EQUAL( size_t( 3 ) , rv );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) + 4 , 3 ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testSetPosEnd( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
fis.position( 4 , true );
CPPUNIT_ASSERT_EQUAL( size_t( 11 ) , fis.position( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , 1024 ) );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , rv );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) + 11 , 4 ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testSetPosEndBad( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
CPPUNIT_ASSERT_THROW( fis.position( fis.size( ) + 1 , true ) ,
X_StreamError );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testMoveOpensFile( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.move( 0 );
CPPUNIT_ASSERT( fis.isOpen( ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testMoveForward( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
fis.move( 4 );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , fis.position( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , 3 ) );
CPPUNIT_ASSERT_EQUAL( size_t( 3 ) , rv );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) + 4 , 3 ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testMoveBack( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
fis.position( 8 );
fis.move( -4 );
CPPUNIT_ASSERT_EQUAL( size_t( 4 ) , fis.position( ) );
uint8_t buffer[ 1024 ];
auto rv( fis.read( buffer , 3 ) );
CPPUNIT_ASSERT_EQUAL( size_t( 3 ) , rv );
CPPUNIT_ASSERT( !memcmp( buffer , CONTENTS( ) + 4 , 3 ) );
}
/*---------------------------------------------------------------------------*/
void FileInputStreamTest::testMoveBad( )
{
T_FileInputStream fis( OK_FILE( ) );
fis.open( );
CPPUNIT_ASSERT_THROW( fis.move( -1 ) , X_StreamError );
}
#endif

318
tests/vfs.cc
View file

@ -1,318 +0,0 @@
#include <lw/lib/VFS.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace lw;
/*= VFSPathTest ===============================================================*/
class VFSPathTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( VFSPathTest );
CPPUNIT_TEST( testUnknown );
CPPUNIT_TEST( testRoot );
CPPUNIT_TEST( testAbsolute );
CPPUNIT_TEST( testRelative );
CPPUNIT_TEST( testValid );
CPPUNIT_TEST( testInvalid );
CPPUNIT_TEST( testDotDirs );
CPPUNIT_TEST( testDotInNames );
CPPUNIT_TEST( testLeadingDots );
CPPUNIT_TEST( testTrailingSlash );
CPPUNIT_TEST( testExtraSlashes );
CPPUNIT_TEST( testEquals );
CPPUNIT_TEST( testToString );
CPPUNIT_TEST( testAppend );
CPPUNIT_TEST( testNormalize );
CPPUNIT_TEST_SUITE_END( );
public:
void testUnknown( );
void testRoot( );
void testAbsolute( );
void testRelative( );
void testValid( );
void testInvalid( );
void testDotDirs( );
void testDotInNames( );
void testLeadingDots( );
void testTrailingSlash( );
void testExtraSlashes( );
void testEquals( );
void testToString( );
void testAppend( );
void testNormalize( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( VFSPathTest );
/*----------------------------------------------------------------------------*/
void VFSPathTest::testUnknown( )
{
{
T_VFSPath path;
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::UNKNOWN );
CPPUNIT_ASSERT( path.elements( ) == 0 );
}
{
T_VFSPath path( "" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::UNKNOWN );
CPPUNIT_ASSERT( path.elements( ) == 0 );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testRoot( )
{
T_VFSPath path( "/" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::ABSOLUTE );
CPPUNIT_ASSERT( path.elements( ) == 0 );
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testAbsolute( )
{
T_VFSPath path( "/this/is/a/test" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::ABSOLUTE );
CPPUNIT_ASSERT( path.elements( ) == 4 );
CPPUNIT_ASSERT( path[ 0 ] == "this" );
CPPUNIT_ASSERT( path[ 1 ] == "is" );
CPPUNIT_ASSERT( path[ 2 ] == "a" );
CPPUNIT_ASSERT( path[ 3 ] == "test" );
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testRelative( )
{
T_VFSPath path( "this/is/a/test" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::RELATIVE );
CPPUNIT_ASSERT( path.elements( ) == 4 );
CPPUNIT_ASSERT( path[ 0 ] == "this" );
CPPUNIT_ASSERT( path[ 1 ] == "is" );
CPPUNIT_ASSERT( path[ 2 ] == "a" );
CPPUNIT_ASSERT( path[ 3 ] == "test" );
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testValid( )
{
char const* const NAMES[] = {
"test" , "123" , "test-123" , "-test-123-" , "test_123" , "_" , "-"
};
for ( size_t i = 0 ; i < sizeof( NAMES ) / sizeof( NAMES[ 0 ] ) ; i ++ ) {
T_VFSPath path( NAMES[ i ] );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::RELATIVE );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testInvalid( )
{
char const* const NAMES[] = {
"bad name" , "bad\\name" , "bad\u00e9name" , "bad\x09name" ,
"BadName"
};
for ( size_t i = 0 ; i < sizeof( NAMES ) / sizeof( NAMES[ 0 ] ) ; i ++ ) {
T_VFSPath path( NAMES[ i ] );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::INVALID );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testDotDirs( )
{
{
T_VFSPath path( "./.././test" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::RELATIVE );
CPPUNIT_ASSERT( path.elements( ) == 4 );
CPPUNIT_ASSERT( path[ 0 ] == "." );
CPPUNIT_ASSERT( path[ 1 ] == ".." );
CPPUNIT_ASSERT( path[ 2 ] == "." );
CPPUNIT_ASSERT( path[ 3 ] == "test" );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testDotInNames( )
{
{
T_VFSPath path( "test.test/test...test/test." );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::RELATIVE );
CPPUNIT_ASSERT( path.elements( ) == 3 );
CPPUNIT_ASSERT( path[ 0 ] == "test.test" );
CPPUNIT_ASSERT( path[ 1 ] == "test...test" );
CPPUNIT_ASSERT( path[ 2 ] == "test." );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testLeadingDots( )
{
{
T_VFSPath path( ".test" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::INVALID );
CPPUNIT_ASSERT( path.elements( ) == 1 );
CPPUNIT_ASSERT( path[ 0 ] == ".test" );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testTrailingSlash( )
{
T_VFSPath path( "/this/is/a/test/" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::ABSOLUTE );
CPPUNIT_ASSERT( path.elements( ) == 4 );
CPPUNIT_ASSERT( path[ 0 ] == "this" );
CPPUNIT_ASSERT( path[ 1 ] == "is" );
CPPUNIT_ASSERT( path[ 2 ] == "a" );
CPPUNIT_ASSERT( path[ 3 ] == "test" );
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testExtraSlashes( )
{
T_VFSPath path( "///this////is//a////test///" );
CPPUNIT_ASSERT( path.type( ) == E_VFSPathType::ABSOLUTE );
CPPUNIT_ASSERT( path.elements( ) == 4 );
CPPUNIT_ASSERT( path[ 0 ] == "this" );
CPPUNIT_ASSERT( path[ 1 ] == "is" );
CPPUNIT_ASSERT( path[ 2 ] == "a" );
CPPUNIT_ASSERT( path[ 3 ] == "test" );
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testEquals( )
{
const T_VFSPath PATHS[] = {
{} , ".bad" , "test" , "/test" , "this/is/a/test"
};
const auto n( sizeof( PATHS ) / sizeof( PATHS[ 0 ] ) );
T_VFSPath copies[ n ];
for ( size_t i = 0 ; i < n ; i ++ ) {
copies[ i ] = PATHS[ i ];
}
for ( size_t i = 0 ; i < n ; i ++ ) {
for ( size_t j = 0 ; j < n ; j ++ ) {
if ( i == j ) {
CPPUNIT_ASSERT( PATHS[ i ] == PATHS[ j ] );
CPPUNIT_ASSERT( PATHS[ i ] == copies[ j ] );
} else {
CPPUNIT_ASSERT( PATHS[ i ] != PATHS[ j ] );
CPPUNIT_ASSERT( PATHS[ i ] != copies[ j ] );
}
}
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testToString( )
{
char const* const PATHS[] = {
"/test" , "test" , "test/test" , "/test/test" , "" , ".bad"
};
for ( size_t i = 0 ; i < sizeof( PATHS ) / sizeof( PATHS[ 0 ] ) ; i ++ ) {
T_VFSPath path( PATHS[ i ] );
CPPUNIT_ASSERT( T_String( path ) == PATHS[ i ] );
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testAppend( )
{
const T_VFSPath paths[] = {
"/test" , "test" , ".bad" , {}
};
const E_VFSPathType combos[] = {
// Parent is absolute
E_VFSPathType::ABSOLUTE , E_VFSPathType::ABSOLUTE ,
E_VFSPathType::INVALID , E_VFSPathType::UNKNOWN ,
// Parent is relative
E_VFSPathType::RELATIVE , E_VFSPathType::RELATIVE ,
E_VFSPathType::INVALID , E_VFSPathType::UNKNOWN ,
// Parent is invalid
E_VFSPathType::INVALID , E_VFSPathType::INVALID ,
E_VFSPathType::INVALID , E_VFSPathType::UNKNOWN ,
// Parent is unknown
E_VFSPathType::UNKNOWN , E_VFSPathType::UNKNOWN ,
E_VFSPathType::UNKNOWN , E_VFSPathType::UNKNOWN
};
int cid = 0;
for ( int i = 0 ; i < 4 ; i ++ ) {
for ( int j = 0 ; j < 4 ; j ++ , cid ++ ) {
T_VFSPath parent( paths[ i ] ) , child( paths[ j ] );
T_VFSPath path( parent , child );
//printf( "i = %d j = %d t = %d\n" , i , j , int( path.type( ) ) );
CPPUNIT_ASSERT( path.type( ) == combos[ cid ] );
if ( combos[ cid ] == E_VFSPathType::UNKNOWN ) {
CPPUNIT_ASSERT( path.elements( ) == 0 );
} else {
CPPUNIT_ASSERT( path.elements( ) == parent.elements( ) + child.elements( ) );
CPPUNIT_ASSERT( path[ 0 ] == parent[ 0 ] );
CPPUNIT_ASSERT( path[ 1 ] == child[ 0 ] );
}
}
}
}
/*----------------------------------------------------------------------------*/
void VFSPathTest::testNormalize( )
{
const T_VFSPath INPUTS[] = {
{} , ".bad" , "/test" , "test" ,
"./test" ,
"/." ,
"/.." ,
"." ,
".." ,
"wat/../wet/../wut" ,
"wat/../.." ,
"wat/.." ,
"/wat/../.."
};
const T_VFSPath EXPECTED[] = {
{} , {} , "/test" , "test" ,
"test" ,
"/" ,
"/" ,
"." ,
".." ,
"wut" ,
".." ,
"." ,
"/"
};
static_assert( sizeof( INPUTS ) / sizeof( INPUTS[ 0 ] )
== sizeof( EXPECTED ) / sizeof( EXPECTED[ 0 ] ) ,
"yo, your test sucks!" );
for ( size_t i = 0 ; i < sizeof( INPUTS ) / sizeof( INPUTS[ 0 ] ) ; i ++ ) {
CPPUNIT_ASSERT( T_String( INPUTS[ i ].normalize( ) ) == T_String( EXPECTED[ i ] ) );
}
}