Robot: Fix unit test EXPECT_TRUE, EXPECT_FALSE logic.

cyber/component/component_test.cc

@@ -80,15 +80,15 @@ TEST(TimerComponent, init) {
   apollo::cyber::proto::ReaderOption *read_opt = compcfg.add_readers();
   read_opt->set_channel("/perception/channel");
   auto comC = std::make_shared<Component_C<RawMessage>>();
-  EXPECT_EQ(true, comC->Initialize(compcfg));
-  EXPECT_EQ(true, comC->Process(msg_str1));
+  EXPECT_TRUE(comC->Initialize(compcfg));
+  EXPECT_TRUE(comC->Process(msg_str1));
 
   compcfg.set_name("perception2");
   apollo::cyber::proto::ReaderOption *read_opt2 = compcfg.add_readers();
   read_opt2->set_channel("/driver/channel1");
   auto comB = std::make_shared<Component_B<RawMessage, RawMessage>>();
-  EXPECT_EQ(true, comB->Initialize(compcfg));
-  EXPECT_EQ(true, comB->Process(msg_str1, msg_str2));
+  EXPECT_TRUE(comB->Initialize(compcfg));
+  EXPECT_TRUE(comB->Process(msg_str1, msg_str2));
 
   compcfg.set_name("perception3");
   apollo::cyber::proto::ReaderOption *read_opt3 = compcfg.add_readers();
@@ -98,8 +98,8 @@ TEST(TimerComponent, init) {
   read_opt4->set_channel("/driver/channel3");
   auto comA = std::make_shared<
       Component_A<RawMessage, RawMessage, RawMessage, RawMessage>>();
-  EXPECT_EQ(true, comA->Initialize(compcfg));
-  EXPECT_EQ(true, comA->Process(msg_str1, msg_str2, msg_str3, msg_str4));
+  EXPECT_TRUE(comA->Initialize(compcfg));
+  EXPECT_TRUE(comA->Process(msg_str1, msg_str2, msg_str3, msg_str4));
 }
 
 TEST(TimerComponentFail, init) {
@@ -116,23 +116,23 @@ TEST(TimerComponentFail, init) {
   apollo::cyber::proto::ReaderOption *read_opt = compcfg.add_readers();
   read_opt->set_channel("/perception/channel");
   auto comC = std::make_shared<Component_C<RawMessage>>();
-  EXPECT_EQ(false, comC->Initialize(compcfg));
-  EXPECT_EQ(false, comC->Process(msg_str1));
+  EXPECT_FALSE(comC->Initialize(compcfg));
+  EXPECT_FALSE(comC->Process(msg_str1));
 
   compcfg.set_name("perception2_f");
   apollo::cyber::proto::ReaderOption *read_opt2 = compcfg.add_readers();
   read_opt2->set_channel("/driver/channel");
   auto comB = std::make_shared<Component_B<RawMessage, RawMessage>>();
-  EXPECT_EQ(false, comB->Initialize(compcfg));
-  EXPECT_EQ(false, comB->Process(msg_str1, msg_str2));
+  EXPECT_FALSE(comB->Initialize(compcfg));
+  EXPECT_FALSE(comB->Process(msg_str1, msg_str2));
 
   compcfg.set_name("perception3_F");
   apollo::cyber::proto::ReaderOption *read_opt3 = compcfg.add_readers();
   read_opt3->set_channel("/driver/channel");
   auto comA = std::make_shared<
       Component_A<RawMessage, RawMessage, RawMessage, RawMessage>>();
-  EXPECT_EQ(false, comA->Initialize(compcfg));
-  EXPECT_EQ(false, comA->Process(msg_str1, msg_str2, msg_str3, msg_str4));
+  EXPECT_FALSE(comA->Initialize(compcfg));
+  EXPECT_FALSE(comA->Process(msg_str1, msg_str2, msg_str3, msg_str4));
 }
 
 }  // namespace cyber

cyber/component/timer_component_test.cc

@@ -43,8 +43,8 @@ TEST(TimerComponent, timertest) {
   compcfg.set_interval(100);
 
   std::shared_ptr<Component_Timer> com = std::make_shared<Component_Timer>();
-  EXPECT_EQ(true, com->Initialize(compcfg));
-  EXPECT_EQ(true, com->Process());
+  EXPECT_TRUE(com->Initialize(compcfg));
+  EXPECT_TRUE(com->Process());
 }
 
 TEST(TimerComponentFalse, timerfail) {
@@ -56,8 +56,8 @@ TEST(TimerComponentFalse, timerfail) {
   compcfg.set_interval(100);
 
   std::shared_ptr<Component_Timer> com = std::make_shared<Component_Timer>();
-  EXPECT_EQ(false, com->Initialize(compcfg));
-  EXPECT_EQ(false, com->Process());
+  EXPECT_FALSE(com->Initialize(compcfg));
+  EXPECT_FALSE(com->Process());
 }
 }  // namespace cyber
 }  // namespace apollo

