Attachment #4844 for issue #11742

View | Details | Raw Unified | Return to issue 11742
Collapse All | Expand All




	Test* pTest = this;

    // if (signalCheck(pTest->getName()) == HAS_SIGNAL)
	sal_Int32 nValue = (pCallbackFunc)(0, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, result, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);
	if (nValue == DO_NOT_EXECUTE)
    {
        return;
    }
    
	// (pTestResult_StartTest)(result, pTest);
    (pCallbackFunc)(0, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE);

	try 
	{

		{
			runTest();
			// (pTestResult_AddInfo)(result, pTest, "PASSED");
            (pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "PASSED", TAG_DONE);
		}
		catch ( StubException &e)
		{
			(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "STUB", TAG_DONE );
		}
		catch ( Exception &e ) 
		{
			Exception *copy = e.clone();
			// (pTestResult_AddFailure)( result, pTest, copy );
			(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );
		}
		catch ( std::exception &e ) 
		{
			// (pTestResult_AddError)( result, pTest, new Exception( e.what() ) );
			(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( e.what() ), TAG_DONE );
		}
		catch (...) 
		{
			Exception *e = new Exception( "caught unknown exception" );
			// (pTestResult_AddError)( result, pTest, e );
			(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );
		}
		
		try 

		catch (...) 
		{
			// (pTestResult_AddError)( result, pTest, new Exception( "tearDown() failed" ) );
			(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "tearDown() failed" ), TAG_DONE );
		}
	}
	catch (...) 
	{
		// (pTestResult_AddError)( result, pTest, new Exception( "setUp() failed" ) );
		(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "setUp() failed" ), TAG_DONE );
	}
	
	// (pTestResult_EndTest)( result, pTest );
	(pCallbackFunc)( 0, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE );
}

/// A default run method 

