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