C++ d3函数代码示例

/******************************************************************************
 *	De-init Semaphore sub-module
 *
 *	Parameter:
 *		None
 *
 *	Return value:
 *		0					Success
 *****************************************************************************/
OSA_RESULT	osa_sem_release(void)
{
	list_t *plist;
	SemHandle_t *phandle;

    d3(printf("osa_sem_release:\n"));
	
    if( g_pSems ) {
        /* delete all open semaphores */
        plist = &(g_pSems->list);
        while( plist->next != plist->prev ) {
            phandle = list_entry(plist, SemHandle_t, list);

            osa_sem_delete( (OSA_HANDLE) phandle );
        }

        sem_destroy( &g_ListMux );

        memset(g_pSems, 0, sizeof(SemHandle_t));
        free(g_pSems);
        g_pSems = NULL;
    }

    d3(printf("osa_sem_release: end\n"));

	return 0;
}

/******************************************************************************
 *  Initialize Portable layer Thread functions
 *
 *  Parameter:
 *      NONE
 *  Return value:
 *      0                   successful
 *****************************************************************************/
OSA_RESULT  osa_t_init(void)
{
    struct sched_param  sparam;
    pid_t               mypid;

    d3(printf("osa_t_init:\n"));
    
    /* setup thread handle list */
    g_ThreadList = (ThreadHandle_t*) malloc( sizeof(ThreadHandle_t) );
    memset(g_ThreadList, 0, sizeof(ThreadHandle_t));
    INIT_LIST_HEAD( &(g_ThreadList->list) );
    g_ThreadList->id = 0;
    g_ThreadList->magic = OSA_T_MAGIC;

    /* create, set tid tsd */
    if( _osa_tid_key == -1 )
        _osa_tsd_create(&_osa_tid_key);
    _osa_tsd_set( &_osa_tid_key, (size_t) g_ThreadList);

    /* set my schedule policy ?*/
    #if 1
    mypid = getpid();
    sched_getparam(mypid,&sparam);
    sparam.sched_priority = (OSA_T_LNX_PRIORITY_MAX - OSA_T_LNX_PRIORITY_MIN + 1)/2;
    sched_setscheduler(mypid, SCHED_RR, &sparam);
    //sched_setscheduler(mypid,SCHED_OTHER,&sparam);
    #endif

    // setup thread signal actions
    _osa_t_setup_signal();

    d3(printf("osa_t_init: end\n"));
    
    return 0;
}

/******************************************************************************
 *	Deinit mutex sub-module
 *
 *	Parameter:
 *		None
 *
 *	Return value:
 *		0					Success
 *****************************************************************************/
OSA_RESULT	osa_mu_release(void)
{
	MutexHandle_t	*phandle;
    list_t          *plist;

	d3(printf( "osa_mu_release:\n"));

    if( g_pMutexs ) {
        plist = &(g_pMutexs->list);
        while( plist->next != plist->prev ) {
            phandle = list_entry( &(plist->next), MutexHandle_t, list);

            osa_mu_delete( (OSA_HANDLE) phandle);
        }

        sem_destroy( &g_ListMux );

        memset(g_pMutexs, 0, sizeof(MutexHandle_t));
        free(g_pMutexs);
        g_pMutexs = NULL;
    }

    d3(printf("osa_mu_release: end\n"));

	return 0;
}

/******************************************************************************
 *  Release Portable layer Thread enviroment
 *
 *  Parameter:
 *      NONE
 *  Return value:
 *      0                   successful
 *****************************************************************************/
OSA_RESULT  osa_t_release(void)
{
    list_t          *list;
    ThreadHandle_t  *handle;

    d3(printf("osa_t_release:\n"));

    if( g_ThreadList ) {
        /* stop all thread & delete thread handle list */
        list = &(g_ThreadList->list);
        while( list->next != list->prev ) {
            handle = list_entry(list->next, ThreadHandle_t, list);

            /* if it state isn't STOP then stop it */
            if( handle->state != OSA_TS_STOP ) {
                osa_t_kill((OSA_HANDLE) handle);
            }

            /* delete thread resource */
            osa_t_delete( (OSA_HANDLE) handle );
        }
    }

    d3(printf("osa_t_release: end\n"));
    
    return 0;
}

/******************************************************************************
 *	Create mutex
 *
 *	Parameter:
 *		hMu					[out] Mutex's handle
 *		mode				[in] create flags
 *
 *	Return value:
 *		0					Success
 *****************************************************************************/