Lines 157-163 NamedRegistries::needDestroy( TestFactor Link Here

(-)source/cppunit/TestFactoryRegistry.cpp (-2 / +2 lines)
157	void NamedRegistries::testRegistries( hTestResult _pResult)	157	void NamedRegistries::testRegistries( hTestResult _pResult)
158	{	158	{
159	// initialise the test handling	159	// initialise the test handling
160	(pCallbackFunc)(NULL, TAG_TYPE, INIT_TEST, TAG_RESULT_PTR, _pResult, TAG_DONE);	160	(pCallbackFunc)(0, TAG_TYPE, INIT_TEST, TAG_RESULT_PTR, _pResult, TAG_DONE);
161		161
162	// Start signal based Check	162	// Start signal based Check
163	for (MapRegistries::const_iterator it = m_registries.begin();	163	for (MapRegistries::const_iterator it = m_registries.begin();
Lines 171-177 void NamedRegistries::testRegistries( hT Link Here
171	}	171	}
172		172
173	// release test handling	173	// release test handling
174	(pCallbackFunc)(NULL, TAG_TYPE, RELEASE_TEST, TAG_RESULT_PTR, _pResult, TAG_DONE);	174	(pCallbackFunc)(0, TAG_TYPE, RELEASE_TEST, TAG_RESULT_PTR, _pResult, TAG_DONE);
175	// start normal based tests, leave signal signed tests out.	175	// start normal based tests, leave signal signed tests out.
176		176
177	//! Allfunction in the inclusion list which has a flag, not found, has to call here.	177	//! Allfunction in the inclusion list which has a flag, not found, has to call here.




TestSuite::run( hTestResult result )
{
	// (pTestResult_EnterNode)(result, getName().c_str());
	(pCallbackFunc)(0, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);
	for ( std::vector<Test *>::iterator it = m_tests.begin();
		  it != m_tests.end();
		  ++it )

		//# if ( result->shouldStop() )
		//#     break;
		// if ( pTestResult_ShouldStop(result) )
		if ( (pCallbackFunc)(0, TAG_TYPE, RESULT_SHOULD_STOP, TAG_RESULT_PTR, result, TAG_DONE) )
		{
			break;
		}

		test->run( result );
	}
	// (pTestResult_LeaveNode)(result, getName().c_str());
	(pCallbackFunc)(0, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);
}






			 m_pName(_pName)
{
    // (pTestResult_EnterNode)(m_aResult, m_pName);
    (pCallbackFunc)( 0, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);
}
rtl_tres_state_start::~rtl_tres_state_start()
{
    // (pTestResult_LeaveNode)(m_aResult, m_pName);
    (pCallbackFunc)(0, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);
}

// --------------------------------- C-Wrapper ---------------------------------

{
    CppUnit::Test* pTest = new WrappedTest(pFuncName);
    
    sal_Int32 nValue = (pCallbackFunc)(0, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, pResult, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);
    if (nValue == DO_NOT_EXECUTE)
    {
        return false;

    // This code is copied from CppUnit::TestCase and less adapted, to work with the
    // old test code.
    // (pTestResult_StartTest)(pResult, pTest);
    (pCallbackFunc)(0, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE);
    
    try 
    {
        CPPUNIT_ASSERT_MESSAGE( pTestMsg, bSuccess ? true : false );
        // (pTestResult_AddInfo)(pResult, pTest, "#PASSED#");
        (pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_INFO, "#PASSED#", TAG_DONE);
    }
    catch ( CppUnit::Exception &e ) 
    {
        CppUnit::Exception *copy = e.clone();
        // (pTestResult_AddFailure)( pResult, pTest, copy );
        (pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );
    }
    catch ( std::exception &e ) 
    {
        //(pTestResult_AddError)( pResult, pTest, new CppUnit::Exception( e.what() ) );
        (pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new CppUnit::Exception( e.what() ), TAG_DONE );
    }
    catch (...) 
    {
        CppUnit::Exception *e = new CppUnit::Exception( "caught unknown exception" );
        // (pTestResult_AddError)( pResult, pTest, e );
        (pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );
    }
    

    // (pTestResult_EndTest)( pResult, pTest );
    (pCallbackFunc)( 0, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE );
    
    return bSuccess;
}




//#             << ")" << std::endl;
//#         // out << sLastTestFunctionName << std::endl;               // SIGNAL!

		fprintf(out, "# the previous test function creates signal: %s(%d)\n",
						getSignalName(_nSignalNo).c_str(), _nSignalNo);
		// fprintf(out, "%s\n", sLastTestFunctionName );
		fclose(out);
    }

        if (out != NULL)
        {
            // out << buildTestFunctionName(_sName) << std::endl;
			fprintf(out, "%s\n", buildTestFunctionName(_sName).c_str());
			fclose(out);
        }
		else

{
    sal_Int32 nRetValue = 0;
    TagData nTagType     = _aTagItems.GetTagData(TAG_TYPE, 0);
    hTestResult hResult  = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR,0);
    CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;
    
    try


        case SIGNAL_START_TEST:
        {
            const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
            if (sName != NULL)
            {
                signalStartTest(sName);

                
        case SIGNAL_END_TEST:
        {
            const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
            if (sName != NULL)
            {
                signalEndTest(sName);

{
    sal_Int32 nRetValue = 0;
    TagData nTagType     = _aTagItems.GetTagData(TAG_TYPE, 0);
    hTestResult hResult  = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR,0);
    CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;

    try

        {
        case EXECUTION_CHECK:
        {
            const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
            if (sName) nRetValue = CheckExecution(pResult, sName);
  
            break;




        CppUnit::Test*       pTest   = (CppUnit::Test*)_pTest;

        std::string sName = pTest->getName();
        CallbackDispatch(0, TAG_TYPE, SIGNAL_START_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);

        pResult->startTest(pTest);
    }

        pResult->endTest(pTest);

        std::string sName = pTest->getName();
        CallbackDispatch(0, TAG_TYPE, SIGNAL_END_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);
    }
	
// -----------------------------------------------------------------------------

    {
        sal_Int32 nRetValue = 0;
        TagData nTagType     = _aTagItems.GetTagData(TAG_TYPE, 0);
        hTestResult pResult  = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR, 0);
        CppUnit::Test* pTest = (CppUnit::Test*) _aTagItems.GetTagData(TAG_TEST_PTR, 0);
		
        try
        {

				
            case RESULT_ADD_FAILURE:
            {
                hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, 0);
                TestResult_addFailure(pResult, pTest, pException);
                break;
            }
			
            case RESULT_ADD_ERROR:
            {
                hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, 0);
                TestResult_addError(pResult, pTest, pException);
                break;
            }
			
            case RESULT_ADD_INFO:
            {
                const char* pInfo = (const char* ) _aTagItems.GetTagData(TAG_INFO, 0);
                TestResult_addInfo(pResult, pTest, pInfo);
                break;
            }
			
            case RESULT_ENTER_NODE:
            {
                const char* pNode = (const char* )_aTagItems.GetTagData(TAG_NODENAME, 0);
                TestResult_enterNode(pResult, pNode);
                break;
            }
			
            case RESULT_LEAVE_NODE:
            {
                const char* pNode = (const char* ) _aTagItems.GetTagData(TAG_NODENAME, 0);
                TestResult_leaveNode(pResult, pNode);
                break;
            }

	// printf(".\n");

    sal_Int32 nRetValue = 0;
    Tag nPreTag = aTagItems.GetTagData(TAG_TYPE,0);
    if ( (nPreTag & TAG_RESULT) == TAG_RESULT)
    {
        nRetValue = TestResult_StarterA( aTagItems );

Return to issue 11742

Lines 66-79 TestCase::run( hTestResult result ) Link Here

(-)source/cppunit/TestCase.cpp (-10 / +10 lines)
66	Test* pTest = this;	66	Test* pTest = this;
67		67
68	// if (signalCheck(pTest->getName()) == HAS_SIGNAL)	68	// if (signalCheck(pTest->getName()) == HAS_SIGNAL)
69	sal_Int32 nValue = (pCallbackFunc)(NULL, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, result, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);	69	sal_Int32 nValue = (pCallbackFunc)(0, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, result, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);
70	if (nValue == DO_NOT_EXECUTE)	70	if (nValue == DO_NOT_EXECUTE)
71	{	71	{
72	return;	72	return;
73	}	73	}
74		74
75	// (pTestResult_StartTest)(result, pTest);	75	// (pTestResult_StartTest)(result, pTest);
76	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE);	76	(pCallbackFunc)(0, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE);
77		77
78	try	78	try
79	{	79	{
Lines 83-110 TestCase::run( hTestResult result ) Link Here
83	{	83	{
84	runTest();	84	runTest();
85	// (pTestResult_AddInfo)(result, pTest, "PASSED");	85	// (pTestResult_AddInfo)(result, pTest, "PASSED");
86	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "PASSED", TAG_DONE);	86	(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "PASSED", TAG_DONE);
87	}	87	}
88	catch ( StubException &e)	88	catch ( StubException &e)
89	{	89	{
90	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "STUB", TAG_DONE );	90	(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_INFO, "STUB", TAG_DONE );
91	}	91	}
92	catch ( Exception &e )	92	catch ( Exception &e )
93	{	93	{
94	Exception *copy = e.clone();	94	Exception *copy = e.clone();
95	// (pTestResult_AddFailure)( result, pTest, copy );	95	// (pTestResult_AddFailure)( result, pTest, copy );
96	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );	96	(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );
97	}	97	}
98	catch ( std::exception &e )	98	catch ( std::exception &e )
99	{	99	{
100	// (pTestResult_AddError)( result, pTest, new Exception( e.what() ) );	100	// (pTestResult_AddError)( result, pTest, new Exception( e.what() ) );
101	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( e.what() ), TAG_DONE );	101	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( e.what() ), TAG_DONE );
102	}	102	}
103	catch (...)	103	catch (...)
104	{	104	{
105	Exception *e = new Exception( "caught unknown exception" );	105	Exception *e = new Exception( "caught unknown exception" );
106	// (pTestResult_AddError)( result, pTest, e );	106	// (pTestResult_AddError)( result, pTest, e );
107	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );	107	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );
108	}	108	}
109		109
110	try	110	try
Lines 114-130 TestCase::run( hTestResult result ) Link Here
114	catch (...)	114	catch (...)
115	{	115	{
116	// (pTestResult_AddError)( result, pTest, new Exception( "tearDown() failed" ) );	116	// (pTestResult_AddError)( result, pTest, new Exception( "tearDown() failed" ) );
117	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "tearDown() failed" ), TAG_DONE );	117	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "tearDown() failed" ), TAG_DONE );
118	}	118	}
119	}	119	}
120	catch (...)	120	catch (...)
121	{	121	{
122	// (pTestResult_AddError)( result, pTest, new Exception( "setUp() failed" ) );	122	// (pTestResult_AddError)( result, pTest, new Exception( "setUp() failed" ) );
123	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "setUp() failed" ), TAG_DONE );	123	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new Exception( "setUp() failed" ), TAG_DONE );
124	}	124	}
125		125
126	// (pTestResult_EndTest)( result, pTest );	126	// (pTestResult_EndTest)( result, pTest );
127	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE );	127	(pCallbackFunc)( 0, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, result, TAG_TEST_PTR, pTest, TAG_DONE );
128	}	128	}
129		129
130	/// A default run method	130	/// A default run method

