示例#1
0
void tst_QSizeF::scale() {
    QSizeF t1(10.4, 12.8);
    t1.scale(60.6, 60.6, Qt::IgnoreAspectRatio);
    QCOMPARE(t1, QSizeF(60.6, 60.6));

    QSizeF t2(10.4, 12.8);
    t2.scale(43.52, 43.52, Qt::KeepAspectRatio);
    QCOMPARE(t2, QSizeF(35.36, 43.52));

    QSizeF t3(9.6, 12.48);
    t3.scale(31.68, 31.68, Qt::KeepAspectRatioByExpanding);
    QCOMPARE(t3, QSizeF(31.68, 41.184));

    QSizeF t4(12.8, 10.4);
    t4.scale(43.52, 43.52, Qt::KeepAspectRatio);
    QCOMPARE(t4, QSizeF(43.52, 35.36));

    QSizeF t5(12.48, 9.6);
    t5.scale(31.68, 31.68, Qt::KeepAspectRatioByExpanding);
    QCOMPARE(t5, QSizeF(41.184, 31.68));

    QSizeF t6(0.0, 0.0);
    t6.scale(200, 240, Qt::IgnoreAspectRatio);
    QCOMPARE(t6, QSizeF(200, 240));

    QSizeF t7(0.0, 0.0);
    t7.scale(200, 240, Qt::KeepAspectRatio);
    QCOMPARE(t7, QSizeF(200, 240));

    QSizeF t8(0.0, 0.0);
    t8.scale(200, 240, Qt::KeepAspectRatioByExpanding);
    QCOMPARE(t8, QSizeF(200, 240));
}
示例#2
0
void
test_relational()
{
    cout << "test_relational" << endl;

    sc_time t1;
    sc_time t2( 1, SC_FS );
    sc_time t3( 1.2345, SC_NS );
    sc_time t4( 1.2341, SC_NS );
    sc_time t5( -1.5432, SC_NS );

    cout << ( t1 == t2 ) << endl;
    cout << ( t1 != t2 ) << endl;
    cout << ( t1 <  t2 ) << endl;
    cout << ( t1 <= t2 ) << endl;
    cout << ( t1 >  t2 ) << endl;
    cout << ( t1 >= t2 ) << endl;

    cout << ( t3 == t4 ) << endl;
    cout << ( t3 != t4 ) << endl;
    cout << ( t3 <  t4 ) << endl;
    cout << ( t3 <= t4 ) << endl;
    cout << ( t3 >  t4 ) << endl;
    cout << ( t3 >= t4 ) << endl;

    cout << ( t1 == t5 ) << endl;
    cout << ( t1 != t5 ) << endl;
    cout << ( t1 <  t5 ) << endl;
    cout << ( t1 <= t5 ) << endl;
    cout << ( t1 >  t5 ) << endl;
    cout << ( t1 >= t5 ) << endl;
}
示例#3
0
文件: main.cpp 项目: chipot/moost
int        main(int argc, const char *argv[])
{
  int accu = 0;
  for (size_t bite = 0; bite < 64; ++bite)
  {
    pong p;
    moost::Thread t1(p);
    moost::Thread t2(p);
    moost::Thread t3(p);
    moost::Thread t4(p);
    moost::Thread t5(p);
    moost::Thread t0(&ping);
    moost::Thread t01(&ping);
    moost::Thread t02(&ping);
    moost::Thread t03(&ping);
    moost::Thread t04(&ping);

    t0.join();
    t01.join();
    t02.join();
    t03.join();
    t04.join();
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();
    accu = i;
  }
  if (accu == 0)
    std::cout << "OK" << std::endl;
  else
    std::cout << "KO" << std::endl;
  return (0);
}
示例#4
0
文件: struct.c 项目: 4ker/8cc
void testmain() {
    print("struct");
    t1();
    t2();
    t3();
    t4();
    t5();
    t6();
    t7();
    t8();
    t9();
    t10();
    t11();
    t12();
    t13();
    t14();
    unnamed();
    assign();
    arrow();
    incomplete();
    bitfield_basic();
    bitfield_mix();
    bitfield_union();
    bitfield_unnamed();
    bitfield_initializer();
    test_offsetof();
    flexible_member();
    empty_struct();
}
示例#5
0
void
test_print()
{
    cout << "test_print" << endl;

    sc_time t1;
    cout << t1 << endl;

    uint64 v = 1230;
    sc_time t2( v, false );
    cout << t2 << endl;

    v *= 10000;
    sc_time t3( v, false );
    cout << t3 << endl;

    v *= 100;
    sc_time t4( v, false );
    cout << t4 << endl;

    v *= 10000;
    sc_time t5( v, false );
    cout << t5 << endl;

    v *= 100;
    sc_time t6( v, false );
    cout << t6 << endl;

    v *= 10000;
    sc_time t7( v, false );
    cout << t7 << endl;
}
示例#6
0
int main(int argc, char* argv[])
{
  auto master_thread_id = std::this_thread::get_id();

  auto lambda_f = [=]()
  {
    auto thread_id = std::this_thread::get_id();
    if (thread_id == master_thread_id)
    {
      std::lock_guard<std::mutex> l(cout_mutex);
      std::cout << "Master thread. ID=" << thread_id << std::endl;
    }
    else
    {
      std::lock_guard<std::mutex> l(cout_mutex);
      std::cout << "Child thread.  ID=" << thread_id << std::endl;
    }
  };

  ScopedThread t1(lambda_f);
  ScopedThread t2(lambda_f);
  ScopedThread t3(lambda_f);
  ScopedThread t4(lambda_f);
  ScopedThread t5(lambda_f);

  lambda_f();
}
示例#7
0
void testSerialize ()
{
  BTree<int> empty;
  BTree<int> t90 (90,empty,empty),
             t12 (12,t90,empty),
             t30 (30,empty,t12),
             t50 (50,empty,empty),
             t5  (5,t50, empty),
             t7  (7,t30,t5);


  std::ofstream f ("tree.txt");

  f << t7;

  f.close ();

  BTree<int> newTree;
  std::ifstream fin ("tree.txt");

  newTree.read (fin);

  //assert (t7==newTree);

  std::cout << std::endl << newTree;
}
示例#8
0
void
test_types()
{
  std::cout << "--- types ---\n";
  Void_type t1;
  std::cout << t1 << '\n'; // void

  Boolean_type t2;
  std::cout << t2 << '\n'; // bool

  Integer_type t3;
  std::cout << t3 << '\n'; // int

  Float_type t4;
  std::cout << t4 << '\n'; // double

  Function_type t5({&t2, &t3}, t2);
  std::cout << t5 << '\n'; // (bool, int32) -> bool

  Pointer_type t6(t2);
  std::cout << t6 << '\n'; // bool*;

  Reference_type t7(t5);
  std::cout << t7 << '\n'; // ((bool, int32) -> bool)&;

  Function_type t8({}, t1);
  std::cout << t8 << '\n'; // () -> void

  Sequence_type t9(*new Pointer_type(t8));
  std::cout << t9 << '\n'; // (() -> void)*[]
}
示例#9
0
int main(){
	float* A = (float*) memalign(16, LEN5*sizeof(float));
	float* B = (float*) memalign(16, LEN5*sizeof(float));
	float* C = (float*) memalign(16, LEN5*sizeof(float));
	float* D = (float*) memalign(16, LEN5*sizeof(float));
	float* E = (float*) memalign(16, LEN5*sizeof(float));
	
	
	
	for (int i = 0; i < LEN5; i++){
			A[i] = (float)(i)/(float)LEN5;
			B[i] = (float)(i+1)/(float)LEN5;
			C[i] = (float)(i+2)/(float)LEN5;
		    D[i] = (float)(i+3)/(float)LEN5;
			E[i] = (float)(i+4)/(float)LEN5;
		
		}

	unsigned long long start_c, end_c, diff_c;
	start_c = _rdtsc();

	t5(A,B,C,D,E);

	end_c=_rdtsc(); 
	diff_c = end_c - start_c;
	float giga_cycle = diff_c / 1000000000.0;
	
	float ttt = (float)0.;
        #pragma novector
	for (int i = 0; i < LEN5; i++)
		ttt += A[i];
	printf("t5 took\t %.2f and the result is %f\n", giga_cycle, ttt);
}
示例#10
0
文件: time.cpp 项目: jrwilson/ioa
static const char*
op_plus_equal ()
{
  std::cout << __func__ << std::endl;

  ioa::time t1 (1, 500500);
  ioa::time t2 (-2, -300300);

  ioa::time t3 (t1);
  t3 += t1;
  mu_assert (t3.sec () == 3);
  mu_assert (t3.usec () == 1000);

  ioa::time t4 (t1);
  t4 += t2;

  mu_assert (t4.sec () == 0);
  mu_assert (t4.usec () == -799800);

  ioa::time t5 (t2);
  t5 += t1;
  mu_assert (t5.sec () == 0);
  mu_assert (t5.usec () == -799800);

  ioa::time t6 (t2);
  t6 += t2;
  mu_assert (t6.sec () == -4);
  mu_assert (t6.usec () == -600600);

  return 0;
}
示例#11
0
void testPrintWithStack ()
{
  BTree<int> empty;
  BTree<int> t90 (90,empty,empty),
             t12 (12,t90,empty),
             t30 (30,empty,t12),
             t50 (50,empty,empty),
             t5  (5,t50, empty),
             t7  (7,t30,t5);


  t7.printWithStack(std::cout);

  std::stringstream str;
  t7.printWithStack(str);

  int x, y, z;
  str >> x >> y >> z;
  assert (x == 30);
  assert (y == 90);
  assert (z == 12);

  //или
  assert (str.str() == "30 90 12 7 50 5 ");

}
示例#12
0
 int test11()
 {
   context ctx(MAGIC_VALUE11);
   {
     exc_test t1(ctx, MAGIC_VALUE11_2);
     try
     {
       exc_test t2(ctx, MAGIC_VALUE11_2);
       throw exc_test(ctx, MAGIC_VALUE11);   //  this magic value is expected to be catched in ff_throw() and captured in context::state
     }
     catch (exc_test&)
     {
       exc_test t3(ctx, MAGIC_VALUE11_2);
       try 
       {
         exc_test t4(ctx, MAGIC_VALUE11_2);
         ff_throw(ctx);
       }
       catch (exc_test&)
       {
         exc_test t5(ctx, MAGIC_VALUE11_2);
         ctx.state = UNEXPECTED_CATCH1;
       }
     }
   }
   return ctx.balance();
 }
