932 lines
31 KiB
C++
932 lines
31 KiB
C++
|
#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 ) );
|
||
|
|
}
|