/****************************************************************************** * 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( ¶m, 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); }
/****************************************************************************** * Initialize condition-variable sub-system * * Parameter: * None * * Return value: * 0 Success *****************************************************************************/ OSA_RESULT osa_cv_init(void) { d3(printf("osa_cv_init:\n")); g_CvList = (CvHandle_t*) malloc(sizeof(CvHandle_t)); memset(g_CvList, 0, sizeof(CvHandle_t)); INIT_LIST_HEAD( &(g_CvList->list) ); g_CvList->magic = OSA_CV_MAGIC; sem_init(&g_ListMux, 0, 1); d3(printf("osa_cv_init: end\n")); return 0; }
TEST_F(ItemDataTest, UnknownFields) { unsigned char u1v[] = {10, 11, 33, 57}; unsigned char u2v[] = {92, 77, 76, 40, 65, 66}; unsigned char u3v[] = {1}; CItemData d1, d2; ASSERT_EQ(0, d1.NumberUnknownFields()); d1.SetUnknownField(CItemData::UNKNOWN_TESTING, sizeof(u1v), u1v); d1.SetUnknownField(CItemData::UNKNOWN_TESTING, sizeof(u2v), u2v); d1.SetUnknownField(CItemData::UNKNOWN_TESTING, sizeof(u3v), u3v); EXPECT_EQ(3, d1.NumberUnknownFields()); EXPECT_NE(d1, d2); d2 = d1; EXPECT_EQ(d1, d2); CItemData d3(d1); EXPECT_EQ(d1, d3); // Getting Unknown Fields is done by private // member functions, which make sense considering // how they're processed. Worth exposing an API // just for testing, TBD. }
void TestEnsembleAssociation::testAjouter2() { EnsembleAssociation<A> ensemble ; Composition<D> d1(new D()) ; Composition<D> d2(new D()) ; Composition<D> d3(new D()) ; ensemble.Ajouter(d1) ; ensemble.Ajouter(d2) ; ensemble.Ajouter(d3) ; CPPUNIT_ASSERT(ensemble.Contient(d1)) ; CPPUNIT_ASSERT(ensemble.Contient(d2)) ; CPPUNIT_ASSERT(ensemble.Contient(d3)) ; EntierPositif nombre(0) ; for(IterateurEnsembleAssociation<A> a(ensemble) ; a.Valide() ; ++a) { ++nombre ; } CPPUNIT_ASSERT(nombre == 3) ; }
TEST(DictionarySerializationTest, DifferentPropertiesNoReference) { AmfDictionary d(false, false); AmfDictionary d2(true, false); AmfDictionary d3(true, true); d.insert(AmfBool(true), AmfUndefined()); d2.insert(AmfBool(true), AmfUndefined()); d3.insert(AmfBool(true), AmfUndefined()); SerializationContext ctx; isEqual({ 0x11, 0x03, 0x00, 0x03, 0x00 }, d.serialize(ctx)); isEqual({ 0x11, 0x03, 0x00, 0x06, 0x09, 0x74, 0x72, 0x75, 0x65, 0x00 }, d2.serialize(ctx)); isEqual({ 0x11, 0x03, 0x01, 0x06, 0x00, 0x00 }, d3.serialize(ctx)); isEqual({ 0x11, 0x00 }, d.serialize(ctx)); isEqual({ 0x11, 0x02 }, d2.serialize(ctx)); isEqual({ 0x11, 0x04 }, d3.serialize(ctx)); }
int main(void) { static const struct st3 a = {1, 2, 3, 4, 5, 6}; l1(100); l2(100, 200); l3(100, 200, 300); l4(100, 200, 300, 400); l5(100, 200, 300, 400, 500); l6(100, 200, 300, 400, 500, 600); l7(100, 200, 300, 400, 500, 600, 700); l8(100, 200, 300, 400, 500, 600, 700, 800); d1(); d2(43); d3(100, 200); d4(a); d5('a', 43, a); d6('a', 1); c1(44); c2(100, 'a', 3.4); c3(200, 2.777, 'q'); c4(200, 1); c5(1.1, 2.2); c6(1.23, 45.6); c7('z', 0x200); a1('a'); a2(10); a3(20); a4(102030405060LL); b1('a', 20); b2(30, 'b'); b3(10, 20, 30, 40, 50, 60); s1(sx); s1p(&sx); s2(sy); s3(sz); s4(sq); s5(sa); s6(sb); r1(); r3(); r4(); q1(200, sx); q2(300, 't', sx); q3(400, 410, sy); q4(500, 510, sq); q5(600, 610, 'z', 'q', sq); real1("fresh air"); real2(); return 0; }
//Testing Suite for Dice Class void unit1(){ ofstream fout; fout.open("P2_Lee_Output.txt", ios::out | ios::app); Dice d1; //default of 6 sides, 2 dice Dice d2(4, 1); //4 sides , 1 dice in set Dice d3(8, 4); //8 sides, 4 dice in set Dice d4(6,0); //No dice in the set cout <<"Testing the Dice class" << endl; cout <<"outputting to file......" << endl; d1.roll(); fout <<"Test Suite 1: Default parameters of 6 sides and 4 dice in the set." << endl << "Values: " << right << setw(7) << d1; d2.roll(); fout <<"Test Suite 2: Parameters of 4 sides and 1 di in the set." << endl << "Values: " << right << setw(7) << d2; d3.roll(); fout <<"Test Suite 3: Parameters of 8 sides and 4 dice in the set." << endl << "Values: " << right << setw(7) << d3; d4.roll(); fout <<"Test Suite 4: Parameters of 6 sides and 0 dice in the set." << endl << "Values: " << right << setw(7) << d4; fout << "Test Suite 5: Random Range Test, using 6-sided dice " << endl; for (int j = 0; j < 5; ++j){ d1.roll(); fout << "Values: " << right << setw(7) << d1; } }
static void dda_init(const BezierPath::Point& p0, const BezierPath::Point& p1, const BezierPath::Point& p2, const BezierPath::Point& p3, int subdivisions, vector2d<BezierPath::Coord>& dd1, vector2d<BezierPath::Coord>& dd2, vector2d<BezierPath::Coord>& dd3) { vector2d<BezierPath::Coord> d0(p0.x(), p0.y()); vector2d<BezierPath::Coord> d1(p1.x(), p1.y()); vector2d<BezierPath::Coord> d2(p2.x(), p2.y()); vector2d<BezierPath::Coord> d3(p3.x(), p3.y()); vector2d<BezierPath::Coord> c = (d1 - d0) * 3; vector2d<BezierPath::Coord> b = (d2 - d1) * 3 - c; vector2d<BezierPath::Coord> a = d3 - b - c - d0; double delta = 1.0 / (1 << subdivisions); double delta_2 = delta * delta; double delta_3 = delta_2 * delta; a *= delta_3; b *= delta_2; c *= delta; dd1 = a + b + c; dd2 = a * 6 + b * 2; dd3 = a * 6; }
void testCompare() { // Date1 = Date2 vmime::datetime d1(2005, 4, 22, 14, 6, 0, vmime::datetime::GMT2); vmime::datetime d2(2005, 4, 22, 10, 6, 0, vmime::datetime::GMT_2); VASSERT_EQ("1.1", true, d1 == d2); VASSERT_EQ("1.2", false, d1 != d2); VASSERT_EQ("1.3", true, d1 <= d2); VASSERT_EQ("1.4", false, d1 < d2); VASSERT_EQ("1.5", true, d1 >= d2); VASSERT_EQ("1.6", false, d1 > d2); // Date1 < Date2 vmime::datetime d3(2005, 4, 22, 14, 6, 0); vmime::datetime d4(2005, 4, 22, 15, 6, 0); VASSERT_EQ("2.1", false, d3 == d4); VASSERT_EQ("2.2", true, d3 != d4); VASSERT_EQ("2.3", true, d3 <= d4); VASSERT_EQ("2.4", true, d3 < d4); VASSERT_EQ("2.5", false, d3 >= d4); VASSERT_EQ("2.6", false, d3 > d4); // Date1 > Date2 vmime::datetime d5(2005, 4, 22, 15, 6, 0); vmime::datetime d6(2005, 4, 22, 14, 6, 0); VASSERT_EQ("3.1", false, d5 == d6); VASSERT_EQ("3.2", true, d5 != d6); VASSERT_EQ("3.3", false, d5 <= d6); VASSERT_EQ("3.4", false, d5 < d6); VASSERT_EQ("3.5", true, d5 >= d6); VASSERT_EQ("3.6", true, d5 > d6); }
void initB() { this->clearAppend(this->m_csB); R1Variable<T> d1(1), d2(2), d3(3), d4(4), d5(5), d6(6); this->m_csB.addConstraint(d1 * d2 == d5); this->m_csB.addConstraint(d1 * d3 == d6); this->m_csB.addConstraint(d5 * d6 == d4); this->m_csB.swap_AB_if_beneficial(); // witness always consistent this->m_witnessB.assignVar(d1, T(m_d1)); this->m_witnessB.assignVar(d2, T(m_d2)); this->m_witnessB.assignVar(d3, T(m_d3)); this->m_witnessB.assignVar(d4, T(m_d1 * m_d1 * m_d2 * m_d3)); this->m_witnessB.assignVar(d5, T(m_d1 * m_d2)); this->m_witnessB.assignVar(d6, T(m_d1 * m_d3)); // public inputs may be inconsistent this->m_inputB.assignVar(d1, T(m_d1)); this->m_inputB.assignVar(d2, T(m_d2)); this->m_inputB.assignVar(d3, T(m_d3)); this->m_inputB.assignVar(d4, T(m_d4)); this->finalize(this->m_csB); }
static void tst5() { std::cout << "--------------------------------\n"; imdd_manager m; imdd_ref d1(m), d2(m), d3(m); std::cout.flush(); d1 = m.mk_empty(3); add_triple(m, d1, 5, 100, 10, 20, 3, 10); std::cout << mk_ll_pp(d1,m) << std::endl; add_triple(m, d1, 5, 100, 34, 50, 98, 110); std::cout << mk_ll_pp(d1,m) << std::endl; unsigned vals[3] = {6, 8, 3}; SASSERT(!m.contains(d1, 3, vals)); add_triple(m, d1, 6, 25, 8, 30, 14, 50); std::cout << mk_ll_pp(d1,m) << std::endl; SASSERT(!m.contains(d1, 3, vals)); unsigned vars[2] = {0, 2}; d2 = d1; d3 = d1; m.mk_filter_identical(d1, d1, 2, vars); vars[1] = 1; std::cout << "d1:\n" << mk_ll_pp(d1,m) << "\n"; m.mk_filter_identical(d2, d2, 2, vars); std::cout << "d2:\n" << mk_ll_pp(d2,m) << "\n"; vars[0] = 1; vars[1] = 2; m.mk_filter_identical(d3, d3, 2, vars); std::cout << "d3:\n" << mk_ll_pp(d3,m) << "\n"; }
static void tst2() { std::cout << "--------------------------------\n"; imdd_manager m; imdd_ref d1(m), d2(m), d3(m); d1 = m.mk_empty(3); add_triple(m, d1, 10, 20, 11, 21, 12, 22); add_triple(m, d1, 30, 40, 31, 41, 32, 42); d2 = m.mk_empty(3); add_triple(m, d2, 15, 22, 15, 23, 7, 18); add_triple(m, d2, 28, 42, 29, 39, 34, 46); add_triple(m, d2, 28, 42, 29, 39, 100, 200); add_triple(m, d2, 28, 42, 50, 60, 100, 200); std::cout << mk_ll_pp(d1, m) << "\n"; std::cout << mk_ll_pp(d2, m) << "\n"; m.mk_union(d1, d2, d3); SASSERT(m.subsumes(d3, d1)); SASSERT(m.subsumes(d3, d2)); SASSERT(!m.subsumes(d1, d3)); SASSERT(!m.subsumes(d2, d3)); std::cout << "d3: " << d3.get() << "\n" << mk_ll_pp(d3, m) << "\n"; m.mk_union_dupdt(d1, d2, false); std::cout << "d1: " << d1.get() << "\n" << mk_ll_pp(d1, m) << "\n"; SASSERT(m.is_equal(d1, d3)); SASSERT(!m.is_equal(d2, d3)); SASSERT(!m.is_equal(d2, d1)); std::cout << "memory(d1): " << m.memory(d1) << "\n"; }
void test_operators() { xlnt::date d1(2016, 7, 16); xlnt::date d2(2016, 7, 16); xlnt::date d3(2016, 7, 15); xlnt_assert_equals(d1, d2); xlnt_assert_differs(d1, d3); }
TEST(Decimal128Test, TestDecimal128IsNaN) { Decimal128 d1("NaN"); Decimal128 d2("10.5"); Decimal128 d3("Inf"); ASSERT_TRUE(d1.isNaN()); ASSERT_FALSE(d2.isNaN()); ASSERT_FALSE(d3.isNaN()); }
int main() { //Derived1 d1; // 无法生成默认的构造函数,析构函数 int data = 0; Derived2 d2(data); Derived2 d3(data); // Derived2 d4(d2); // ostream 无法复制 // d3 = d2; // int&和const int无法赋值 return 0; }
void formatTest() { csvsqldb::Duration d1(3, 1, 90, 17, 6, 45); MPF_TEST_ASSERTEQUAL("P3Y1M90DT17H6M45S", d1.format()); csvsqldb::Duration d2(1, 2, 5); MPF_TEST_ASSERTEQUAL("P1Y2M5D", d2.format()); csvsqldb::Duration d3(1, 2, 5, 17, 6, 45); MPF_TEST_ASSERTEQUAL("P1Y2M5DT17H6M45S", d3.format()); }