OSA_RESULT	osa_mu_create(OSA_HANDLE *hMu, ru32 mode)
{
	MutexHandle_t *phandle;

    d3(printf("osa_mu_create: mode:%d\n", mode));
	
    phandle = (MutexHandle_t*) malloc(sizeof(MutexHandle_t));
	if( phandle == NULL ) {
        d1(printf("osa_mu_create: malloc fail\n"));
		return E_OSA_MEM;
	}
	memset(phandle, 0, sizeof(MutexHandle_t));

	INIT_LIST_HEAD( &(phandle->list) );
	phandle->magic = OSA_MU_MAGIC;
	pthread_mutex_init( &(phandle->handle), NULL );

	/* now insert into list */
    if( g_pMutexs ) {
        sem_wait( &(g_ListMux) );
        list_add( &(phandle->list), &(g_pMutexs->list) );
        sem_post( &(g_ListMux) );
    }

	*hMu = (OSA_HANDLE) phandle;

    d3(printf("osa_mu_create: end\n"));

	return 0;
}

/******************************************************************************
 *  Local: set thread specifice data
 *
 *  Parameter:
 *      threadvar               Thread's TSD
 *      value                   TSD
 *
 *  Return value:
 *      0                       Success
 *****************************************************************************/
static void _sig_suspend_handler(ri32 signo)
{
    ThreadHandle_t  *handle;
    ri32            ret;
    sigset_t        mask;

    handle = (ThreadHandle_t *) osa_t_self();
    if( _osa_t_checkHandle(handle) ) {
        d1(printf("_sig_suspend_handler: thread's handle error!\n"));
        return;
    }

    d3(printf("_sig_suspend_handler: id=%x\n", handle->id));

    ret = sem_trywait( &(handle->th_sem) );
    if( 0 != ret ) {
        d1(printf("_sig_suspend_handler: cant tyrwait semaphore!"));
        return ;
    }
        
    if( OSA_TO_SUSPEND == handle->op) {
        /* check current thread state */
        if (OSA_TS_RUN != handle->state) {
            d1(printf("_sig_suspend_handler: error thread state!\n"));
            sem_post( &(handle->th_sem) );
            return ;
        }

        sigemptyset(&mask);
        pthread_sigmask(SIG_BLOCK, &mask, &mask);
        sigdelset(&mask, THREAD_SIG_CONTINUE);

        handle->state = OSA_TS_SUSPEND;

        sem_post( &(handle->th_sem) );
        sem_post( &(handle->suspend_sem) );
        
        do {
            sigsuspend(&mask);
        } while ( OSA_TO_CONTINUE != handle->op );

        /* set state to RUNNING */
        sem_wait( &(handle->th_sem) );
        handle->state = OSA_TS_RUN;
        sem_post( &(handle->th_sem) );

        d3(printf( "_sig_suspend_handler: end\n"));
        
        return;
    }

    d2(printf("_sig_suspend_handler: error operation code.\n"));

    sem_post( &(handle->th_sem));
}

/******************************************************************************
 *	Initialize Semaphore sub-module
 *
 *	Parameter:
 *		None
 *
 *	Return value:
 *		0					Success
 *****************************************************************************/
OSA_RESULT	osa_sem_init(void)
{
    d3(printf("osa_sem_init:\n"));
	
    g_pSems = (SemHandle_t*) malloc(sizeof(SemHandle_t));
	g_pSems->magic = OSA_SEM_MAGIC;
	INIT_LIST_HEAD( &(g_pSems->list) );

	sem_init( &g_ListMux, 0, 1);

    d3(printf("osa_sem_init: end\n"));
	
	return 0;
}

static void veltranspose(float *vel,int ny,int nx,int nz)
{
    float *tmpvel=sf_floatalloc(ny*nx*nz);
    int nvel[2],ntmpvel[2];
    int i,iz,iy,ix;
    d3(ny,nx,nvel); d3(nx,nz,ntmpvel);
    for(i=0;i<ny*nx*nz;i++)
	tmpvel[i]=vel[i];
    for(iz=0;iz<nz;iz++)
	for(iy=0;iy<ny;iy++)
	    for(ix=0;ix<nx;ix++)
		vel[i3(iz,iy,ix,nvel)]=tmpvel[i3(iy,ix,iz,ntmpvel)];
    free(tmpvel); 
}

/******************************************************************************
 *  Resume a thread to run
 *
 *  Parameter:
 *      hTask                   [in] Thread's handle
 *
 *  Return value:
 *      0                       Success
 *****************************************************************************/
