1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include <stdio.h> 25 #include <rtl/tres.h> 26 #include <osl/diagnose.h> 27 #include <osl/time.h> 28 29 /* force an assertion on false state */ 30 #define TST_BOOM(c, m) OSL_ENSURE(c, m) 31 32 33 typedef struct _rtl_CmpState 34 { 35 struct _rtl_CmpState* m_next; 36 struct _rtl_CmpState* m_prev; 37 38 sal_Bool m_stat; 39 rtl_String* m_msg; 40 41 } rtl_CmpState; 42 43 typedef struct _rtl_FuncState 44 { 45 struct _rtl_FuncState* m_next; 46 struct _rtl_FuncState* m_prev; 47 rtl_String* m_name; 48 sal_uInt32 m_flags; 49 sal_uInt32 m_start; 50 sal_uInt32 m_stop; 51 struct _rtl_CmpState* m_cmp; 52 53 } rtl_FuncState; 54 55 56 57 typedef struct _rtl_TestResult_Data 58 { 59 rtl_TestResult_vtable* m_funcs; 60 void* m_externaldata; 61 62 rtl_FuncState* m_state; 63 64 } rtl_TestResult_Data; 65 66 67 /** 68 * internal helper functions 69 */ 70 71 /* ...to create, link, unlink and destroy allocated memory */ 72 rtl_FuncState* SAL_CALL rtl_tres_create_funcstate( const sal_Char* meth ); 73 rtl_FuncState* SAL_CALL rtl_tres_link_funcstate( rtl_FuncState* ptr, 74 rtl_FuncState* plink ); 75 rtl_FuncState* SAL_CALL rtl_tres_unlink_funcstate( rtl_FuncState* plink ); 76 rtl_CmpState* SAL_CALL rtl_tres_create_cmpstate( 77 sal_Bool state, 78 const sal_Char* msg 79 ); 80 rtl_CmpState* SAL_CALL rtl_tres_link_cmpstate( rtl_CmpState* ptr, 81 rtl_CmpState* plink ); 82 rtl_CmpState* SAL_CALL rtl_tres_unlink_cmpstate( rtl_CmpState* plink ); 83 sal_uInt32 SAL_CALL rtl_tres_timer(); 84 void SAL_CALL rtl_tres_destroy_funcstate( rtl_FuncState* pState_ ); 85 void SAL_CALL rtl_tres_destroy_funcstates( rtl_FuncState* pState_ ); 86 void SAL_CALL rtl_tres_destroy_cmpstates( rtl_CmpState* pState_ ); 87 void SAL_CALL rtl_tres_destroy_cmpstate( rtl_CmpState* pState_ ); 88 89 90 /* set and clear single bits */ 91 static void SAL_CALL rtl_tres_setbit( rtl_FuncState* pState_, 92 sal_uInt32 flag ); 93 static void SAL_CALL rtl_tres_clearbit( rtl_FuncState* pState_, 94 sal_uInt32 flag ); 95 96 /** 97 * forward declarations of concrete function implementations overloadable 98 * and accessible via vtable 99 */ 100 static sal_Bool SAL_CALL rtl_tres_state( 101 rtl_TestResult* pThis_, 102 sal_Bool state, 103 const sal_Char* msg, 104 const sal_Char* sub, 105 sal_Bool v 106 ); 107 108 static void SAL_CALL rtl_tres_end( rtl_TestResult* pThis_, 109 const sal_Char* msg ); 110 111 static rtl_funcstate SAL_CALL rtl_tres_funcstate( rtl_TestResult* pThis_ ); 112 113 static sal_Bool SAL_CALL rtl_tres_ispassed( rtl_TestResult* pThis_ ); 114 static sal_Bool SAL_CALL rtl_tres_isok( rtl_TestResult* pThis_ ); 115 116 static sal_Bool SAL_CALL rtl_tres_isbit( rtl_TestResult* pThis_, 117 sal_uInt32 flag ); 118 119 static rtl_funcstate SAL_CALL rtl_tres_getnextfuncstate( rtl_funcstate ); 120 static rtl_funcstate SAL_CALL rtl_tres_getprevfuncstate( rtl_funcstate ); 121 static sal_uInt32 SAL_CALL rtl_tres_getflags( rtl_funcstate ); 122 sal_uInt32 SAL_CALL rtl_tres_getstarttime( rtl_funcstate ); 123 sal_uInt32 SAL_CALL rtl_tres_getstoptime( rtl_funcstate ); 124 static rtl_cmpstate SAL_CALL rtl_tres_getcmpstate( rtl_funcstate ); 125 126 static sal_Bool SAL_CALL rtl_tres_getstat( rtl_cmpstate ); 127 rtl_String* SAL_CALL rtl_tres_getname( rtl_funcstate ); 128 rtl_String* SAL_CALL rtl_tres_getmsg( rtl_cmpstate ); 129 static rtl_cmpstate SAL_CALL rtl_tres_getnextcmpstate( rtl_cmpstate ); 130 131 132 /** 133 * initialize vtable with function pointers 134 */ 135 static rtl_TestResult_vtable trVTable = 136 { 137 sizeof(rtl_TestResult_vtable), 138 rtl_tres_state, 139 rtl_tres_end, 140 rtl_tres_ispassed, 141 rtl_tres_isok, 142 rtl_tres_funcstate, 143 rtl_tres_isbit, 144 rtl_tres_getnextfuncstate, 145 rtl_tres_getprevfuncstate, 146 rtl_tres_getflags, 147 rtl_tres_getname, 148 rtl_tres_getstarttime, 149 rtl_tres_getstoptime, 150 rtl_tres_getcmpstate, 151 rtl_tres_getstat, 152 rtl_tres_getmsg, 153 rtl_tres_getnextcmpstate 154 }; 155 156 /** 157 * rtl_tres_create 158 * create and initialize data struct for TestResult 159 * 160 * @param const sal_Char* meth = name of the method (entryname) 161 * @param sal_uInt32 flags = bitmap of comandline and status flags 162 * 163 * @return rtl_TestResult* = pointer to a new allocated testresult struct 164 */ 165 rtl_TestResult* rtl_tres_create( const sal_Char* meth, sal_uInt32 flags ) 166 { 167 /* allocate memory for testresult data structure */ 168 rtl_TestResult_Data* pData = (rtl_TestResult_Data*) malloc( sizeof( 169 rtl_TestResult_Data ) ); 170 /* initialize members... */ 171 pData->m_funcs = &trVTable; /* ...vtableptr to vtbladr */ 172 pData->m_externaldata = 0; /* ...external data pointer */ 173 174 /* allocate memory for state structure and initialize members */ 175 pData->m_state = rtl_tres_create_funcstate( meth ); 176 pData->m_state->m_flags = flags; /* ...option Bitmap */ 177 178 /* set OK flag initial */ 179 rtl_tres_setbit( pData->m_state, rtl_tres_Flag_OK ); 180 181 return (rtl_TestResult*)pData ; 182 } 183 184 /** 185 * rtl_tres_create_funcstate 186 * allocates and initializes a structure to represent the status of a test 187 * entry or its substates 188 * 189 * @param const sal_Char* meth = the name of the method (entry or sub entry) 190 * 191 * @return rtl_FuncState* = pointer to a new allocated funcstate struct 192 */ 193 rtl_FuncState* SAL_CALL rtl_tres_create_funcstate( const sal_Char* meth ) 194 { 195 rtl_FuncState* pStat = 0; /* status structure */ 196 197 /* allocate memory for status structure */ 198 pStat = (rtl_FuncState*) malloc( sizeof( struct _rtl_FuncState ) ); 199 200 if ( pStat ) 201 { 202 pStat->m_next = pStat; /* init ptr to next struct */ 203 pStat->m_prev = pStat; /* init ptr to prev struct */ 204 205 pStat->m_name = 0; /* init name */ 206 pStat->m_flags = 0; /* init flags */ 207 pStat->m_start = rtl_tres_timer(); /* init start milliseconds */ 208 pStat->m_stop = 0; /* init stop milliseconds */ 209 pStat->m_cmp = 0; /* init ptr to msg struct */ 210 rtl_string_newFromStr( &pStat->m_name, meth );/* copy meth to name */ 211 212 /* set ok flag initially */ 213 rtl_tres_setbit(pStat, rtl_tres_Flag_OK); 214 } 215 216 return ( pStat ); 217 } 218 /** 219 * rtl_tres_link_funcstate 220 * link initialized funcstate structure to a circular double linked list 221 * 222 * @param rtl_FuncState* ptr = pointer to a funcstate where to link in new 223 * @param rtl_FuncState* plink = pointer to a funcstate to link in list 224 * 225 * @return rtl_FuncState* = pointer to structure linked in new 226 */ 227 rtl_FuncState* SAL_CALL rtl_tres_link_funcstate( rtl_FuncState* ptr, 228 rtl_FuncState* plink ) 229 { 230 ptr->m_next->m_prev = plink; 231 ptr->m_next->m_prev->m_next = ptr->m_next; 232 ptr->m_next->m_prev->m_prev = ptr; 233 ptr->m_next = plink; 234 return ( plink ); 235 } 236 237 /** 238 * rtl_tres_unlink_funcstate 239 * unlink funcstate structure from a circular double linked list 240 * 241 * @param rtl_FuncState* plink = pointer to a funcstate to unlink from list 242 * 243 * @return rtl_FuncState* = pointer to funcstate struct unlinked from 244 * list 245 */ 246 rtl_FuncState* SAL_CALL rtl_tres_unlink_funcstate( rtl_FuncState* plink ) 247 { 248 plink->m_next->m_prev = plink->m_prev; 249 plink->m_prev->m_next = plink->m_next; 250 plink->m_next = plink; 251 plink->m_prev = plink; 252 return ( plink ); 253 } 254 255 /** 256 * rtl_tres_link_cmpstate 257 * link initialized cmpstate structure to a circular double linked list 258 * 259 * @param rtl_CmpState* ptr = pointer to a cmpstate where to link in new 260 * @param rtl_CmpState* plink = pointer to a cmpstate to link in list 261 * 262 * @return rtl_CmpState* = pointer to cmpstate struct linked in new 263 */ 264 rtl_CmpState* SAL_CALL rtl_tres_link_cmpstate( rtl_CmpState* ptr, 265 rtl_CmpState* plink ) 266 { 267 ptr->m_next->m_prev = plink; 268 ptr->m_next->m_prev->m_next = ptr->m_next; 269 ptr->m_next->m_prev->m_prev = ptr; 270 ptr->m_next = plink; 271 return ( plink ); 272 } 273 /** 274 * rtl_tres_unlink_cmpstate 275 * unlink cmpstate structure from a circular double linked list 276 * 277 * @param rtl_CmpState* plink = pointer to a cmpstate to unlink from list 278 * 279 * @return rtl_CmpState* = pointer to cmpstate struct unlinked from list 280 */ 281 rtl_CmpState* SAL_CALL rtl_tres_unlink_cmpstate( rtl_CmpState* plink ) 282 { 283 plink->m_next->m_prev = plink->m_prev; 284 plink->m_prev->m_next = plink->m_next; 285 plink->m_next = plink; 286 plink->m_prev = plink; 287 return ( plink ); 288 } 289 290 /** 291 * rtl_tres_create_cmpstate 292 * allocates and initializes a structure to represent the status of a test 293 * comparison 294 * 295 * @param sal_Bool state = compare state 296 * @param sal_Char* msg = message for logging and debug purposes 297 * 298 * @return rtl_CmpState* = pointer to the new allocated struct 299 */ 300 rtl_CmpState* SAL_CALL rtl_tres_create_cmpstate( 301 sal_Bool state, 302 const sal_Char* msg 303 ) 304 { 305 /* allocate memory for cmpstate struct */ 306 rtl_CmpState* pStat = (rtl_CmpState*) malloc( sizeof( rtl_CmpState ) ); 307 308 /* initialize if memory could be allocated */ 309 if ( pStat ) 310 { 311 pStat->m_next = pStat; /* init next with this */ 312 pStat->m_prev = pStat; /* init prev with this */ 313 pStat->m_msg = 0; 314 pStat->m_stat = state; /* boolean state */ 315 rtl_string_newFromStr( &pStat->m_msg, msg ); /* copy message */ 316 } 317 return ( pStat ); 318 } 319 320 /** 321 * rtl_tres_destroy 322 * free allocated memory of testresult data struct 323 * 324 * @param rtl_TestResult* pThis_ = ponter to a valid testresult struct 325 */ 326 void SAL_CALL rtl_tres_destroy( rtl_TestResult* pThis_ ) 327 { 328 /* cast to implementation representation structure */ 329 rtl_TestResult_Data* pData = (rtl_TestResult_Data*) pThis_; 330 331 /* destroy all funcstates */ 332 if ( pData->m_state ) 333 rtl_tres_destroy_funcstates( pData->m_state ); 334 335 /* free allocted memory and reinitialize to zero */ 336 /* to be able to prevent dangling pointer access*/ 337 free( pData ); pData = 0; 338 } 339 340 /** 341 * rtl_tres_destroy_funcstates 342 * free allocated memory occupied by the list of funcstate data structs 343 * (iterates through next pointers) 344 * 345 * @param rtl_FuncState* pState_ = pointer to a valid funcstate struct 346 */ 347 void SAL_CALL rtl_tres_destroy_funcstates( rtl_FuncState* pState_ ) 348 { 349 rtl_FuncState* plink = pState_->m_next; 350 while ( plink != plink->m_next ) 351 { 352 rtl_tres_destroy_funcstate( rtl_tres_unlink_funcstate( plink ) ); 353 plink = pState_->m_next; 354 } 355 rtl_tres_destroy_funcstate( plink ); 356 } 357 358 /** 359 * rtl_tres_destroy_cmpstates 360 * free allocated memory occupied by the list of cmpstate data structs 361 * (iterates through next pointers) 362 * 363 * @param rtl_CmpState* pState_ = pointer to a valid cmpstate struct 364 */ 365 void SAL_CALL rtl_tres_destroy_cmpstates( rtl_CmpState* pState_ ) 366 { 367 rtl_CmpState* plink = pState_->m_next; 368 while ( plink != plink->m_next ) 369 { 370 rtl_tres_destroy_cmpstate( rtl_tres_unlink_cmpstate( plink ) ); 371 plink = pState_->m_next; 372 } 373 rtl_tres_destroy_cmpstate( plink ); 374 } 375 376 377 /** 378 * rtl_tres_destroy_funcstate 379 * free allocated memory occupied by one funcstate and it's list 380 * of cmpstate data structs 381 * 382 * @param rtl_FuncState* pState_ = pointer to a valid funcstate struct 383 */ 384 void SAL_CALL rtl_tres_destroy_funcstate( rtl_FuncState* pState_ ) 385 { 386 rtl_FuncState* plink = pState_; 387 388 if ( plink->m_cmp ) 389 rtl_tres_destroy_cmpstates( plink->m_cmp ); 390 391 if ( plink->m_name ) 392 { 393 rtl_string_release( plink->m_name ); 394 plink->m_name = 0; 395 } 396 plink->m_flags = 0; 397 free( plink ); 398 plink = 0; 399 } 400 401 /** 402 * rtl_tres_destroy_cmpstate 403 * free allocated memory of a cmpstate data struct 404 * 405 * @param rtl_CmpState* pState_ = pointer to cmpstate struct to destroy 406 */ 407 void SAL_CALL rtl_tres_destroy_cmpstate( rtl_CmpState* pState_ ) 408 { 409 410 rtl_CmpState* plink = pState_; 411 412 if ( plink->m_msg ) 413 { 414 rtl_string_release( plink->m_msg ); 415 plink->m_msg = 0; 416 } 417 free( plink ); 418 plink = 0; 419 } 420 /** 421 * central function to call in tests 422 * 423 * @param rtl_TestResult* pThis_ = self pointer to TestResult structure 424 * @param sal_Bool state = boolean result of statement comparison 425 * @param const sal_Char* msg = message for actual statementcomparison 426 * @param const sal_Char* sub = name of sub testfunction 427 * @param sal_Bool v = boolean verbose parameter 428 * 429 * @return sal_Bool = determines if statement comparison 430 * was positive or not 431 */ 432 static sal_Bool SAL_CALL rtl_tres_state( 433 rtl_TestResult* pThis_, 434 sal_Bool state, 435 const sal_Char* msg, 436 const sal_Char* sub, 437 sal_Bool v 438 ) 439 { 440 441 /* cast pointer to testresult data implementation struct*/ 442 rtl_TestResult_Data* pData = (rtl_TestResult_Data*)pThis_; 443 444 /* initialize funcstate pointer with masterstate */ 445 rtl_FuncState* pFunc = pData->m_state; 446 447 /* if substate required */ 448 if ( sub ) 449 { 450 /* link new created function state to last item */ 451 pFunc = rtl_tres_link_funcstate( pFunc->m_prev, 452 rtl_tres_create_funcstate( sub ) ); 453 454 /* indicate this state as substate */ 455 rtl_tres_setbit( pFunc, rtl_tres_Flag_SUB ); 456 457 /* indicate prvious state as passed if no masterstate */ 458 if ( pFunc->m_prev != pData->m_state ) 459 rtl_tres_setbit( pFunc->m_prev, rtl_tres_Flag_PASSED ); 460 } 461 462 463 /* test failed */ 464 if( ! state ) 465 { 466 /* determine if assertion should be thrown */ 467 if ( rtl_tres_isbit( pThis_, rtl_tres_Flag_BOOM ) ) 468 { 469 /* if message available */ 470 if ( msg ) 471 TST_BOOM( state, msg ); 472 else 473 TST_BOOM( state, "no msg available" ); 474 } 475 476 /* clear this state ok flag and masterstate ok flag */ 477 rtl_tres_clearbit( pFunc, rtl_tres_Flag_OK ); 478 rtl_tres_clearbit( pData->m_state, rtl_tres_Flag_OK ); 479 } 480 /* message available */ 481 if( msg ) 482 { 483 /* append a new comparison state */ 484 if (! pFunc->m_cmp ) 485 pFunc->m_cmp = rtl_tres_create_cmpstate( state, msg ); 486 else 487 rtl_tres_link_cmpstate( pFunc->m_cmp, 488 rtl_tres_create_cmpstate(state, msg ) ); 489 490 /* message to stderr required ? */ 491 if ( v || ( pFunc->m_next->m_flags & rtl_tres_Flag_VERBOSE ) ) 492 fprintf( stderr, "%s\n", msg ); 493 } 494 495 pFunc->m_stop = rtl_tres_timer(); 496 return ( state ); 497 } 498 499 /** 500 * rtl_tres_timer 501 * function to get actual timevalue 502 * this has to be replaced by a high resolution timer 503 */ 504 sal_uInt32 SAL_CALL rtl_tres_timer() 505 { 506 sal_uInt32 val = 0; 507 TimeValue* tmv = (TimeValue*)malloc( sizeof( TimeValue ) ); 508 osl_getSystemTime( tmv ); 509 val = tmv->Nanosec/1000L; 510 free( tmv ); 511 return ( val ); 512 } 513 514 515 static void SAL_CALL rtl_tres_end( rtl_TestResult* pThis_, 516 const sal_Char* msg ) 517 { 518 rtl_TestResult_Data* pData = (rtl_TestResult_Data*) pThis_; 519 520 if( msg ) 521 { 522 if (! pData->m_state->m_cmp ) 523 pData->m_state->m_cmp = rtl_tres_create_cmpstate( sal_True, msg ); 524 else 525 rtl_tres_link_cmpstate( pData->m_state->m_cmp, 526 rtl_tres_create_cmpstate( sal_True, msg ) ); 527 } 528 pData->m_state->m_prev->m_flags |= rtl_tres_Flag_PASSED; 529 pData->m_state->m_flags |= rtl_tres_Flag_PASSED; 530 pData->m_state->m_stop = rtl_tres_timer(); 531 } 532 533 534 static sal_Bool SAL_CALL rtl_tres_ispassed( rtl_TestResult* pThis_ ) 535 { 536 return rtl_tres_isbit( pThis_, rtl_tres_Flag_PASSED ); 537 } 538 539 static sal_Bool SAL_CALL rtl_tres_isok( rtl_TestResult* pThis_ ) 540 { 541 return rtl_tres_isbit( pThis_, rtl_tres_Flag_OK ); 542 } 543 /** 544 * return pointer to funcstate structure 545 */ 546 static rtl_funcstate SAL_CALL rtl_tres_funcstate( rtl_TestResult* pThis_ ) 547 { 548 549 rtl_TestResult_Data* pThis = (rtl_TestResult_Data*) pThis_; 550 return (rtl_funcstate)pThis->m_state; 551 } 552 553 /** 554 * determine if a flag is set or not 555 */ 556 static sal_Bool SAL_CALL rtl_tres_isbit( rtl_TestResult* pThis_, 557 sal_uInt32 flag ) 558 { 559 return (sal_Bool) 560 ((((rtl_TestResult_Data *) pThis_)->m_state->m_flags & flag) == flag); 561 } 562 /** 563 * set one single bit 564 */ 565 static void SAL_CALL rtl_tres_setbit( rtl_FuncState* pState_, 566 sal_uInt32 flag ) 567 { 568 pState_->m_flags |= flag; 569 } 570 /** 571 * clear one single bit 572 */ 573 static void SAL_CALL rtl_tres_clearbit( rtl_FuncState* pState_, 574 sal_uInt32 flag ) 575 { 576 pState_->m_flags = pState_->m_flags & ( ~flag ); 577 } 578 579 /** 580 * returns next pointer of passed funcstate structure 581 */ 582 rtl_funcstate SAL_CALL rtl_tres_getnextfuncstate( rtl_funcstate fstate ) 583 { 584 rtl_FuncState* fs = (rtl_FuncState*)fstate; 585 return( (rtl_funcstate)fs->m_next ); 586 587 } 588 /** 589 * returns previous pointer of passed funcstate structure 590 */ 591 rtl_funcstate SAL_CALL rtl_tres_getprevfuncstate( rtl_funcstate fstate ) 592 { 593 rtl_FuncState* fs = (rtl_FuncState*)fstate; 594 return( (rtl_funcstate)fs->m_prev ); 595 596 } 597 /** 598 * returns flag value of passed funcstate structure 599 */ 600 sal_uInt32 SAL_CALL rtl_tres_getflags( rtl_funcstate fstate ) 601 { 602 rtl_FuncState* fs = (rtl_FuncState*)fstate; 603 return( fs->m_flags ); 604 } 605 /** 606 * returns name of passed funcstate structure 607 */ 608 rtl_String* SAL_CALL rtl_tres_getname( rtl_funcstate fstate ) 609 { 610 rtl_FuncState* fs = (rtl_FuncState*)fstate; 611 return( fs->m_name ); 612 } 613 /** 614 * returns starttime of passed funcstate structure 615 */ 616 sal_uInt32 SAL_CALL rtl_tres_getstarttime( rtl_funcstate fstate ) 617 { 618 rtl_FuncState* fs = (rtl_FuncState*)fstate; 619 return( fs->m_start ); 620 } 621 622 /** 623 * returns stoptime of passed funcstate structure 624 */ 625 sal_uInt32 SAL_CALL rtl_tres_getstoptime( rtl_funcstate fstate ) 626 { 627 rtl_FuncState* fs = (rtl_FuncState*)fstate; 628 return( fs->m_stop ); 629 } 630 631 /** 632 * returns pointer to cmpstate of passed funcstate structure 633 */ 634 rtl_cmpstate SAL_CALL rtl_tres_getcmpstate( rtl_funcstate fstate) 635 { 636 rtl_FuncState* fs = (rtl_FuncState*)fstate; 637 return( (rtl_cmpstate)fs->m_cmp ); 638 639 } 640 /** 641 * returns boolean state of passed cmpstate structure 642 */ 643 sal_Bool SAL_CALL rtl_tres_getstat( rtl_cmpstate cstate) 644 { 645 rtl_CmpState* cs = (rtl_CmpState*)cstate; 646 return( cs->m_stat ); 647 } 648 /** 649 * returns message of passed cmpstate structure 650 */ 651 rtl_String* SAL_CALL rtl_tres_getmsg( rtl_cmpstate cstate) 652 { 653 rtl_CmpState* cs = (rtl_CmpState*)cstate; 654 return( cs->m_msg ); 655 } 656 /** 657 * returns next pointer of passed cmpstate structure 658 */ 659 rtl_cmpstate SAL_CALL rtl_tres_getnextcmpstate( rtl_cmpstate cstate) 660 { 661 rtl_CmpState* cs = (rtl_CmpState*)cstate; 662 return( (rtl_cmpstate)cs->m_next ); 663 } 664 665 /* 666 // <method_logPrintf> 667 //inline void logPrintf ( const sal_Bool bTestCaseState, 668 // const char *pFormatStr, ... 669 // ) 670 //{ 671 // if( m_pFunctions && m_pFunctions->pLogPrintf ) 672 // { 673 // va_list vArgumentList; 674 // va_start ( vArgumentList, pFormatStr ); 675 676 // m_pFunctions->pLogPrintf( this, bTestCaseState, pFormatStr, vArgumentList ); 677 678 // va_end ( vArgumentList ); 679 // } 680 //} // </method_logPrintf> 681 */ 682 683