Lines 190-196 void markSignalAsAlreadyDone(sal_Int32 _ Link Here

(-)source/result/signal.cxx (-7 / +8 lines)
190	//# << ")" << std::endl;	190	//# << ")" << std::endl;
191	//# // out << sLastTestFunctionName << std::endl; // SIGNAL!	191	//# // out << sLastTestFunctionName << std::endl; // SIGNAL!
192		192
193	fprintf(out, "# the previous test function creates signal: %s(%d)\n", getSignalName(_nSignalNo), _nSignalNo);	193	fprintf(out, "# the previous test function creates signal: %s(%d)\n",
		194	getSignalName(_nSignalNo).c_str(), _nSignalNo);
194	// fprintf(out, "%s\n", sLastTestFunctionName );	195	// fprintf(out, "%s\n", sLastTestFunctionName );
195	fclose(out);	196	fclose(out);
196	}	197	}
Lines 538-544 void signalStartTest(std::string const& Link Here
538	if (out != NULL)	539	if (out != NULL)
539	{	540	{
540	// out << buildTestFunctionName(_sName) << std::endl;	541	// out << buildTestFunctionName(_sName) << std::endl;
541	fprintf(out, "%s\n", buildTestFunctionName(_sName));	542	fprintf(out, "%s\n", buildTestFunctionName(_sName).c_str());
542	fclose(out);	543	fclose(out);
543	}	544	}
544	else	545	else
Lines 575-581 sal_Int32 SignalHandlerA( TagHelper cons Link Here
575	{	576	{
576	sal_Int32 nRetValue = 0;	577	sal_Int32 nRetValue = 0;
577	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);	578	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);
578	hTestResult hResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR, NULL);	579	hTestResult hResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR,0);
579	CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;	580	CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;
580		581
581	try	582	try
Lines 614-620 sal_Int32 SignalHandlerA( TagHelper cons Link Here
614		615
615	case SIGNAL_START_TEST:	616	case SIGNAL_START_TEST:
616	{	617	{
617	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME);	618	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
618	if (sName != NULL)	619	if (sName != NULL)
619	{	620	{
620	signalStartTest(sName);	621	signalStartTest(sName);
Lines 624-630 sal_Int32 SignalHandlerA( TagHelper cons Link Here
624		625
625	case SIGNAL_END_TEST:	626	case SIGNAL_END_TEST:
626	{	627	{
627	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME);	628	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
628	if (sName != NULL)	629	if (sName != NULL)
629	{	630	{
630	signalEndTest(sName);	631	signalEndTest(sName);
Lines 675-681 sal_Int32 ExecutionA( TagHelper const& _ Link Here
675	{	676	{
676	sal_Int32 nRetValue = 0;	677	sal_Int32 nRetValue = 0;
677	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);	678	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);
678	hTestResult hResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR, NULL);	679	hTestResult hResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR,0);
679	CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;	680	CppUnit::TestResult* pResult = (CppUnit::TestResult*)hResult;
680		681
681	try	682	try
Lines 684-690 sal_Int32 ExecutionA( TagHelper const& _ Link Here
684	{	685	{
685	case EXECUTION_CHECK:	686	case EXECUTION_CHECK:
686	{	687	{
687	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME);	688	const char* sName = (const char*) _aTagItems.GetTagData(TAG_NODENAME,0);
688	if (sName) nRetValue = CheckExecution(pResult, sName);	689	if (sName) nRetValue = CheckExecution(pResult, sName);
689		690
690	break;	691	break;

Lines 79-85 namespace Link Here

(-)source/result/treswrapper.cxx (-10 / +10 lines)
79	CppUnit::Test* pTest = (CppUnit::Test*)_pTest;	79	CppUnit::Test* pTest = (CppUnit::Test*)_pTest;
80		80
81	std::string sName = pTest->getName();	81	std::string sName = pTest->getName();
82	CallbackDispatch(NULL, TAG_TYPE, SIGNAL_START_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);	82	CallbackDispatch(0, TAG_TYPE, SIGNAL_START_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);
83		83
84	pResult->startTest(pTest);	84	pResult->startTest(pTest);
85	}	85	}
Lines 91-97 namespace Link Here
91	pResult->endTest(pTest);	91	pResult->endTest(pTest);
92		92
93	std::string sName = pTest->getName();	93	std::string sName = pTest->getName();
94	CallbackDispatch(NULL, TAG_TYPE, SIGNAL_END_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);	94	CallbackDispatch(0, TAG_TYPE, SIGNAL_END_TEST, TAG_RESULT_PTR, _pResult, TAG_NODENAME, sName.c_str(), TAG_DONE);
95	}	95	}
96		96
97	// -----------------------------------------------------------------------------	97	// -----------------------------------------------------------------------------
Lines 152-159 namespace Link Here
152	{	152	{
153	sal_Int32 nRetValue = 0;	153	sal_Int32 nRetValue = 0;
154	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);	154	TagData nTagType = _aTagItems.GetTagData(TAG_TYPE, 0);
155	hTestResult pResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR, NULL);	155	hTestResult pResult = (hTestResult) _aTagItems.GetTagData(TAG_RESULT_PTR, 0);
156	CppUnit::Test* pTest = (CppUnit::Test*) _aTagItems.GetTagData(TAG_TEST_PTR, NULL);	156	CppUnit::Test* pTest = (CppUnit::Test*) _aTagItems.GetTagData(TAG_TEST_PTR, 0);
157		157
158	try	158	try
159	{	159	{
Lines 169-203 namespace Link Here
169		169
170	case RESULT_ADD_FAILURE:	170	case RESULT_ADD_FAILURE:
171	{	171	{
172	hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, NULL);	172	hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, 0);
173	TestResult_addFailure(pResult, pTest, pException);	173	TestResult_addFailure(pResult, pTest, pException);
174	break;	174	break;
175	}	175	}
176		176
177	case RESULT_ADD_ERROR:	177	case RESULT_ADD_ERROR:
178	{	178	{
179	hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, NULL);	179	hException pException = (hException) _aTagItems.GetTagData(TAG_EXCEPTION, 0);
180	TestResult_addError(pResult, pTest, pException);	180	TestResult_addError(pResult, pTest, pException);
181	break;	181	break;
182	}	182	}
183		183
184	case RESULT_ADD_INFO:	184	case RESULT_ADD_INFO:
185	{	185	{
186	const char* pInfo = (const char* ) _aTagItems.GetTagData(TAG_INFO, NULL);	186	const char* pInfo = (const char* ) _aTagItems.GetTagData(TAG_INFO, 0);
187	TestResult_addInfo(pResult, pTest, pInfo);	187	TestResult_addInfo(pResult, pTest, pInfo);
188	break;	188	break;
189	}	189	}
190		190
191	case RESULT_ENTER_NODE:	191	case RESULT_ENTER_NODE:
192	{	192	{
193	const char* pNode = (const char* )_aTagItems.GetTagData(TAG_NODENAME, NULL);	193	const char* pNode = (const char* )_aTagItems.GetTagData(TAG_NODENAME, 0);
194	TestResult_enterNode(pResult, pNode);	194	TestResult_enterNode(pResult, pNode);
195	break;	195	break;
196	}	196	}
197		197
198	case RESULT_LEAVE_NODE:	198	case RESULT_LEAVE_NODE:
199	{	199	{
200	const char* pNode = (const char* ) _aTagItems.GetTagData(TAG_NODENAME, NULL);	200	const char* pNode = (const char* ) _aTagItems.GetTagData(TAG_NODENAME, 0);
201	TestResult_leaveNode(pResult, pNode);	201	TestResult_leaveNode(pResult, pNode);
202	break;	202	break;
203	}	203	}
Lines 263-269 sal_Int32 CallbackDispatch(int x, ...) Link Here
263	// printf(".\n");	263	// printf(".\n");
264		264
265	sal_Int32 nRetValue = 0;	265	sal_Int32 nRetValue = 0;
266	Tag nPreTag = aTagItems.GetTagData(TAG_TYPE);	266	Tag nPreTag = aTagItems.GetTagData(TAG_TYPE,0);
267	if ( (nPreTag & TAG_RESULT) == TAG_RESULT)	267	if ( (nPreTag & TAG_RESULT) == TAG_RESULT)
268	{	268	{
269	nRetValue = TestResult_StarterA( aTagItems );	269	nRetValue = TestResult_StarterA( aTagItems );

Lines 39-45 void Link Here

(-)source/cppunit/TestSuite.cpp (-3 / +3 lines)
39	TestSuite::run( hTestResult result )	39	TestSuite::run( hTestResult result )
40	{	40	{
41	// (pTestResult_EnterNode)(result, getName().c_str());	41	// (pTestResult_EnterNode)(result, getName().c_str());
42	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);	42	(pCallbackFunc)(0, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);
43	for ( std::vector<Test *>::iterator it = m_tests.begin();	43	for ( std::vector<Test *>::iterator it = m_tests.begin();
44	it != m_tests.end();	44	it != m_tests.end();
45	++it )	45	++it )
Lines 47-53 TestSuite::run( hTestResult result ) Link Here
47	//# if ( result->shouldStop() )	47	//# if ( result->shouldStop() )
48	//# break;	48	//# break;
49	// if ( pTestResult_ShouldStop(result) )	49	// if ( pTestResult_ShouldStop(result) )
50	if ( (pCallbackFunc)(NULL, TAG_TYPE, RESULT_SHOULD_STOP, TAG_RESULT_PTR, result, TAG_DONE) )	50	if ( (pCallbackFunc)(0, TAG_TYPE, RESULT_SHOULD_STOP, TAG_RESULT_PTR, result, TAG_DONE) )
51	{	51	{
52	break;	52	break;
53	}	53	}
Lines 55-61 TestSuite::run( hTestResult result ) Link Here
55	test->run( result );	55	test->run( result );
56	}	56	}
57	// (pTestResult_LeaveNode)(result, getName().c_str());	57	// (pTestResult_LeaveNode)(result, getName().c_str());
58	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);	58	(pCallbackFunc)(0, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, result, TAG_NODENAME, getName().c_str(), TAG_DONE);
59	}	59	}
60		60
61		61

Lines 111-122 rtl_tres_state_start::rtl_tres_state_sta Link Here

(-)source/cppunit/tresstatewrapper.cxx (-9 / +9 lines)
111	m_pName(_pName)	111	m_pName(_pName)
112	{	112	{
113	// (pTestResult_EnterNode)(m_aResult, m_pName);	113	// (pTestResult_EnterNode)(m_aResult, m_pName);
114	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);	114	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ENTER_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);
115	}	115	}
116	rtl_tres_state_start::~rtl_tres_state_start()	116	rtl_tres_state_start::~rtl_tres_state_start()
117	{	117	{
118	// (pTestResult_LeaveNode)(m_aResult, m_pName);	118	// (pTestResult_LeaveNode)(m_aResult, m_pName);
119	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);	119	(pCallbackFunc)(0, TAG_TYPE, RESULT_LEAVE_NODE, TAG_RESULT_PTR, m_aResult, TAG_NODENAME, m_pName, TAG_DONE);
120	}	120	}
121		121
122	// --------------------------------- C-Wrapper ---------------------------------	122	// --------------------------------- C-Wrapper ---------------------------------
Lines 152-158 sal_Bool SAL_CALL c_rtl_tres_state( Link Here
152	{	152	{
153	CppUnit::Test* pTest = new WrappedTest(pFuncName);	153	CppUnit::Test* pTest = new WrappedTest(pFuncName);
154		154
155	sal_Int32 nValue = (pCallbackFunc)(NULL, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, pResult, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);	155	sal_Int32 nValue = (pCallbackFunc)(0, TAG_TYPE, EXECUTION_CHECK, TAG_RESULT_PTR, pResult, TAG_NODENAME, pTest->getName().c_str(), TAG_DONE);
156	if (nValue == DO_NOT_EXECUTE)	156	if (nValue == DO_NOT_EXECUTE)
157	{	157	{
158	return false;	158	return false;
Lines 161-195 sal_Bool SAL_CALL c_rtl_tres_state( Link Here
161	// This code is copied from CppUnit::TestCase and less adapted, to work with the	161	// This code is copied from CppUnit::TestCase and less adapted, to work with the
162	// old test code.	162	// old test code.
163	// (pTestResult_StartTest)(pResult, pTest);	163	// (pTestResult_StartTest)(pResult, pTest);
164	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE);	164	(pCallbackFunc)(0, TAG_TYPE, RESULT_START, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE);
165		165
166	try	166	try
167	{	167	{
168	CPPUNIT_ASSERT_MESSAGE( pTestMsg, bSuccess ? true : false );	168	CPPUNIT_ASSERT_MESSAGE( pTestMsg, bSuccess ? true : false );
169	// (pTestResult_AddInfo)(pResult, pTest, "#PASSED#");	169	// (pTestResult_AddInfo)(pResult, pTest, "#PASSED#");
170	(pCallbackFunc)(NULL, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_INFO, "#PASSED#", TAG_DONE);	170	(pCallbackFunc)(0, TAG_TYPE, RESULT_ADD_INFO, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_INFO, "#PASSED#", TAG_DONE);
171	}	171	}
172	catch ( CppUnit::Exception &e )	172	catch ( CppUnit::Exception &e )
173	{	173	{
174	CppUnit::Exception *copy = e.clone();	174	CppUnit::Exception *copy = e.clone();
175	// (pTestResult_AddFailure)( pResult, pTest, copy );	175	// (pTestResult_AddFailure)( pResult, pTest, copy );
176	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );	176	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_FAILURE, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, copy, TAG_DONE );
177	}	177	}
178	catch ( std::exception &e )	178	catch ( std::exception &e )
179	{	179	{
180	//(pTestResult_AddError)( pResult, pTest, new CppUnit::Exception( e.what() ) );	180	//(pTestResult_AddError)( pResult, pTest, new CppUnit::Exception( e.what() ) );
181	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new CppUnit::Exception( e.what() ), TAG_DONE );	181	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, new CppUnit::Exception( e.what() ), TAG_DONE );
182	}	182	}
183	catch (...)	183	catch (...)
184	{	184	{
185	CppUnit::Exception *e = new CppUnit::Exception( "caught unknown exception" );	185	CppUnit::Exception *e = new CppUnit::Exception( "caught unknown exception" );
186	// (pTestResult_AddError)( pResult, pTest, e );	186	// (pTestResult_AddError)( pResult, pTest, e );
187	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );	187	(pCallbackFunc)( 0, TAG_TYPE, RESULT_ADD_ERROR, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_EXCEPTION, e, TAG_DONE );
188	}	188	}
189		189
190		190
191	// (pTestResult_EndTest)( pResult, pTest );	191	// (pTestResult_EndTest)( pResult, pTest );
192	(pCallbackFunc)( NULL, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE );	192	(pCallbackFunc)( 0, TAG_TYPE, RESULT_END, TAG_RESULT_PTR, pResult, TAG_TEST_PTR, pTest, TAG_DONE );
193		193
194	return bSuccess;	194	return bSuccess;
195	}	195	}