OSA_RESULT  osa_t_resume(OSA_HANDLE hTask)
{
    ThreadHandle_t  *handle;
    ri32            ret;

    handle = (ThreadHandle_t *) hTask;
    ret = _osa_t_checkHandle(handle);
    if( ret != 0 ) {
        d1(printf("osa_t_resume: given thread's handle error!\n"));
        return E_OSA_T_BADHANDLE;
    }

    d3(printf("osa_t_resume: ThreadID: %d\n", handle->id));

    sem_wait( &(handle->th_sem) );
    if( OSA_TS_STOP == handle->state ) {
        sem_post( &(handle->th_sem) );
        return E_OSA_T_NOSUSPEND;
    }

    if( (handle->suspend_count == 0) || (handle->state == OSA_TS_RUN) ) {
        sem_post( &(handle->th_sem) );
        return E_OSA_T_RUNNING;
    }
    
    handle->suspend_count --;
    if( handle->suspend_count > 0 ) {
        d2(printf("osa_t_resume: suspend count large than 2(%d)\n",
                  handle->suspend_count));
        sem_post( &(handle->th_sem) );

        return E_OSA_T_SUSPEND;
    }

    handle->op = OSA_TO_CONTINUE;
    ret = pthread_kill(handle->threadid, THREAD_SIG_CONTINUE);
    if ( 0 != ret ) {
        sem_post( &(handle->th_sem) );
        d1(printf("osa_t_resume: send THREAD_SIG_CONTINUE failed!\n"));
        return -1;
    }
    
    sem_post( &(handle->th_sem) );

    d3(printf( "osa_t_resume: end\n"));
    
    return 0;
}

/******************************************************************************
 *  Local: set thread specifice data
 *
 *  Parameter:
 *      threadvar               Thread's TSD
 *      value                   TSD
 *
 *  Return value:
 *      0                       Success
 *****************************************************************************/
static void _sig_kill_handler(ri32 signo)
{
    ThreadHandle_t *handle;

    d3(printf("_sgi_kill_handler:\n"));
    
    handle = (ThreadHandle_t *) osa_t_self();
    if( _osa_t_checkHandle(handle) ) {
        d1(printf("_sig_kill_handler: thread handle error!\n"));
        return;
    }

    sem_post( &(handle->kill_sem) );

    /* set state to STOP */
    sem_wait( &(handle->th_sem) );
    //d1(printf(">> set thread state to OSA_TS_STOP 4 (%5d)\n",
    //          osa_t_getid())); fflush(stdout);
    handle->state = OSA_TS_STOP;
    sem_post( &(handle->th_sem) );

    _osa_tsd_set( &_osa_tid_key, 0 );

    pthread_exit(0);
}

    void addTest()
    {
        csvsqldb::Duration d1(3, 1, 90, 17, 6, 45);
        d1.add(csvsqldb::Duration(5, 2, 1, 3, 7, 5));
        MPF_TEST_ASSERTEQUAL(8, d1.years());
        MPF_TEST_ASSERTEQUAL(3, d1.months());
        MPF_TEST_ASSERTEQUAL(91, d1.days());
        MPF_TEST_ASSERTEQUAL(20, d1.hours());
        MPF_TEST_ASSERTEQUAL(13, d1.minutes());
        MPF_TEST_ASSERTEQUAL(50, d1.seconds());

        csvsqldb::Duration d2(1, 2, 5);
        d2.add(d1);
        MPF_TEST_ASSERTEQUAL(9, d2.years());
        MPF_TEST_ASSERTEQUAL(5, d2.months());
        MPF_TEST_ASSERTEQUAL(96, d2.days());
        MPF_TEST_ASSERTEQUAL(20, d2.hours());
        MPF_TEST_ASSERTEQUAL(13, d2.minutes());
        MPF_TEST_ASSERTEQUAL(50, d2.seconds());
        MPF_TEST_ASSERTEQUAL(csvsqldb::Duration::Positive, d2.sign());

        csvsqldb::Duration d3(1, 2, 3, csvsqldb::Duration::Negative);
        MPF_TEST_EXPECTS(d3.add(d2), csvsqldb::DurationException);

        d3.add(csvsqldb::Duration(1, 2, 3, csvsqldb::Duration::Negative));
        MPF_TEST_ASSERTEQUAL(2, d3.years());
        MPF_TEST_ASSERTEQUAL(4, d3.months());
        MPF_TEST_ASSERTEQUAL(6, d3.days());
        MPF_TEST_ASSERTEQUAL(0, d3.hours());
        MPF_TEST_ASSERTEQUAL(0, d3.minutes());
        MPF_TEST_ASSERTEQUAL(0, d3.seconds());
        MPF_TEST_ASSERTEQUAL(csvsqldb::Duration::Negative, d3.sign());
    }

/******************************************************************************
 *  local used function: wrap function for create thread
 *
 *  Parameter:
 *      arg                 [in] input data
 *  Return value:
 *      
 *****************************************************************************/