cyber/node/writer_reader_test.cc

@@ -263,8 +263,8 @@ TEST(WriterReaderTest, user_defined_message) {
   attr.set_channel_id(channel_id);
   attr.mutable_qos_profile()->set_depth(10);
 
-  EXPECT_EQ(false, message::HasSerializer<Message>::value);
-  EXPECT_EQ(false, message::HasType<Message>::value);
+  EXPECT_FALSE(message::HasSerializer<Message>::value);
+  EXPECT_FALSE(message::HasType<Message>::value);
 
   auto node = CreateNode("node");
   ASSERT_TRUE(node);

modules/control/common/pid_controller_test.cc

@@ -55,7 +55,7 @@ TEST_F(PidControllerTest, StationPidController) {
   EXPECT_NEAR(control_value, -0.01, 1e-6);
   dt = 0.0;
   EXPECT_EQ(pid_controller.Control(100, dt), control_value);
-  EXPECT_EQ(pid_controller.IntegratorHold(), false);
+  EXPECT_FALSE(pid_controller.IntegratorHold());
 }
 
 TEST_F(PidControllerTest, SpeedPidController) {

modules/dreamview/backend/data_collection_monitor/data_collection_monitor_test.cc

@@ -72,41 +72,41 @@ TEST_F(DataCollectionMonitorTest, UpdateCollectionProgress) {
     bool hasField;
 
     hasField = JsonUtil::GetNumberFromJson(progress, "mps < 10", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(0.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "mps >= 10", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(50.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Throttle == 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(0.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Throttle != 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(25.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Brake <= 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(50.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Brake > 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(0.0, value);
 
     hasField =
         JsonUtil::GetNumberFromJson(progress, "Left steering < 20%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(0.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Right steering 20% ~ 40%",
                                            &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(10.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Overall", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(10.0, value);
   }
 
@@ -119,25 +119,25 @@ TEST_F(DataCollectionMonitorTest, UpdateCollectionProgress) {
     bool hasField;
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Brake <= 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(100.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Throttle != 30%", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(75.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Right steering 20% ~ 40%",
                                            &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(30.0, value);
 
     hasField = JsonUtil::GetNumberFromJson(progress, "Overall", &value);
-    EXPECT_EQ(true, hasField);
+    EXPECT_TRUE(hasField);
     EXPECT_DOUBLE_EQ(30.0, value);
   }
 
   data_collection_monitor_->Stop();
-  EXPECT_EQ(false, data_collection_monitor_->IsEnabled());
+  EXPECT_FALSE(data_collection_monitor_->IsEnabled());
 }
 
 }  // namespace dreamview

modules/perception/camera/test/camera_common_data_provider_test.cc

@@ -294,9 +294,9 @@ TEST(DataProvider, test_undistortion) {
   init_options.do_undistortion = true;
   init_options.sensor_name = "none_onsemi_obstacle";
   init_options.device_id = 0;
-  EXPECT_EQ(data_provider.Init(init_options), false);
+  EXPECT_FALSE(data_provider.Init(init_options));
   init_options.sensor_name = "onsemi_obstacle";
-  EXPECT_EQ(data_provider.Init(init_options), true);
+  EXPECT_TRUE(data_provider.Init(init_options));
 
   EXPECT_TRUE(
       data_provider.FillImageData(img.rows, img.cols, img.data, "bgr8"));

modules/perception/lib/config_manager/config_manager_test.cc

@@ -102,9 +102,9 @@ TEST_F(ConfigManagerTest, TestModelConfig) {
 
   bool bool_value = false;
   EXPECT_TRUE(model_config->get_value("bool_value_true", &bool_value));
-  EXPECT_EQ(bool_value, true);
+  EXPECT_TRUE(bool_value);
   EXPECT_TRUE(model_config->get_value("bool_value_false", &bool_value));
-  EXPECT_EQ(bool_value, false);
+  EXPECT_FALSE(bool_value);
 
   std::vector<int> int_list;
   EXPECT_TRUE(model_config->get_value("array_p1", &int_list));
@@ -124,7 +124,7 @@ TEST_F(ConfigManagerTest, TestModelConfig) {
   std::vector<bool> bool_list;
   EXPECT_TRUE(model_config->get_value("array_bool", &bool_list));
   EXPECT_EQ(bool_list.size(), 4u);
-  EXPECT_EQ(bool_list[2], true);
+  EXPECT_TRUE(bool_list[2]);
 
   // not exist
   EXPECT_FALSE(model_config->get_value("array_p3", &double_list));

modules/perception/radar/lib/interface/base_matcher_test.cc

@@ -26,9 +26,8 @@ namespace perception {
 namespace radar {
 
 TEST(BaseMatcherTest, base_matcher_test) {
-  BaseMatcher* matcher = new BaseMatcher();
-  EXPECT_TRUE(matcher != nullptr);
-  EXPECT_EQ(matcher->Init(), true);
+  std::unique_ptr<BaseMatcher> matcher(new BaseMatcher());
+  EXPECT_TRUE(matcher->Init());
   EXPECT_EQ(matcher->Name(), "BaseMatcher");
   double match_distance = 2.5;
   BaseMatcher::SetMaxMatchDistance(match_distance);
@@ -71,8 +70,7 @@ TEST(BaseMatcherTest, base_matcher_test) {
   bool match_state =
       matcher->Match(radar_tracks, radar_frame, options, &assignments,
                      &unassigned_tracks, &unassigned_objects);
-  EXPECT_EQ(match_state, true);
-  delete matcher;
+  EXPECT_TRUE(match_state);
 }
 
 }  // namespace radar

modules/perception/radar/lib/tracker/common/radar_track_test.cc

@@ -39,10 +39,10 @@ TEST(RadarTrackTest, radar_track_test) {
   double timestamp = 123456789.0;
   RadarTrackPtr radar_track(new RadarTrack(object, timestamp));
   EXPECT_EQ(radar_track->GetObsId(), 0);
-  EXPECT_EQ(radar_track->ConfirmTrack(), false);
-  EXPECT_EQ(radar_track->IsDead(), false);
+  EXPECT_FALSE(radar_track->ConfirmTrack());
+  EXPECT_FALSE(radar_track->IsDead());
   radar_track->SetDead();
-  EXPECT_EQ(radar_track->IsDead(), true);
+  EXPECT_TRUE(radar_track->IsDead());
 
   base::ObjectPtr object2(new base::Object);
   object2->track_id = 100;
@@ -50,7 +50,7 @@ TEST(RadarTrackTest, radar_track_test) {
   object2->velocity << 3.0, 4.0, 0.0;
   double timestamp2 = 123456789.1;
   radar_track->UpdataObsRadar(object2, timestamp2);
-  EXPECT_EQ(radar_track->ConfirmTrack(), true);
+  EXPECT_TRUE(radar_track->ConfirmTrack());
 
   RadarTrackPtr radar_track2(new RadarTrack(object, timestamp));
   use_filter = true;
@@ -62,7 +62,7 @@ TEST(RadarTrackTest, radar_track_test) {
   double timestamp3 = 123456789.1;
   radar_track2->UpdataObsRadar(object3, timestamp3);
   EXPECT_TRUE(radar_track->GetTrackingTime() - 0.1 < 1e-5);
-  EXPECT_EQ(radar_track2->ConfirmTrack(), true);
+  EXPECT_TRUE(radar_track2->ConfirmTrack());
 
   chosen_filter = "Default";
   RadarTrack::SetChosenFilter(chosen_filter);

modules/perception/radar/lib/tracker/conti_ars_tracker/conti_ars_tracker_empty_test.cc

@@ -24,12 +24,11 @@ namespace perception {
 namespace radar {
 
 TEST(ContiArsTrackerTest, conti_ars_tracker_empty_init_test) {
-  BaseTracker* tracker = new ContiArsTracker();
+  std::unique_ptr<BaseTracker> tracker(new ContiArsTracker());
   FLAGS_work_root =
       "/apollo/modules/perception/testdata/"
       "radar/conti_ars_tracker/empty";
-  EXPECT_EQ(tracker->Init(), false);
-  delete tracker;
+  EXPECT_FALSE(tracker->Init());
 }
 
 }  // namespace radar

modules/perception/radar/lib/tracker/conti_ars_tracker/conti_ars_tracker_test.cc

@@ -27,17 +27,16 @@ namespace perception {
 namespace radar {
 
 TEST(ContiArsTrackerTest, conti_ars_tracker_init_test) {
-  BaseTracker* tracker = new ContiArsTracker();
+  std::unique_ptr<BaseTracker> tracker(new ContiArsTracker());
   FLAGS_work_root =
       "/apollo/modules/perception/testdata/"
       "radar/conti_ars_tracker";
-  EXPECT_EQ(tracker->Init(), true);
+  EXPECT_TRUE(tracker->Init());
   EXPECT_EQ(tracker->Name(), "ContiArsTracker");
-  delete tracker;
 }
 
 TEST(ContiArsTrackerTest, conti_ars_tracker_track_test) {
-  BaseTracker* tracker = new ContiArsTracker();
+  std::unique_ptr<BaseTracker> tracker(new ContiArsTracker());
   FLAGS_work_root = "./radar_test_data/conti_ars_tracker";
   tracker->Init();
   base::Frame radar_frame;
@@ -54,8 +53,7 @@ TEST(ContiArsTrackerTest, conti_ars_tracker_track_test) {
   TrackerOptions options;
   base::FramePtr tracked_frame(new base::Frame);
   bool state = tracker->Track(radar_frame, options, tracked_frame);
-  EXPECT_EQ(state, true);
-  delete tracker;
+  EXPECT_TRUE(state);
 }
 
 TEST(ContiArsTrackerTest, conti_ars_tracker_collect_test) {
@@ -66,7 +64,7 @@ TEST(ContiArsTrackerTest, conti_ars_tracker_collect_test) {
   double timestamp = 123456789.0;
   RadarTrackPtr radar_track(new RadarTrack(object, timestamp));
 
-  ContiArsTracker* tracker = new ContiArsTracker();
+  std::unique_ptr<ContiArsTracker> tracker(new ContiArsTracker());
   FLAGS_work_root = "./radar_test_data/conti_ars_tracker";
   tracker->Init();
   tracker->track_manager_->ClearTracks();
@@ -77,7 +75,6 @@ TEST(ContiArsTrackerTest, conti_ars_tracker_collect_test) {
   RadarTrack::SetTrackedTimesThreshold(0);
   tracker->CollectTrackedFrame(tracked_frame);
   EXPECT_EQ(tracked_frame->objects.size(), 1);
-  delete tracker;
 }
 
 TEST(ContiArsTrackerTest, conti_ars_tracker_unassigned_test) {
@@ -95,7 +92,7 @@ TEST(ContiArsTrackerTest, conti_ars_tracker_unassigned_test) {
   radar_frame.timestamp =
       timestamp + ContiArsTracker::s_tracking_time_win_ + 1e-5;
 
-  ContiArsTracker* tracker = new ContiArsTracker();
+  std::unique_ptr<ContiArsTracker> tracker(new ContiArsTracker());
   FLAGS_work_root = "./radar_test_data/conti_ars_tracker";
   tracker->Init();
   tracker->track_manager_->ClearTracks();
@@ -122,7 +119,6 @@ TEST(ContiArsTrackerTest, conti_ars_tracker_unassigned_test) {
   tracker->UpdateUnassignedTracks(radar_frame, unassigned_tracks);
   tracker->track_manager_->RemoveLostTracks();
   EXPECT_EQ(tracker->track_manager_->GetTracks().size(), 0);
-  delete tracker;
 }
 
 }  // namespace radar

modules/perception/radar/lib/tracker/matcher/hm_matcher_test.cc

@@ -31,10 +31,8 @@ namespace radar {
 TEST(HMMatcherTest, hm_matcher_init_test) {
   BaseMatcher* matcher = new HMMatcher();
   EXPECT_TRUE(matcher != nullptr);
-  FLAGS_work_root =
-      "/apollo/modules/perception/testdata/"
-      "radar/matcher";
-  EXPECT_EQ(matcher->Init(), true);
+  FLAGS_work_root = "/apollo/modules/perception/testdata/radar/matcher";
+  EXPECT_TRUE(matcher->Init());
   delete matcher;
 }
 
@@ -62,10 +60,8 @@ TEST(HMMatcherTest, hm_matcher_propterty_match_test) {
 TEST(HMMatcherTest, hm_matcher_test) {
   BaseMatcher* matcher = new HMMatcher();
   EXPECT_TRUE(matcher != nullptr);
-  FLAGS_work_root =
-      "/apollo/modules/perception/testdata/"
-      "radar/matcher";
-  EXPECT_EQ(matcher->Init(), true);
+  FLAGS_work_root = "/apollo/modules/perception/testdata/radar/matcher";
+  EXPECT_TRUE(matcher->Init());
   EXPECT_EQ(matcher->Name(), "HMMatcher");
   double match_distance = 2.5;
   BaseMatcher::SetMaxMatchDistance(match_distance);
@@ -122,7 +118,7 @@ TEST(HMMatcherTest, hm_matcher_test) {
   EXPECT_EQ(assignments.size(), 2);
   EXPECT_EQ(unassigned_tracks.size(), 1);
   EXPECT_EQ(unassigned_objects.size(), 1);
-  EXPECT_EQ(match_state, true);
+  EXPECT_TRUE(match_state);
   delete matcher;
 }