1100 lines
35 KiB
C++
1100 lines
35 KiB
C++
#include "srd-preproc-cmd-common.hh"
|
|
|
|
|
|
class SRDPreprocCmdCastsTest : public CppUnit::TestFixture
|
|
{
|
|
CPPUNIT_TEST_SUITE( SRDPreprocCmdCastsTest );
|
|
|
|
CPPUNIT_TEST( testToStringEmpty );
|
|
CPPUNIT_TEST( testToStringString );
|
|
CPPUNIT_TEST( testToStringWord );
|
|
CPPUNIT_TEST( testToStringInt );
|
|
CPPUNIT_TEST( testToStringLong );
|
|
CPPUNIT_TEST( testToStringReal );
|
|
CPPUNIT_TEST( testToStringVar );
|
|
CPPUNIT_TEST( testToStringList );
|
|
CPPUNIT_TEST( testToStringBinary );
|
|
CPPUNIT_TEST( testToStringBinaryInvalid );
|
|
CPPUNIT_TEST( testToStringMultiple );
|
|
|
|
CPPUNIT_TEST( testToWordEmpty );
|
|
CPPUNIT_TEST( testToWordStringOk );
|
|
CPPUNIT_TEST( testToWordStringBad );
|
|
CPPUNIT_TEST( testToWordWord );
|
|
CPPUNIT_TEST( testToWordInt );
|
|
CPPUNIT_TEST( testToWordLong );
|
|
CPPUNIT_TEST( testToWordReal );
|
|
CPPUNIT_TEST( testToWordVar );
|
|
CPPUNIT_TEST( testToWordList );
|
|
CPPUNIT_TEST( testToWordMultiple );
|
|
|
|
CPPUNIT_TEST( testToIntEmpty );
|
|
CPPUNIT_TEST( testToIntStringOk );
|
|
CPPUNIT_TEST( testToIntStringBad );
|
|
CPPUNIT_TEST( testToIntWord );
|
|
CPPUNIT_TEST( testToIntInt );
|
|
CPPUNIT_TEST( testToIntLongOk );
|
|
CPPUNIT_TEST( testToIntLongBad );
|
|
CPPUNIT_TEST( testToIntReal );
|
|
CPPUNIT_TEST( testToIntVar );
|
|
CPPUNIT_TEST( testToIntList );
|
|
CPPUNIT_TEST( testToIntMultiple );
|
|
|
|
CPPUNIT_TEST( testToLongEmpty );
|
|
CPPUNIT_TEST( testToLongStringOk );
|
|
CPPUNIT_TEST( testToLongStringBad );
|
|
CPPUNIT_TEST( testToLongWord );
|
|
CPPUNIT_TEST( testToLongInt );
|
|
CPPUNIT_TEST( testToLongLong );
|
|
CPPUNIT_TEST( testToLongReal );
|
|
CPPUNIT_TEST( testToLongVar );
|
|
CPPUNIT_TEST( testToLongList );
|
|
CPPUNIT_TEST( testToLongMultiple );
|
|
|
|
CPPUNIT_TEST( testToBestIntEmpty );
|
|
CPPUNIT_TEST( testToBestIntString32 );
|
|
CPPUNIT_TEST( testToBestIntString64 );
|
|
CPPUNIT_TEST( testToBestIntStringBad );
|
|
CPPUNIT_TEST( testToBestIntWord );
|
|
CPPUNIT_TEST( testToBestIntInt );
|
|
CPPUNIT_TEST( testToBestIntLong32 );
|
|
CPPUNIT_TEST( testToBestIntLong64 );
|
|
CPPUNIT_TEST( testToBestIntReal32 );
|
|
CPPUNIT_TEST( testToBestIntReal64 );
|
|
CPPUNIT_TEST( testToBestIntVar );
|
|
CPPUNIT_TEST( testToBestIntList );
|
|
CPPUNIT_TEST( testToBestIntMultiple );
|
|
|
|
CPPUNIT_TEST( testToRealEmpty );
|
|
CPPUNIT_TEST( testToRealStringOk );
|
|
CPPUNIT_TEST( testToRealStringBad );
|
|
CPPUNIT_TEST( testToRealWord );
|
|
CPPUNIT_TEST( testToRealInt );
|
|
CPPUNIT_TEST( testToRealLong );
|
|
CPPUNIT_TEST( testToRealReal );
|
|
CPPUNIT_TEST( testToRealVar );
|
|
CPPUNIT_TEST( testToRealList );
|
|
CPPUNIT_TEST( testToRealMultiple );
|
|
|
|
CPPUNIT_TEST( testToVarEmpty );
|
|
CPPUNIT_TEST( testToVarStringOk );
|
|
CPPUNIT_TEST( testToVarStringOkWithDollar );
|
|
CPPUNIT_TEST( testToVarStringBadWord );
|
|
CPPUNIT_TEST( testToVarStringBadVarName );
|
|
CPPUNIT_TEST( testToVarWordOk );
|
|
CPPUNIT_TEST( testToVarWordBad );
|
|
CPPUNIT_TEST( testToVarInt );
|
|
CPPUNIT_TEST( testToVarLong );
|
|
CPPUNIT_TEST( testToVarReal );
|
|
CPPUNIT_TEST( testToVarVar );
|
|
CPPUNIT_TEST( testToVarList );
|
|
CPPUNIT_TEST( testToVarMultiple );
|
|
|
|
CPPUNIT_TEST( testToListEmpty );
|
|
CPPUNIT_TEST( testToListString );
|
|
CPPUNIT_TEST( testToListStringEmpty );
|
|
CPPUNIT_TEST( testToListWord );
|
|
CPPUNIT_TEST( testToListBinary );
|
|
CPPUNIT_TEST( testToListBinaryEmpty );
|
|
CPPUNIT_TEST( testToListList );
|
|
CPPUNIT_TEST( testToListListEmpty );
|
|
CPPUNIT_TEST( testToListOtherTypes );
|
|
|
|
CPPUNIT_TEST( testToSourceEmpty );
|
|
CPPUNIT_TEST( testToSourceWord );
|
|
CPPUNIT_TEST( testToSourceString );
|
|
CPPUNIT_TEST( testToSourceInt );
|
|
CPPUNIT_TEST( testToSourceLong );
|
|
CPPUNIT_TEST( testToSourceReal );
|
|
CPPUNIT_TEST( testToSourceVar );
|
|
CPPUNIT_TEST( testToSourceList );
|
|
CPPUNIT_TEST( testToSourceMultiple );
|
|
|
|
CPPUNIT_TEST_SUITE_END( );
|
|
|
|
public:
|
|
void testToStringEmpty( );
|
|
void testToStringString( );
|
|
void testToStringWord( );
|
|
void testToStringInt( );
|
|
void testToStringLong( );
|
|
void testToStringReal( );
|
|
void testToStringVar( );
|
|
void testToStringList( );
|
|
void testToStringBinary( );
|
|
void testToStringBinaryInvalid( );
|
|
void testToStringMultiple( );
|
|
|
|
void testToWordEmpty( );
|
|
void testToWordStringOk( );
|
|
void testToWordStringBad( );
|
|
void testToWordWord( );
|
|
void testToWordInt( );
|
|
void testToWordLong( );
|
|
void testToWordReal( );
|
|
void testToWordVar( );
|
|
void testToWordList( );
|
|
void testToWordMultiple( );
|
|
|
|
void testToIntEmpty( );
|
|
void testToIntStringOk( );
|
|
void testToIntStringBad( );
|
|
void testToIntWord( );
|
|
void testToIntInt( );
|
|
void testToIntLongOk( );
|
|
void testToIntLongBad( );
|
|
void testToIntReal( );
|
|
void testToIntVar( );
|
|
void testToIntList( );
|
|
void testToIntMultiple( );
|
|
|
|
void testToLongEmpty( );
|
|
void testToLongStringOk( );
|
|
void testToLongStringBad( );
|
|
void testToLongWord( );
|
|
void testToLongInt( );
|
|
void testToLongLong( );
|
|
void testToLongReal( );
|
|
void testToLongVar( );
|
|
void testToLongList( );
|
|
void testToLongMultiple( );
|
|
|
|
void testToBestIntEmpty( );
|
|
void testToBestIntString32( );
|
|
void testToBestIntString64( );
|
|
void testToBestIntStringBad( );
|
|
void testToBestIntWord( );
|
|
void testToBestIntInt( );
|
|
void testToBestIntLong32( );
|
|
void testToBestIntLong64( );
|
|
void testToBestIntReal32( );
|
|
void testToBestIntReal64( );
|
|
void testToBestIntVar( );
|
|
void testToBestIntList( );
|
|
void testToBestIntMultiple( );
|
|
|
|
void testToRealEmpty( );
|
|
void testToRealStringOk( );
|
|
void testToRealStringBad( );
|
|
void testToRealWord( );
|
|
void testToRealInt( );
|
|
void testToRealLong( );
|
|
void testToRealReal( );
|
|
void testToRealVar( );
|
|
void testToRealList( );
|
|
void testToRealMultiple( );
|
|
|
|
void testToVarEmpty( );
|
|
void testToVarStringOk( );
|
|
void testToVarStringOkWithDollar( );
|
|
void testToVarStringBadWord( );
|
|
void testToVarStringBadVarName( );
|
|
void testToVarWordOk( );
|
|
void testToVarWordBad( );
|
|
void testToVarInt( );
|
|
void testToVarLong( );
|
|
void testToVarReal( );
|
|
void testToVarVar( );
|
|
void testToVarList( );
|
|
void testToVarMultiple( );
|
|
|
|
void testToListEmpty( );
|
|
void testToListString( );
|
|
void testToListStringEmpty( );
|
|
void testToListWord( );
|
|
void testToListBinary( );
|
|
void testToListBinaryEmpty( );
|
|
void testToListList( );
|
|
void testToListListEmpty( );
|
|
void testToListOtherTypes( );
|
|
|
|
void testToSourceEmpty( );
|
|
void testToSourceWord( );
|
|
void testToSourceString( );
|
|
void testToSourceInt( );
|
|
void testToSourceLong( );
|
|
void testToSourceReal( );
|
|
void testToSourceVar( );
|
|
void testToSourceList( );
|
|
void testToSourceMultiple( );
|
|
};
|
|
CPPUNIT_TEST_SUITE_REGISTRATION( SRDPreprocCmdCastsTest );
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringString( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string \"a string\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"a string\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"word\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string 1 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"1\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string 12123456789 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"12123456789\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string 0.5 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"0.5\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string ( -raw $a ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"$a\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringBinary( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string [ 4c 4f 4c ] )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"LOL\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringBinaryInvalid( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string [ 80 4c 4f 4c e5 ] )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid UTF-8 data" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 14 );
|
|
CPPUNIT_ASSERT( check( "\"\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToStringMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-string \"a\" b ( ) ( -raw $c ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
|
|
CPPUNIT_ASSERT( check( "\"a\" \"b\" \"$c\"" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordStringOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word \"a-word\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "a-word" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordStringBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word \"not a word, lol\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid word" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "word" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word 1 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word 12123456789 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word 0.5 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "x" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToWordMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-word ( ) \"a\" ( -raw $b ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "invalid a b" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntStringOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer \"123\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntStringBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer \"123nope\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid integer value" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer 123 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntLongOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer ( -to-long 123 ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntLongBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer 12345678912 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "value out of range" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
|
|
CPPUNIT_ASSERT( check( "2147483647" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer 0.5 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 22 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToIntMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-integer ( ) 1 \"2\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 15 );
|
|
CPPUNIT_ASSERT( check( "0 1 2" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongStringOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long \"12345678912\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12345678912" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongStringBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long \"123nope\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid integer value" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 0 ) , output[ 0 ].longValue( ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 0 ) , output[ 0 ].longValue( ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long 123 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 123 ) , output[ 0 ].longValue( ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long 12345678912 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12345678912" , output ) );
|
|
}
|
|
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long 1e10 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "10000000000" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 19 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 0 ) , output[ 0 ].longValue( ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 0 ) , output[ 0 ].longValue( ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToLongMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-long ( ) 12345678912 \"12123456789\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT_EQUAL( 3u , output.size( ) );
|
|
CPPUNIT_ASSERT( output[ 0 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 0 ) , output[ 0 ].longValue( ) );
|
|
CPPUNIT_ASSERT( output[ 1 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 12345678912L ) , output[ 1 ].longValue( ) );
|
|
CPPUNIT_ASSERT( output[ 2 ].type( ) == E_SRDTokenType::LONG );
|
|
CPPUNIT_ASSERT_EQUAL( int64_t( 12123456789L ) , output[ 2 ].longValue( ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntString32( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer \"123456\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123456" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntString64( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer \"12345678912\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12345678912" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntStringBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer \"123nope\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid integer value" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer nope )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer 123 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntLong32( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer ( -to-long 123 ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "123" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntLong64( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer 12345678912 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12345678912" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntReal32( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer 12.3 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntReal64( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer 1e10 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "10000000000" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 27 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
|
|
CPPUNIT_ASSERT( check( "0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToBestIntMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-best-integer ( ) \"123\" 456 78912345678 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 20 );
|
|
CPPUNIT_ASSERT( check( "0 123 456 78912345678" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealStringOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real \"-12e-3\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "-0.012" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealStringBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real \"nope\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid real value" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "0." , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real nope )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "0." , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real 12 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12.0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real 12345678912 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "12345678912.0" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real 1234567891.2 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "1234567891.2" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 19 );
|
|
CPPUNIT_ASSERT( check( "0." , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "0." , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToRealMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-real ( ) 123 456.5 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 12 );
|
|
CPPUNIT_ASSERT( check( "0. 123.0 456.5" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarStringOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable \"name\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "$name" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarStringOkWithDollar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable \"$name\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "$name" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarStringBadWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable \"not a word\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid variable name" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarStringBadVarName( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable \"-bad\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid variable name" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarWordOk( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable name )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "$name" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarWordBad( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable -bad )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "invalid variable name" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable 1 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable 12345678912 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable 1.5 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable ( -raw $x ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "$x" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToVarMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-variable ( ) \"$x\" y )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2u , errors.size( ) );
|
|
M_CKERR_( 0 , "unsupported type conversion" , 1 , 3 );
|
|
M_CKERR_( 1 , "previous error cause" , 1 , 16 );
|
|
CPPUNIT_ASSERT( check( "$invalid $x $y" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToListEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListString( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list \"abc\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"a\" \"b\" \"c\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListStringEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list \"\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list abc )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"a\" \"b\" \"c\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListBinary( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list [ deadbeef ] )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "222 173 190 239" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListBinaryEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list [ ] )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list ( ab c ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "ab c" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListListEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list ( ) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToListOtherTypes( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-list 10 1.2 (-raw $x) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( 0u , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "10 1.2 $x" , output ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceEmpty( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceWord( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source word )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"word\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceString( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source \"some\\nstring\" )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"\\\"some\\\\nstring\\\"\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceInt( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source 123 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"123\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceLong( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source 5000000000 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"5000000000\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceReal( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source 1.2 )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"1.2\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceVar( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "( -to-source (-raw $x) )" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"$x\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceList( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "(-to-source ( word \"string\" 123 5000000000 1.2 (-raw $x) ))" , errors ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , errors.size( ) );
|
|
CPPUNIT_ASSERT( check( "\"( word \\\"string\\\" 123 5000000000 1.2 $x )\"" , output ) );
|
|
}
|
|
|
|
void SRDPreprocCmdCastsTest::testToSourceMultiple( )
|
|
{
|
|
T_SRDErrors errors;
|
|
T_SRDList output( process( "(-to-source word \"string\" 123 5000000000 1.2 (-raw $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 ) );
|
|
}
|