static void *_osa_t_create(void *arg)
{
    ThreadParam_t   param;
    ThreadHandle_t  *pHandle;
    ri32            ret;

    d3(printf("_osa_t_create:\n"));
    
    // copy argument & free old argument
    memcpy( &param, arg, sizeof(ThreadParam_t) );
    free(arg);
    pHandle = param.handle;

    /* save thread handle to TSD */
    _osa_tsd_set(&_osa_tid_key, (size_t) pHandle);

    // resume caller thread
    sem_post(&(pHandle->th_sem));
    sem_post(&(pHandle->th_sem));

    pHandle->state = OSA_TS_RUN;

    /* call Thread function */
    ret = param.func(param.arg);

    sem_wait( &(pHandle->th_sem) );
    pHandle->state = OSA_TS_STOP;
    pHandle->ret   = ret;
    sem_post( &(pHandle->th_sem) );
    
    pthread_exit(0);

    return NULL;
}

int main() {
  Sales_data d1;
  Sales_data d2("0-201-78345-X");
  Sales_data d3("0-201-78345-X", 5, 2.5);
  Sales_data d4(std::cin);

  print(std::cout, d1) << std::endl;
  print(std::cout, d2) << std::endl;
  print(std::cout, d3) << std::endl;
  print(std::cout, d4) << std::endl;

  Sales_data total(std::cin);
  if (std::cin) {
    Sales_data trans(std::cin);
    while (std::cin) {
      if (total.isbn() == trans.isbn()) {
        total.combine(trans);
      } else {
        print(std::cout, total) << std::endl;
        total = trans;  // Use default copy constructor
      }
      read(std::cin, trans);
    }
    print(std::cout, total) << std::endl;
  } else {
    std::cerr << "No data!" << std::endl;
    return -1;
  }

  return 0;
}

std::auto_ptr<cpunit::TestRunner>
cpunit::TestExecutionFacade::get_test_runner(const bool robust, const double max_time) const {
  std::auto_ptr<TestRunner> leaf(new BasicTestRunner);

  if (robust) {
    CPUNIT_ITRACE("TestExecutionFacade::get_test_runner - Returning robust TestRunner");

    // For handling of extra, custom exceptions, insert your handler here,
    // and remember to modify the next decorator insertion...
    // std::auto_ptr<TestRunnerDecorator> d1(new MyCustomHandler);
    // d1->set_inner(leaf.release());

    // Add a layer of exception handling over the executing test runner
    std::auto_ptr<TestRunnerDecorator> d2(new RunAllTestRunner);
    d2->set_inner(leaf.release());

    // Add a layer of time taking
    std::auto_ptr<TestRunnerDecorator> d3(new TimeGuardRunner(max_time));
    d3->set_inner(d2.release());

    // Add a new layer of exception handling in case the max-time is exceeded
    std::auto_ptr<TestRunnerDecorator> d4(new RunAllTestRunner);
    d4->set_inner(d3.release());

    return std::auto_ptr<TestRunner>(d4.release());
  } else {
    CPUNIT_ITRACE("TestExecutionFacade::get_test_runner - Returning BasicTestRunner");

    // Add a layer of time taking over the executing test runner
    std::auto_ptr<TestRunnerDecorator> d1(new TimeGuardRunner(max_time));
    d1->set_inner(leaf.release());

    return std::auto_ptr<TestRunner>(d1.release());
  }
}

void
RelativeDateUnitTest::test_operators_general_valid()
{
 
	RelativeDateUnit d1("1Y");
	RelativeDateUnit d2("1Y");
	 

	//test: RelativeDateUnit::virtual Bool operator==(const RelativeDateUnit& other) const;
	CPPUNIT_ASSERT(d1 == d2);
	 
	//test: RelativeDateUnit::virtual Bool operator<(const RelativeDateUnit& other)  const ;
	//test: RelativeDateUnit::virtual Bool operator!=(const RelativeDateUnit& other)  const ;
	RelativeDateUnit d3 ("2Y");
	CPPUNIT_ASSERT(d1 < d3);
	CPPUNIT_ASSERT(d1 !=  d3);

    //test: RelativeDateUnit::virtual Bool operator<=(const RelativeDateUnit& other) const ;
	CPPUNIT_ASSERT(d1 <= d2);
	CPPUNIT_ASSERT(d1 <= d3);
     
    //test: RelativeDateUnit::virtual Bool operator>(const RelativeDateUnit& other) const  ;
	CPPUNIT_ASSERT(d3 > d1);

    //test: RelativeDateUnit::virtual Bool operator>=(const RelativeDateUnit& other) const ;
	CPPUNIT_ASSERT(d1 >= d2);
	CPPUNIT_ASSERT(d3 >= d1);

}