自学教程：C++ ASSERT_TRUE函数代码示例

TEST(MAPPING, MAPPING5) {    mkdir("tmp", 0700);    TemporaryFile tmpfile("dbbuilder5", ".dat", "./tmp");    FILE *filew = fopen(tmpfile.path(), "w");    GenomeHash genomeHash;    genomeHash.open(4, 4);    genomeHash.insert("ATCG", 1);    genomeHash.insert("GCTA", 2);    genomeHash.save(filew);    fprintf(filew, "1/tX/t1.0/n");    fprintf(filew, "2/tY/t2.0/n");    fclose(filew);    {        PFILE *pfile = pipedopen("./data/paired1.fastq", false);        ASSERT_TRUE(pfile);        cppfasta::FastqReader2 reader(pfile->file);        std::map<std::string, int> result;        std::map<std::string, double> fpkm;        uint64_t num;            ASSERT_TRUE(domapping(tmpfile.path(), &reader, &result, &fpkm, NULL, &num, 1, 1, false, false));        ASSERT_EQ(4U, num);        ASSERT_EQ(2, result["X"]);        ASSERT_EQ(2, result["UNMAPPED"]);        pipedclose(pfile);    }    {        PFILE *pfile1 = pipedopen("./data/paired1.fastq", false);        ASSERT_TRUE(pfile1);        PFILE *pfile2 = pipedopen("./data/paired2.fastq", false);        ASSERT_TRUE(pfile2);        cppfasta::FastqReader2 reader(pfile1->file, pfile2->file);        std::map<std::string, int> result;        std::map<std::string, double> fpkm;        uint64_t num;            ASSERT_TRUE(domapping(tmpfile.path(), &reader, &result, &fpkm, NULL, &num, 1, 1, false, true));        ASSERT_EQ(4U, num);        ASSERT_EQ(3, result["X"]);        ASSERT_EQ(1, result["UNMAPPED"]);        pipedclose(pfile1);        pipedclose(pfile2);    }    {        PFILE *pfile = pipedopen("./data/paired-unified.fastq", false);        ASSERT_TRUE(pfile);        cppfasta::FastqReader2 reader(pfile->file);        std::map<std::string, int> result;        std::map<std::string, double> fpkm;        uint64_t num;            ASSERT_TRUE(domapping(tmpfile.path(), &reader, &result, &fpkm, NULL, &num, 1, 1, false, true));        ASSERT_EQ(4U, num);        ASSERT_EQ(3, result["X"]);        ASSERT_EQ(1, result["UNMAPPED"]);        pipedclose(pfile);    }    rmdir("tmp");}