示例#13
0
文件: test.cpp 项目: ronchaine/wheel
int main(void)
{
   wheel::EventMapping events;

   wheel::Timer t5("timer", 5000000, true);
   wheel::Timer t2("timer2", 2000000, true);

   printf("created timer at %08x, with 5000 µsec interval\n", &t5);
   printf("created timer at %08x, with 2000 µsec interval\n", &t2);

   events.map_event(wheel::event_from_ptr(WHEEL_EVENT_TIMER, &t5), "test timer", [&](wheel::Event& e)
      { 
         e.data.seek(1);
         uint64_t ptr = e.data.read<uint64_t>();
         printf("event from timer @ %08x\n", ptr);
      }
   );

   events.map_event(wheel::event_from_ptr(WHEEL_EVENT_TIMER, &t2), "test timer2", [&](wheel::Event& e)
      { 
         e.data.seek(1);
         uint64_t ptr = e.data.read<uint64_t>();
         printf("event from timer @ %08x\n", ptr);
      }
   );


   while(1)
   {
      events.process();
   }

   return 0;
}
示例#14
0
void testMemory ()
{
  BTree<int> empty;
  BTree<int> t90 (90,empty,empty),
             t12 (12,t90,empty),
             t30 (30,empty,t12),
             t50 (50,empty,empty),
             t5  (5,t50, empty),
             t7  (7,t30,t5);

  BTree<int> *tmp = new BTree<int> (t7);

  assert (tmp->member (90));
  assert (tmp->member (7));
  assert (*tmp == t7);

  delete tmp;
  assert (t7.member (90));
  assert (t7.member (7));

  t90 = t7;
  assert (t90 == t7);
  t7 = t7;
  assert (t90 == t7);
  assert (t7 == t7);

}
示例#15
0
int main(void)
{
	vector<int> ret;

	TreeNode root(1);
	TreeNode t2(2);
	TreeNode t3(3);
	TreeNode t4(4);
	TreeNode t5(5);
	TreeNode t6(6);
	TreeNode t7(7);
	TreeNode t8(8);
	TreeNode t9(9);
	TreeNode t10(10);

	root.left = &t2;
	root.right = &t3;
	t2.left = &t4;
	t3.left = &t5;
	t3.right = &t6;
	t5.left = &t7;
	t6.left = &t8;
	t6.right = &t9;
	t8.left = &t10;

	Solution s;
	ret = s.preorderTraversal(&root);
	for(auto it = ret.begin(); it != ret.end(); ++it)
	{
		std::cout << *it << " ";
	}
	std::cout << std::endl;
}
示例#16
0
int main() {
    TreeNode root1(1);
    TreeNode root2(1);
	TreeNode t2(2);
	TreeNode t3(3);
	TreeNode t4(4);
	TreeNode t5(5);
	TreeNode t6(6);
	TreeNode t7(7);
	TreeNode t8(8);
	TreeNode t9(9);
	
	root1.left = &t2;
	root1.right = &t3;
	root2.left = &t2;
	root2.right = &t3;
	t2.left = &t4;
	t2.right = &t5;
	t3.right = &t6;
	t4.left = &t7;
	t4.right = &t8;
	t8.left = &t9;
	
	Solution s;
	std::cout << s.isSameTree(&root1, &root2) << std::endl;
    
	return 0;
}
示例#17
0
bool iterator_replace_test( )
{
  bool rc = true;
  const std::string s1( "Insert me!" );

  std::string t1( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t1.replace( t1.begin( ), t1.end( ), s1 );
  if( t1 != "Insert me!" || INSANE( t1 ) ) FAIL

  std::string t2( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t2.replace( t2.begin( ), t2.begin( ) + 1, s1 );
  if( t2 != "Insert me!BCDEFGHIJKLMNOPQRSTUVWXYZ" || INSANE( t2 ) ) FAIL

  std::string t3( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t3.replace( t3.end( ), t3.end( ), s1 );
  if( t3 != "ABCDEFGHIJKLMNOPQRSTUVWXYZInsert me!" || INSANE( t3 ) ) FAIL

  std::string t4( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t4.replace( t4.begin( ) + 4, t4.begin( ) + 7, s1 );
  if( t4 != "ABCDInsert me!HIJKLMNOPQRSTUVWXYZ" || INSANE( t4 ) ) FAIL

  std::string t5( "Shorty" );
  t5.replace( t5.begin( ), t5.begin( ) + 2, 2, 'x' );
  if( t5 != "xxorty" || INSANE( t5 ) ) FAIL

  // Need to test other iterator replace methods.

  return( rc );
}
示例#18
0
bool replace_test( )
{
  bool rc = true;
  const std::string s1( "Insert me!" );

  std::string t1( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t1.replace( 0, std::string::npos, s1, 0, std::string::npos );
  if( t1 != "Insert me!" || INSANE( t1 ) ) FAIL

  std::string t2( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t2.replace( 0, 1, s1, 0, std::string::npos );
  if( t2 != "Insert me!BCDEFGHIJKLMNOPQRSTUVWXYZ" || INSANE( t2 ) ) FAIL

  std::string t3( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t3.replace( 1, 0, s1, 0, 1 );
  if( t3 != "AIBCDEFGHIJKLMNOPQRSTUVWXYZ" || INSANE( t3 ) ) FAIL

  std::string t4( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t4.replace( 26, 0, s1, 0, std::string::npos );
  if( t4 != "ABCDEFGHIJKLMNOPQRSTUVWXYZInsert me!" || INSANE( t4 ) ) FAIL

  std::string t5( "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
  t5.replace( 4, 3, s1, 2, 5 );
  if( t5 != "ABCDsert HIJKLMNOPQRSTUVWXYZ" || INSANE( t5 ) ) FAIL

  std::string t6( "Shorty" );
  t6.replace( 1, 2, s1, 0, 2 );
  if( t6 != "SInrty" || INSANE( t6 ) ) FAIL

  // Need to test other replace methods.

  return( rc );
}
示例#19
0
int
CC_Client::run_basic_tests (void)
{
  Test_Single_Lock_With_Mode t1 (naming_service_,
                                 CosConcurrencyControl::read);
  Test_Single_Lock_With_Mode t2 (naming_service_,
                                 CosConcurrencyControl::write);
  Test_Single_Lock_With_Mode t3 (naming_service_,
                                 CosConcurrencyControl::upgrade);
  Test_Single_Lock_With_Mode t4 (naming_service_,
                                 CosConcurrencyControl::intention_read);
  Test_Single_Lock_With_Mode t5 (naming_service_,
                                 CosConcurrencyControl::intention_write);
  // This test should be run for several different lock mode, but
  // since we do not support
  Test_Release_Not_Held_Lock t6 (naming_service_,
                                 CosConcurrencyControl::read);
  if (t1.run () == CC_SUCCESS &&
      t2.run () == CC_SUCCESS &&
      t3.run () == CC_SUCCESS &&
      t4.run () == CC_SUCCESS &&
      t5.run () == CC_SUCCESS &&
      t6.run () == CC_SUCCESS )
    return CC_SUCCESS;
  else
    return CC_FAIL;
}
int
main (int, char *[])
{
  ACE_START_TEST ("Group_Test");

  int stamp = 20;
  /* ================================================================== */
  ACE_DEBUG((LM_INFO, "-----------group target-----------\n"));

  ACE_DEBUG((LM_INFO, "constrctor(Stamp)..................\n"));
  ACE_CLASSIX_Group_Stamp t0(100);
  t0.dump();

  /* ================================================================== */
  ACE_DEBUG((LM_INFO, "-----------group target-----------\n"));

  ACE_DEBUG((LM_INFO, "constrctor(Stamp)..................\n"));
  ACE_CLASSIX_Group_Stamp t1(stamp);
  t1.dump();

  /* ================================================================== */
  ACE_DEBUG((LM_INFO, "empty constrctor(Stamp) & set_group()\n"));
  ACE_CLASSIX_Group_Stamp t2;
  if (t2 == t1)
      ACE_DEBUG((LM_ERROR, "t2 == t1, should be !=\n"));
  t2.set_addr(&stamp);
  t2.dump();
  if (t2 != t1)
      ACE_DEBUG((LM_ERROR, "????t2 != t1, should be ==\n"));
      

  /* ================================================================== */
  ACE_DEBUG((LM_INFO, "Constrctor(Dynamic) & set_group()\n"));
  ACE_CLASSIX_Group_Dynamic t3;
  t3.dump();

  ACE_CLASSIX_Group_Stamp t4;
  t4.set_addr(t2.get_addr(), t2.get_size()); 
  t4.dump();
  if (t4 == t2)
      ACE_DEBUG((LM_ERROR, "????t4 == t2, should be !=\n"));
  t4.set_addr(&stamp); 
  t4.dump();
  if (t4 != t2)
      ACE_DEBUG((LM_ERROR, "????t4 != t2, should be ==\n"));

  ACE_CLASSIX_Group t5(t3.get_addr(), t3.get_size());
  t5.dump();
  if (t5 != t3)
      ACE_DEBUG((LM_ERROR, "????t5 != t3, should be ==\n"));
      

  if (t2 != t1)
      ACE_DEBUG((LM_ERROR, "????t2 != t1, should be ==\n"));
      
  /* ================================================================== */
  ACE_END_TEST;
  return 0;
}
    void test()
    {
        const unsigned runs = 1000;
        unsigned next_progress_report = 10, progress;
        last_error_count = 0;

        engine.seed(std::time(0));

        BOOST_TEST_EQ(Number(), 0);

        for (unsigned r = 1; r <= runs; ++r)
        {
            progress = 100 * r / runs;
            while (progress >= next_progress_report)
            {
                std::cout << "..." << progress << "%";
                std::cout.flush();
                next_progress_report += 10;
            }

            a = kanooth::numbers::generate_random_bits_number<ref_type>(engine, 1000);
            b = kanooth::numbers::generate_random_bits_number<ref_type>(engine, 512);
            c = kanooth::numbers::generate_random_bits_number<ref_type>(engine, 256);
            d = kanooth::numbers::generate_random_bits_number<ref_type>(engine, 32);

            si = d.convert_to<int>();
            ui = si;

            a1 = static_cast<test_type>(a.str());
            b1 = static_cast<test_type>(b.str());
            c1 = static_cast<test_type>(c.str());
            d1 = static_cast<test_type>(d.str());

            t1();
            t2();
            t3();
            t4();
            t5();

            if(last_error_count != (unsigned)boost::detail::test_errors())
            {
                last_error_count = boost::detail::test_errors();
                //std::cout << std::hex << std::showbase;

                std::cout << "a    = " << a << std::endl;
                std::cout << "a1   = " << a1 << std::endl;
                std::cout << "b    = " << b << std::endl;
                std::cout << "b1   = " << b1 << std::endl;
                std::cout << "c    = " << c << std::endl;
                std::cout << "c1   = " << c1 << std::endl;
                std::cout << "d    = " << d << std::endl;
                std::cout << "d1   = " << d1 << std::endl;
            }

        }
        std::cout << std::endl;
    }
示例#22
0
void testmain(void) {
    print("pointer");
    t1();
    t2();
    t3();
    t4();
    t5();
    t6();
    subtract();
}
示例#23
0
void tst_QSize::scale()
{
    QSize t1( 10, 12 );
    t1.scale( 60, 60, Qt::IgnoreAspectRatio );
    QCOMPARE( t1, QSize(60, 60) );

    QSize t2( 10, 12 );
    t2.scale( 60, 60, Qt::KeepAspectRatio );
    QCOMPARE( t2, QSize(50, 60) );

    QSize t3( 10, 12 );
    t3.scale( 60, 60, Qt::KeepAspectRatioByExpanding );
    QCOMPARE( t3, QSize(60, 72) );

    QSize t4( 12, 10 );
    t4.scale( 60, 60, Qt::KeepAspectRatio );
    QCOMPARE( t4, QSize(60, 50) );

    QSize t5( 12, 10 );
    t5.scale( 60, 60, Qt::KeepAspectRatioByExpanding );
    QCOMPARE( t5, QSize(72, 60) );

    // test potential int overflow
    QSize t6(88473, 88473);
    t6.scale(141817, 141817, Qt::KeepAspectRatio);
    QCOMPARE(t6, QSize(141817, 141817));

    QSize t7(800, 600);
    t7.scale(400, INT_MAX, Qt::KeepAspectRatio);
    QCOMPARE(t7, QSize(400, 300));

    QSize t8(800, 600);
    t8.scale(INT_MAX, 150, Qt::KeepAspectRatio);
    QCOMPARE(t8, QSize(200, 150));

    QSize t9(600, 800);
    t9.scale(300, INT_MAX, Qt::KeepAspectRatio);
    QCOMPARE(t9, QSize(300, 400));

    QSize t10(600, 800);
    t10.scale(INT_MAX, 200, Qt::KeepAspectRatio);
    QCOMPARE(t10, QSize(150, 200));

    QSize t11(0, 0);
    t11.scale(240, 200, Qt::IgnoreAspectRatio);
    QCOMPARE(t11, QSize(240, 200));

    QSize t12(0, 0);
    t12.scale(240, 200, Qt::KeepAspectRatio);
    QCOMPARE(t12, QSize(240, 200));

    QSize t13(0, 0);
    t13.scale(240, 200, Qt::KeepAspectRatioByExpanding);
    QCOMPARE(t13, QSize(240, 200));
}
示例#24
0
void testBFS ()
{
  BTree<int> empty;
  BTree<int> t90 (90,empty,empty),
             t12 (12,t90,empty),
             t30 (30,empty,t12),
             t50 (50,empty,empty),
             t5  (5,t50, empty),
             t7  (7,t30,t5);

  t7.levelsPrint(std::cout);
}
int main(){
    Solution a;
    TreeNode t1(1),t2(2),t3(3),t4(4),t5(5);
    TreeNode* pt1=&t1, *pt2=&t2, *pt3=&t3, *pt4=&t4, *pt5=&t5;

    pt1->right=pt2;
    //pt1->right=pt3;
    // pt2->left=pt4;
    // pt3->right=pt5;
    std::cout<<a.minDepth(NULL)<<std::endl;

}
示例#26
0
void tst_QTime::isNull()
{
    QTime t1;
    QVERIFY( t1.isNull() );
    QTime t2(0,0,0);
    QVERIFY( !t2.isNull() );
    QTime t3(0,0,1);
    QVERIFY( !t3.isNull() );
    QTime t4(0,0,0,1);
    QVERIFY( !t4.isNull() );
    QTime t5(23,59,59);
    QVERIFY( !t5.isNull() );
}
示例#27
0
int main(void)
{
   assert(4 == sizeof(int));

   x += t1();
   x += t2();
   x += t3();
   x += t4();
   x += t5();
   x += t6();

   return x & 255;
}
示例#28
0
int main(int argc, char *argv[])
{
   int i, t, c, pi;

   char test[64];

   if (argc > 1)
   {
      t = 0;

      for (i=0; i<strlen(argv[1]); i++)
      {
         c = tolower(argv[1][i]);

         if (!strchr(test, c))
         {
            test[t++] = c;
            test[t] = 0;
         }
      }
   }
   else strcat(test, "0123456789");

   pi = pigpio_start(0, 0);

   if (pi < 0)
   {
      fprintf(stderr, "pigpio initialisation failed (%d).\n", pi);
      return 1;
   }

   printf("Connected to pigpio daemon (%d).\n", pi);

   if (strchr(test, '0')) t0(pi);
   if (strchr(test, '1')) t1(pi);
   if (strchr(test, '2')) t2(pi);
   if (strchr(test, '3')) t3(pi);
   if (strchr(test, '4')) t4(pi);
   if (strchr(test, '5')) t5(pi);
   if (strchr(test, '6')) t6(pi);
   if (strchr(test, '7')) t7(pi);
   if (strchr(test, '8')) t8(pi);
   if (strchr(test, '9')) t9(pi);
   if (strchr(test, 'a')) ta(pi);
   if (strchr(test, 'b')) tb(pi);
   if (strchr(test, 'c')) tc(pi);

   pigpio_stop(pi);

   return 0;
}
示例#29
0
int main () {
  Tree t1(1), t2("u"), t3(5);
  Tree t4(t1,"*",t2);
  Tree t5("-",t3);

  t4(12.0, 0, 0);
  t5.value();

  Tree t6(t1,"/",t3);
  t6(12.12,0,0);

  Tree t7(t1,"+",t5);
  t7.value();
}
示例#30
0
文件: Tree.cpp 项目: blueocci/codes
void testTree(){
	Tree<int> t2(2),t1(1),t3(3),t4(4),t5(5),t6(6);
	t1.appendChildTree(t2);
	t1.appendChildTree(t3);
	t3.appendChildTree(t4);
	t4.appendChildTree(t5);
	t5.appendChildTree(t6);
	cout << "t1's depth is:" << t1.depth() << endl;
	t1.travelDfs();
	//cout << endl << "Hello from Tree.cpp" << endl;
	//TRACE0("Print in Tree.cpp:::TRACE0.\n");
	//TRACE1("t1's depth is:%d.\n",t1.depth());
	int in;
	cin >> in;
}