/* Basic nominal test of a service. */TEST_F(TestServiceFixture, test_service_nominal) {  stop_memory_checking();  rcl_ret_t ret;  const rosidl_service_type_support_t * ts = ROSIDL_GET_TYPE_SUPPORT(    example_interfaces, srv, AddTwoInts);  const char * topic = "add_two_ints";  rcl_service_t service = rcl_get_zero_initialized_service();  rcl_service_options_t service_options = rcl_service_get_default_options();  ret = rcl_service_init(&service, this->node_ptr, ts, topic, &service_options);  ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  // Check that the service name matches what we assigned.  EXPECT_EQ(strcmp(rcl_service_get_service_name(&service), topic), 0);  auto service_exit = make_scope_exit([&service, this]() {    stop_memory_checking();    rcl_ret_t ret = rcl_service_fini(&service, this->node_ptr);    EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  });  rcl_client_t client = rcl_get_zero_initialized_client();  rcl_client_options_t client_options = rcl_client_get_default_options();  ret = rcl_client_init(&client, this->node_ptr, ts, topic, &client_options);  ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  auto client_exit = make_scope_exit([&client, this]() {    stop_memory_checking();    rcl_ret_t ret = rcl_client_fini(&client, this->node_ptr);    EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  });  // TODO(wjwwood): add logic to wait for the connection to be established  //                use count_services busy wait mechanism  //                until then we will sleep for a short period of time  std::this_thread::sleep_for(std::chrono::milliseconds(1000));  // Initialize a request.  example_interfaces__srv__AddTwoInts_Request client_request;  example_interfaces__srv__AddTwoInts_Request__init(&client_request);  client_request.a = 1;  client_request.b = 2;  int64_t sequence_number;  ret = rcl_send_request(&client, &client_request, &sequence_number);  EXPECT_EQ(sequence_number, 1);  example_interfaces__srv__AddTwoInts_Request__fini(&client_request);  ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  bool success;  wait_for_service_to_be_ready(&service, 10, 100, success);  ASSERT_TRUE(success);  // This scope simulates the service responding in a different context so that we can  // test take_request/send_response in a single-threaded, deterministic execution.  {    // Initialize a response.    example_interfaces__srv__AddTwoInts_Response service_response;    example_interfaces__srv__AddTwoInts_Response__init(&service_response);    auto msg_exit = make_scope_exit([&service_response]() {      stop_memory_checking();      example_interfaces__srv__AddTwoInts_Response__fini(&service_response);    });    // Initialize a separate instance of the request and take the pending request.    example_interfaces__srv__AddTwoInts_Request service_request;    example_interfaces__srv__AddTwoInts_Request__init(&service_request);    rmw_request_id_t header;    ret = rcl_take_request(&service, &header, &service_request);    ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();    EXPECT_EQ(1, service_request.a);    EXPECT_EQ(2, service_request.b);    // Simulate a response callback by summing the request and send the response..    service_response.sum = service_request.a + service_request.b;    ret = rcl_send_response(&service, &header, &service_response);    ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  }  wait_for_service_to_be_ready(&service, 10, 100, success);  // Initialize the response owned by the client and take the response.  example_interfaces__srv__AddTwoInts_Response client_response;  example_interfaces__srv__AddTwoInts_Response__init(&client_response);  rmw_request_id_t header;  ret = rcl_take_response(&client, &header, &client_response);  ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();  EXPECT_EQ(client_response.sum, 3);  EXPECT_EQ(header.sequence_number, 1);}

sgraph& unity_sgraph::get_graph() const {  ASSERT_TRUE(m_graph);  return (*m_graph)();};

TEST_F(TestGet, test_get_one_row){  int err = 0;  CommonSchemaManagerWrapper schema_mgr;  tbsys::CConfig config;  bool ret_val = schema_mgr.parse_from_file("scan_schema.ini", config);  ASSERT_TRUE(ret_val);  ObUpsTableMgr& mgr = ObUpdateServerMain::get_instance()->get_update_server().get_table_mgr();  err = mgr.init();  ASSERT_EQ(0, err);  err = mgr.set_schemas(schema_mgr);  ASSERT_EQ(0, err);  TestUpsTableMgrHelper test_helper(mgr);  TableMgr& table_mgr = test_helper.get_table_mgr();  table_mgr.sstable_scan_finished(10);  TableItem* active_memtable_item = table_mgr.get_active_memtable();  MemTable& active_memtable = active_memtable_item->get_memtable();  // construct multi-row mutator  static const int64_t ROW_NUM = 1;  static const int64_t COL_NUM = 10;  ObCellInfo cell_infos[ROW_NUM][COL_NUM];  std::bitset<COL_NUM> check_flags[ROW_NUM];  char row_key_strs[ROW_NUM][50];  uint64_t table_id = 10;  // init cell infos  for (int64_t i = 0; i < ROW_NUM; ++i)  {    sprintf(row_key_strs[i], "row_key_%08ld", i);    for (int64_t j = 0; j < COL_NUM; ++j)    {      cell_infos[i][j].table_id_ = table_id;      cell_infos[i][j].row_key_ = make_rowkey(row_key_strs[i], &allocator_);      cell_infos[i][j].column_id_ = j + 10;      cell_infos[i][j].value_.set_int(1000 + i * COL_NUM + j);    }  }  ObUpsMutator ups_mutator;  ObMutator &mutator = ups_mutator.get_mutator();  // add cell to array  for (int64_t i = 0; i < ROW_NUM; ++i)  {    for (int64_t j = 0; j < COL_NUM; ++j)    {      ObMutatorCellInfo mutator_cell;      mutator_cell.cell_info = cell_infos[i][j];      mutator_cell.op_type.set_ext(ObActionFlag::OP_UPDATE);      err = mutator.add_cell(mutator_cell);      EXPECT_EQ(0, err);    }  }  prepare_mutator(mutator);  // write row to active memtable  uint64_t trans_descriptor = 0;  err = active_memtable.start_transaction(WRITE_TRANSACTION, trans_descriptor);  ASSERT_EQ(0, err);  err = active_memtable.start_mutation(trans_descriptor);  ASSERT_EQ(0, err);  err = active_memtable.set(trans_descriptor, ups_mutator);  EXPECT_EQ(0, err);  err = active_memtable.end_mutation(trans_descriptor, false);  ASSERT_EQ(0, err);  err = active_memtable.end_transaction(trans_descriptor, false);  ASSERT_EQ(0, err);  /*  ObString text;  text.assign("/tmp", strlen("/tmp"));  active_memtable.dump2text(text);  */  for (int64_t i = 0; i < ROW_NUM; ++i)  {    ObScanner scanner;    ObGetParam get_param;    //get_param.set_timestamp(version);    ObVersionRange version_range;    //version_range.start_version_ = version;    //version_range.end_version_ = version;    version_range.start_version_ = 2;    //version_range.end_version_ = 2;    version_range.border_flag_.set_inclusive_start();    //version_range.border_flag_.set_inclusive_end();    version_range.border_flag_.set_max_value();    get_param.set_version_range(version_range);    for (int64_t j = 0; j < COL_NUM; ++j)    {      get_param.add_cell(cell_infos[i][j]);    }    int64_t count = 0;    err = mgr.get(get_param, scanner, tbsys::CTimeUtil::getTime(), 2000000000 * 1000L * 1000L);    EXPECT_EQ(0, err);//.........这里部分代码省略.........

TEST(ProcessorSet, empty) {  ProcessorSet processor_set;  ASSERT_TRUE(processor_set.empty());  processor_set.set(0);  ASSERT_FALSE(processor_set.empty());}

TEST(RandoTest, nearestToZero){  Rando rando;  int a, b;  ASSERT_TRUE( rando.nearestToZero(a,b));}

TEST_F(MorphoGeneSerializationTest,isEqualAfterSerialization) {    ASSERT_TRUE(morphoGene != morphoGene2);    ASSERT_TRUE(morphoGene->equals(*morphoGene2));}

	void WriteOut()	{		ASSERT_TRUE(writer.WriteOut("binaryTest.dat", false));	}

CTEST2(tube_stream, get_tube_manager){    tube_manager *tm = tube_stream_manager_get_manager(data->sm);    ASSERT_TRUE( (uintptr_t)tm == (uintptr_t)data->sm );}

	//}	virtual void TearDown()	{		ASSERT_TRUE(s_pCmdParser != nullptr);		s_pCmdParser->resetStatu();	}

void consumer(qi::atomic<long> &gSuccess, qi::Future<int> fut) {  //wont block thread on error  ASSERT_TRUE(fut.wait(1000));  EXPECT_EQ(42, fut.value());  ++gSuccess;}

TEST(is_just_whitespaces, demo_case_true){   ASSERT_TRUE(mzlib::is_just_whitespaces("/t/n /r/v/f"));}

void NamenodeTest::test_namenode_server(){	for (int i = 1; i <= FLAGS_N; i++)	{		ThriftResult result;		DatanodeHeartbeat hti;		hti.endpoint.nodeid = i;		mCluster.get_namenode_if()->datanode_heartbeat(result, hti);	}	sleep(2); //wait for heartbeat finish	FileWriteToken token;	mServer->get_write_token(token);	int32_t blockid = token.blockid;	ASSERT_TRUE(token.chunkids.size() == (size_t)FLAGS_N);	std::set<int32_t> failed;	int32_t failid = *token.chunkids.begin();	LOG(ERROR) << "failed block id " << failid;	failed.insert(failid);	FileWriteToken fix_token;	mServer->fix_write_token(fix_token, blockid, failed);	ASSERT_TRUE(fix_token.chunkids[0] != token.chunkids[0]);	for (int i = 1; i < FLAGS_N; i++) {		ASSERT_TRUE(fix_token.chunkids[i] == token.chunkids[i]);	}	for (int i = 0; i < FLAGS_N; i++)	{		ThriftResult result;		std::string data("hello world");		int32_t chunkid = fix_token.chunkids[i];		mCluster.get_datanode_if(NODE_ID(chunkid))->put_chunk(result, chunkid, data);	}	mServer->commit_write(blockid);	FileReadToken read_token;	mServer->get_read_token(read_token, blockid);	for (int i = 0; i < FLAGS_N; i++) {		ASSERT_TRUE(fix_token.chunkids[i] == read_token.chunkids[i]);	}	mServer->get_oplog_manager().uninit();	mServer->get_oplog_manager().init();	FileReadToken new_read;	mServer->get_read_token(new_read, blockid);	for (int i = 0; i < FLAGS_N; i++) {		ASSERT_TRUE(fix_token.chunkids[i] == new_read.chunkids[i]);	}	mServer->delete_block(blockid);	mServer->get_oplog_manager().uninit();	mServer->get_oplog_manager().init();	std::vector<int32_t> chunkids;	mServer->get_block_manager().get_chunk_ids(blockid, chunkids, true);	ASSERT_TRUE(chunkids.empty());}

// This test is disable because it is for generating test data.TEST(libbacktrace, DISABLED_generate_offline_testdata) {  // Create a thread to generate the needed stack and registers information.  const size_t stack_size = 16 * 1024;  void* stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);  ASSERT_NE(MAP_FAILED, stack);  uintptr_t stack_addr = reinterpret_cast<uintptr_t>(stack);  pthread_attr_t attr;  ASSERT_EQ(0, pthread_attr_init(&attr));  ASSERT_EQ(0, pthread_attr_setstack(&attr, reinterpret_cast<void*>(stack), stack_size));  pthread_t thread;  OfflineThreadArg arg;  arg.exit_flag = 0;  ASSERT_EQ(0, pthread_create(&thread, &attr, OfflineThreadFunc, &arg));  // Wait for the offline thread to generate the stack and unw_context information.  sleep(1);  // Copy the stack information.  std::vector<uint8_t> stack_data(reinterpret_cast<uint8_t*>(stack),                                  reinterpret_cast<uint8_t*>(stack) + stack_size);  arg.exit_flag = 1;  ASSERT_EQ(0, pthread_join(thread, nullptr));  ASSERT_EQ(0, munmap(stack, stack_size));  std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));  ASSERT_TRUE(map != nullptr);  backtrace_stackinfo_t stack_info;  stack_info.start = stack_addr;  stack_info.end = stack_addr + stack_size;  stack_info.data = stack_data.data();  // Generate offline testdata.  std::string testdata;  // 1. Dump pid, tid  testdata += android::base::StringPrintf("pid: %d tid: %d/n", getpid(), arg.tid);  // 2. Dump maps  for (auto it = map->begin(); it != map->end(); ++it) {    testdata += android::base::StringPrintf(        "map: start: %" PRIxPTR " end: %" PRIxPTR " offset: %" PRIxPTR " load_bias: %" PRIxPTR        " flags: %d name: %s/n",        it->start, it->end, it->offset, it->load_bias, it->flags, it->name.c_str());  }  // 3. Dump registers  testdata += android::base::StringPrintf("registers: %zu ", sizeof(arg.unw_context));  testdata += RawDataToHexString(&arg.unw_context, sizeof(arg.unw_context));  testdata.push_back('/n');  // 4. Dump stack  testdata += android::base::StringPrintf(      "stack: start: %" PRIx64 " end: %" PRIx64 " size: %zu ",      stack_info.start, stack_info.end, stack_data.size());  testdata += RawDataToHexString(stack_data.data(), stack_data.size());  testdata.push_back('/n');  // 5. Dump function symbols  std::vector<FunctionSymbol> function_symbols = GetFunctionSymbols();  for (const auto& symbol : function_symbols) {    testdata += android::base::StringPrintf(        "function: start: %" PRIxPTR " end: %" PRIxPTR" name: %s/n",        symbol.start, symbol.end, symbol.name.c_str());  }  ASSERT_TRUE(android::base::WriteStringToFile(testdata, "offline_testdata"));}

int main(int argc, char** argv) {  // Initialize control plain using mpi  graphlab::mpi_tools::init(argc, argv);  graphlab::distributed_control dc;  dc_ptr = &dc;  global_logger().set_log_level(LOG_INFO);  // Parse command line options -----------------------------------------------  graphlab::command_line_options clopts("./ldademo");  std::string lda_edges;  std::string lda_dictionary;  bool USE_SYNC=false;  // The dir of the link graph   clopts.attach_option("lda_edges", lda_edges, "The lda graph (edges). Required ");  clopts.attach_option("lda_dictionary", lda_dictionary, "The lda word dictionary. Required ");  clopts.attach_option("wordid_offset", lda::WORDID_OFFSET, "The starting id of the words in the lda input.");  clopts.attach_option("ntopics", lda::NTOPICS, "Number of topics to use");  clopts.attach_option("topklda", lda::TOPK, "Top k words in each topic for display");  clopts.attach_option("force_lock", lda::FORCE_LOCK, "force locked words");  clopts.attach_option("use_sync", USE_SYNC, "Use Synchronous LDA");  if(!clopts.parse(argc, argv)) {    dc.cout() << "Error in parsing command line arguments." << std::endl;    return EXIT_FAILURE;  }  if(!clopts.is_set("lda_edges")) {    std::cout << "LDA edge file not provided" << std::endl;    clopts.print_description();    return EXIT_FAILURE;  }  if(!clopts.is_set("lda_dictionary")) {    std::cout << "LDA dictionary file not provided" << std::endl;    clopts.print_description();    return EXIT_FAILURE;  }  lda::INITIAL_NTOPICS = NTOPICS;  // Build the lda (right) graph  // The global lda_graph points to rgraph  lda::graph_type ldagraph(dc);  load_ldagraph(ldagraph, lda_edges, lda_dictionary);  // Run lda -----------------------------------------------------------------  launch_metric_server();  graphlab::graphlab_options opts;  std::string engine_type = "sync";  if (!USE_SYNC) {    opts.get_engine_args().set_option("factorized",true);    engine_type = "async";  }  //opts2.get_engine_args().set_option("handler_intercept",true);  graphlab::omni_engine<lda::cgs_lda_vertex_program> engine(dc, ldagraph, engine_type, opts);  lda::initialize_global();  {     const bool success =        engine.add_vertex_aggregator<lda::topk_aggregator>        ("topk", lda::topk_aggregator::map, lda::topk_aggregator::finalize) &&        engine.aggregate_periodic("topk", 1);    ASSERT_TRUE(success);  }  { // Add the Global counts aggregator    const bool success =        engine.add_vertex_aggregator<lda::factor_type>        ("global_counts",          lda::global_counts_aggregator::map,          lda::global_counts_aggregator::finalize) &&        engine.aggregate_periodic("global_counts", 1);    ASSERT_TRUE(success);  }  fn_run_lda(engine);// ------------FINALIZE------------------// --------------------------------------graphlab::stop_metric_server_on_eof();graphlab::mpi_tools::finalize();return EXIT_SUCCESS;}

TEST(auto_Object, out_of_scope) {  {    auto_Object<TestObject>(new TestObject);  }  ASSERT_TRUE(TestObject::deleted);}

// Tests that the default container logger writes files into the sandbox.TEST_F(ContainerLoggerTest, DefaultToSandbox){  // Create a master, agent, and framework.  Try<PID<Master>> master = StartMaster();  ASSERT_SOME(master);  Future<SlaveRegisteredMessage> slaveRegisteredMessage =    FUTURE_PROTOBUF(SlaveRegisteredMessage(), _, _);  // We'll need access to these flags later.  slave::Flags flags = CreateSlaveFlags();  Fetcher fetcher;  // We use an actual containerizer + executor since we want something to run.  Try<MesosContainerizer*> containerizer =    MesosContainerizer::create(flags, false, &fetcher);  CHECK_SOME(containerizer);  Try<PID<Slave>> slave = StartSlave(containerizer.get(), flags);  ASSERT_SOME(slave);  AWAIT_READY(slaveRegisteredMessage);  SlaveID slaveId = slaveRegisteredMessage.get().slave_id();  MockScheduler sched;  MesosSchedulerDriver driver(      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);  Future<FrameworkID> frameworkId;  EXPECT_CALL(sched, registered(&driver, _, _))    .WillOnce(FutureArg<1>(&frameworkId));  // Wait for an offer, and start a task.  Future<vector<Offer>> offers;  EXPECT_CALL(sched, resourceOffers(&driver, _))    .WillOnce(FutureArg<1>(&offers))    .WillRepeatedly(Return()); // Ignore subsequent offers.  driver.start();  AWAIT_READY(frameworkId);  AWAIT_READY(offers);  EXPECT_NE(0u, offers.get().size());  // We'll start a task that outputs to stdout.  TaskInfo task = createTask(offers.get()[0], "echo 'Hello World!'");  Future<TaskStatus> status;  EXPECT_CALL(sched, statusUpdate(&driver, _))    .WillOnce(FutureArg<1>(&status))    .WillRepeatedly(Return());       // Ignore subsequent updates.  driver.launchTasks(offers.get()[0].id(), {task});  AWAIT_READY(status);  EXPECT_EQ(TASK_RUNNING, status.get().state());  // Check that the sandbox was written to.  string sandboxDirectory = path::join(      slave::paths::getExecutorPath(          flags.work_dir,          slaveId,          frameworkId.get(),          status->executor_id()),      "runs",      "latest");  ASSERT_TRUE(os::exists(sandboxDirectory));  string stdoutPath = path::join(sandboxDirectory, "stdout");  ASSERT_TRUE(os::exists(stdoutPath));  Result<string> stdout = os::read(stdoutPath);  ASSERT_SOME(stdout);  EXPECT_TRUE(strings::contains(stdout.get(), "Hello World!"));  driver.stop();  driver.join();  Shutdown();}

TEST(OmplPlanning, PathConstrainedSimplePlan){  ros::NodeHandle nh;  ros::service::waitForService(PLANNER_SERVICE_NAME);  ros::Publisher pub = nh.advertise<moveit_msgs::DisplayTrajectory>("display_motion_plan", 1);  ros::ServiceClient planning_service_client = nh.serviceClient<moveit_msgs::GetMotionPlan>(PLANNER_SERVICE_NAME);  EXPECT_TRUE(planning_service_client.exists());  EXPECT_TRUE(planning_service_client.isValid());  moveit_msgs::GetMotionPlan::Request mplan_req;  moveit_msgs::GetMotionPlan::Response mplan_res;  planning_scene_monitor::PlanningSceneMonitor psm(ROBOT_DESCRIPTION);  planning_scene::PlanningScene &scene = *psm.getPlanningScene();  EXPECT_TRUE(scene.isConfigured());  mplan_req.motion_plan_request.planner_id = "RRTConnectkConfigDefault";  mplan_req.motion_plan_request.group_name = "right_arm";  mplan_req.motion_plan_request.num_planning_attempts = 1;  mplan_req.motion_plan_request.allowed_planning_time = ros::Duration(15.0);  const std::vector<std::string>& joint_names = scene.getRobotModel()->getJointModelGroup("right_arm")->getJointModelNames();  mplan_req.motion_plan_request.start_state.joint_state.name = joint_names;  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.21044517893021499);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(0.038959594993384528);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-0.81412902362644646);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.0989597173881371);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(2.3582101183671629);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.993988668449755);  mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-2.2779628049776051);  moveit_msgs::PositionConstraint pcm;  pcm.link_name = "r_wrist_roll_link";  pcm.header.frame_id = psm.getPlanningScene()->getPlanningFrame();  pcm.constraint_region.primitive_poses.resize(1);  pcm.constraint_region.primitive_poses[0].position.x = 0.5;  pcm.constraint_region.primitive_poses[0].position.y = 0.0;  pcm.constraint_region.primitive_poses[0].position.z = 0.7;  pcm.constraint_region.primitive_poses[0].orientation.w = 1.0;  pcm.constraint_region.primitives.resize(1);  pcm.constraint_region.primitives[0].type = shape_msgs::SolidPrimitive::BOX;  pcm.constraint_region.primitives[0].dimensions.x = 0.1;  pcm.constraint_region.primitives[0].dimensions.y = 0.1;  pcm.constraint_region.primitives[0].dimensions.z = 0.1;  pcm.weight = 1.0;  mplan_req.motion_plan_request.goal_constraints.resize(1);  mplan_req.motion_plan_request.goal_constraints[0].position_constraints.push_back(pcm);  // add path constraints  moveit_msgs::Constraints &constr = mplan_req.motion_plan_request.path_constraints;  constr.orientation_constraints.resize(1);  moveit_msgs::OrientationConstraint &ocm = constr.orientation_constraints[0];  ocm.link_name = "r_wrist_roll_link";  ocm.header.frame_id = psm.getPlanningScene()->getPlanningFrame();  ocm.orientation.x = 0.0;  ocm.orientation.y = 0.0;  ocm.orientation.z = 0.0;  ocm.orientation.w = 1.0;  ocm.absolute_x_axis_tolerance = 0.15;  ocm.absolute_y_axis_tolerance = 0.15;  ocm.absolute_z_axis_tolerance = M_PI;  ocm.weight = 1.0;  std::cout << mplan_req.motion_plan_request << std::endl;  ASSERT_TRUE(planning_service_client.call(mplan_req, mplan_res));  ASSERT_EQ(mplan_res.error_code.val, mplan_res.error_code.SUCCESS);  EXPECT_GT(mplan_res.trajectory.joint_trajectory.points.size(), 0);  moveit_msgs::DisplayTrajectory d;  d.model_id = scene.getRobotModel()->getName();  d.trajectory_start = mplan_res.trajectory_start;  d.trajectory = mplan_res.trajectory;  pub.publish(d);  ros::Duration(0.5).sleep();}

TEST_F(CampaignTest, testAircraftHandling){	const vec2_t destination = { 10, 10 };	base_t* base;	aircraft_t* aircraft;	aircraft_t* newAircraft;	aircraft_t* aircraftTemplate;	int firstIdx;	int initialCount;	int count;	int newFound;	base = CreateBase("unittestaircraft", destination);	ASSERT_TRUE(nullptr != base);	/** @todo we should not assume that initial base has aircraft. It's a campaign parameter */	aircraft = AIR_GetFirstFromBase(base);	ASSERT_TRUE(nullptr != aircraft);	/* aircraft should have a template */	aircraftTemplate = aircraft->tpl;	ASSERT_TRUE(nullptr != aircraftTemplate);	firstIdx = aircraft->idx;	initialCount = AIR_BaseCountAircraft(base);	/* test deletion (part 1) */	AIR_DeleteAircraft(aircraft);	count = AIR_BaseCountAircraft(base);	ASSERT_EQ(count, initialCount - 1);	/* test addition (part 1) */	newAircraft = AIR_NewAircraft(base, aircraftTemplate);	ASSERT_TRUE(nullptr != newAircraft);	count = AIR_BaseCountAircraft(base);	ASSERT_EQ(count, initialCount);	/* new aircraft assigned to the right base */	ASSERT_EQ(newAircraft->homebase, base);	newFound = 0;	AIR_Foreach(a) {		/* test deletion (part 2) */		ASSERT_NE(firstIdx, a->idx);		/* for test addition (part 2) */		if (a->idx == newAircraft->idx)			newFound++;	}	/* test addition (part 2) */	ASSERT_EQ(newFound, 1);	/* check if AIR_Foreach iterates through all aircraft */	AIR_Foreach(a) {		AIR_DeleteAircraft(a);	}	aircraft = AIR_GetFirstFromBase(base);	ASSERT_TRUE(nullptr == aircraft);	count = AIR_BaseCountAircraft(base);	ASSERT_EQ(count, 0);	/* cleanup for the following tests */	E_DeleteAllEmployees(nullptr);	base->founded = false;}

TEST(testBattery, GetSystemPowerStatus){    SYSTEM_POWER_STATUS sps;    ASSERT_TRUE(GetSystemPowerStatus(&sps));}

TEST(EditorTest, panZoom){    GamePair pair;    EditorUserInterface editorUi(pair.getClient(0), NULL);    // The basics    F32 scale = 1.1f;    editorUi.setDisplayScale(scale);    ASSERT_EQ(scale, editorUi.getCurrentScale());    Point center(33,44);    editorUi.setDisplayCenter(center);    ASSERT_FLOAT_EQ(center.x, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(center.y, editorUi.getDisplayCenter().y);    // Changing center shouldn't change scale    ASSERT_EQ(scale, editorUi.getCurrentScale());    // Changing scale shouldn't change center    scale = 1.4f;    editorUi.setDisplayScale(scale);    ASSERT_EQ(scale, editorUi.getCurrentScale());    ASSERT_FLOAT_EQ(center.x, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(center.y, editorUi.getDisplayCenter().y);    // Make sure center is what we expect after setting extents -- use non-proportionate size    editorUi.setDisplayExtents(Rect(0,0,  1000,1000));    ASSERT_FLOAT_EQ(0.6f, editorUi.getCurrentScale());    // Based on standard 800x600 window size    ASSERT_FLOAT_EQ(500, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(500, editorUi.getDisplayCenter().y);    Rect r;    r = editorUi.getDisplayExtents();    ASSERT_FLOAT_EQ(-166.666667f, r.min.x);   // These depend on 800x600 display aspect ratio    ASSERT_FLOAT_EQ(1166.666667f, r.max.x);    ASSERT_TRUE(fabs(r.min.y) < .0001);        // We're getting errors here too great to use ASSERT_FLOAT_EQ    ASSERT_FLOAT_EQ(1000       , r.max.y);    ASSERT_FLOAT_EQ(r.getCenter().x, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(r.getCenter().y, editorUi.getDisplayCenter().y);    editorUi.setDisplayExtents(Rect(0,0,  800,600));    EXPECT_FLOAT_EQ(1, editorUi.getCurrentScale());    // Based on standard 800x600 window size    ASSERT_FLOAT_EQ(400, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(300, editorUi.getDisplayCenter().y);    r = editorUi.getDisplayExtents();    ASSERT_FLOAT_EQ(r.getCenter().x, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(r.getCenter().y, editorUi.getDisplayCenter().y);    // Zooming out should double the extents, but not change the center    scale = editorUi.getCurrentScale() / 2;    editorUi.setDisplayScale(scale);    ASSERT_FLOAT_EQ(400, editorUi.getDisplayCenter().x);    ASSERT_FLOAT_EQ(300, editorUi.getDisplayCenter().y);    r = editorUi.getDisplayExtents();    ASSERT_FLOAT_EQ(-400, r.min.x);    ASSERT_FLOAT_EQ(-300, r.min.y);    ASSERT_FLOAT_EQ(1200, r.max.x);    ASSERT_FLOAT_EQ( 900, r.max.y);}

std::string TmpDir() {  std::string dir;  Status s = Env::Default()->GetTestDirectory(&dir);  ASSERT_TRUE(s.ok()) << s.ToString();  return dir;}

/** * Verify that seekg works going forward */TEST_F(StreamFunctionsTest, seekgBasicForward) {    const std::streampos step = 2;    m_stream->seekg(step);    ASSERT_TRUE(streamAndDataAreEqual(*m_stream, TEST_DATA + step, sizeof(TEST_DATA) - step));}

/** * @brief This test cycles through the list of map definitions found in the maps.ufo script * and builds each map with each ufo and every assembly for all valid seeds. * In other words: this a FULL test to check if some seed causes problems in any of the * possible combinations, so it should not be run on the buildserver on a daily basis. */TEST_F(MapDefMassRMATest, DISABLED_MapDefsMassRMA){	/** You can test a certain assembly by passing "-Dmapdef-id=assembly" to testall. */	const char* filterId = TEST_GetStringProperty("mapdef-id");	const mapDef_t* md;	int mapCount = 0;	ASSERT_TRUE(csi.numMDs > 0);	MapDef_Foreach(md) {		if (md->mapTheme[0] == '.')			continue;		if (filterId && !Q_streq(filterId, md->id))			continue;		if (++mapCount <= 0)		/* change 0 to n to skip the first n assemblies */			continue;		{			char* p = md->mapTheme;			if (*p == '+')				p++;			else				continue;			const char* asmName = (const char*)LIST_GetByIdx(md->params, 0);			Com_Printf("/nMap: %s Assembly: %s AssNr: %i/n", p, asmName, mapCount);			sv_threads->integer = 0;			/* This is tricky. Some maps don't have any ufo on them and thus in the mapdef.			 * That would cause a LIST_Foreach macro to never run it's body. That's why these			 * for-loops seem to have two termination conditions. In fact, we have to manually			 * exit the for-loops if we ran it just once (without ufos nor dropships).			 */			bool didItOnce = false;			linkedList_t* iterDrop;			for (iterDrop = md->aircraft; iterDrop || !didItOnce; iterDrop = iterDrop->next) {				const char* craft = nullptr;				if (iterDrop)					craft = (const char*) (iterDrop->data);				if (craft)					Cvar_Set("rm_drop", "%s", Com_GetRandomMapAssemblyNameForCraft(craft));				else					Cvar_Set("rm_drop", "+craft_drop_firebird");				linkedList_t* iterUfo;				for (iterUfo = md->ufos; iterUfo || !didItOnce; iterUfo = iterUfo->next) {					const char* ufo = nullptr;					if (iterUfo)						ufo = (const char*) (iterUfo->data);					if (ufo)						Cvar_Set("rm_ufo", "%s", Com_GetRandomMapAssemblyNameForCraft(ufo));					else						Cvar_Set("rm_ufo", "+craft_ufo_scout");					Com_Printf("/nDrop: %s Ufo: %s", craft, ufo);					Com_Printf("/nSeed:");					for (int i = 0; i < RMA_HIGHEST_SUPPORTED_SEED; i++) {						asmName = nullptr;						srand(i);						long time = Sys_Milliseconds();						Com_Printf(" %i", i);#if 0						typedef struct skip_info {							int         seed;							char const* map;							char const* params;							char const* craft;							char const* ufo;						} skip_info;						/* if we have known problems with some combinations, we can skip them */						skip_info const skip_list[] = {							/* examples: */						//	{ 20, "forest",		"large",		"craft_drop_raptor",   0                     },						//	{ 12, "forest",		"large"			"craft_drop_herakles", "craft_ufo_harvester" },							{ -1, "frozen",		"nature_medium",0,                     0                     },							{ 11, "village",	"medium",		0,                     0					 },							{ 19, "village",	"medium",		0,                     0					 },							{ -1, "village",	"medium_noufo",	0,                     0					 },							{ -1, "village",	"small",		0,                     0					 },						};						bool skip = false;						for (skip_info const* e = skip_list; e != endof(skip_list); ++e) {							if (e->seed >= 0 && i != e->seed)								continue;							if (e->map && !Q_streq(p, e->map))								continue;							if (e->params && !Q_streq(md->params, e->params))								continue;							if (e->craft && !Q_streq(craft, e->craft))//.........这里部分代码省略.........