Localization: Refactor unit tests with EXPECT_ instead of ASSERT_.

modules/localization/msf/common/io/BUILD

@@ -14,15 +14,4 @@ cc_library(
     ],
 )
 
-cc_test(
-    name = "localization_msf_velodyne_utility_test",
-    size = "small",
-    timeout = "short",
-    srcs = ["velodyne_utility_test.cc"],
-    deps = [
-        "//modules/localization/msf/common/io:localization_msf_common_io",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
 cpplint()

modules/localization/msf/common/io/velodyne_utility_test.cc

-/******************************************************************************
- * Copyright 2017 The Apollo Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *****************************************************************************/
-
-#include "modules/localization/msf/common/io/velodyne_utility.h"
-
-#include "gtest/gtest.h"
-
-namespace apollo {
-namespace localization {
-namespace msf {
-
-class VelodyneUtilityTestSuite : public ::testing::Test {
- protected:
-  VelodyneUtilityTestSuite() {}
-  virtual ~VelodyneUtilityTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-/**@brief Test . */
-TEST_F(VelodyneUtilityTestSuite, test) { ASSERT_TRUE(true); }
-
-}  // namespace msf
-}  // namespace localization
-}  // namespace apollo

modules/localization/msf/common/util/compression_test.cc

@@ -22,16 +22,7 @@ namespace apollo {
 namespace localization {
 namespace msf {
 
-class CompressionTestSuite : public ::testing::Test {
- protected:
-  CompressionTestSuite() {}
-  virtual ~CompressionTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-/**@brief ZlibStrategyTest. */
-TEST_F(CompressionTestSuite, ZlibStrategyTest) {
+TEST(CompressionTestSuite, ZlibStrategyTest) {
   ZlibStrategy zlib;
   std::vector<unsigned char> buf_uncompressed;
   std::vector<unsigned char> buf_compressed;
@@ -44,7 +35,7 @@ TEST_F(CompressionTestSuite, ZlibStrategyTest) {
   zlib.Decode(&buf_compressed, &buf_uncompressed2);
 
   for (int i = 0; i < 255; i++) {
-    ASSERT_EQ(buf_uncompressed2[i], (unsigned char)i);
+    EXPECT_EQ(buf_uncompressed2[i], (unsigned char)i);
   }
 }
 

modules/localization/msf/common/util/frame_transform_test.cc

@@ -22,32 +22,24 @@ namespace apollo {
 namespace localization {
 namespace msf {
 
-class FrameTransformTestSuite : public ::testing::Test {
- protected:
-  FrameTransformTestSuite() {}
-  virtual ~FrameTransformTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-TEST_F(FrameTransformTestSuite, LatlonToUtmXYTest) {
+TEST(FrameTransformTestSuite, LatlonToUtmXYTest) {
   double lon_rad = -2.129343746458001;
   double lat_rad = 0.6530018835651807;
   UTMCoor utm_xy;
-  ASSERT_TRUE(FrameTransform::LatlonToUtmXY(lon_rad, lat_rad, &utm_xy));
-  ASSERT_LT(std::fabs(utm_xy.x - 588278.9834174265), 1e-5);
-  ASSERT_LT(std::fabs(utm_xy.y - 4141295.255870659), 1e-5);
+  EXPECT_TRUE(FrameTransform::LatlonToUtmXY(lon_rad, lat_rad, &utm_xy));
+  EXPECT_LT(std::fabs(utm_xy.x - 588278.9834174265), 1e-5);
+  EXPECT_LT(std::fabs(utm_xy.y - 4141295.255870659), 1e-5);
 }
 
-TEST_F(FrameTransformTestSuite, UtmXYToLatlonTest) {
+TEST(FrameTransformTestSuite, UtmXYToLatlonTest) {
   double x = 588278.9834174265;
   double y = 4141295.255870659;
   int zone = 10;
   bool southhemi = false;
   WGS84Corr latlon;
-  ASSERT_TRUE(FrameTransform::UtmXYToLatlon(x, y, zone, southhemi, &latlon));
-  ASSERT_LT(std::fabs(latlon.log + 2.129343746458001), 1e-5);
-  ASSERT_LT(std::fabs(latlon.lat - 0.6530018835651807), 1e-5);
+  EXPECT_TRUE(FrameTransform::UtmXYToLatlon(x, y, zone, southhemi, &latlon));
+  EXPECT_LT(std::fabs(latlon.log + 2.129343746458001), 1e-5);
+  EXPECT_LT(std::fabs(latlon.lat - 0.6530018835651807), 1e-5);
 }
 
 }  // namespace msf

modules/localization/msf/common/util/rect2d_test.cc

@@ -22,38 +22,29 @@ namespace apollo {
 namespace localization {
 namespace msf {
 
-class Rect2DTestSuite : public ::testing::Test {
- protected:
-  Rect2DTestSuite() {}
-  virtual ~Rect2DTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-/**@brief Rect2DTest. */
-TEST_F(Rect2DTestSuite, Rect2DTest) {
+TEST(Rect2DTestSuite, Rect2DTest) {
   Rect2D<double> rect_a(0.5, 0.5, 1.0, 1.0);
   double min_x = rect_a.GetMinX();
   double min_y = rect_a.GetMinY();
   double max_x = rect_a.GetMaxX();
   double max_y = rect_a.GetMaxY();
-  ASSERT_LT(std::abs(min_x - 0.5), 1e-5);
-  ASSERT_LT(std::abs(min_y - 0.5), 1e-5);
-  ASSERT_LT(std::abs(max_x - 1.0), 1e-5);
-  ASSERT_LT(std::abs(max_y - 1.0), 1e-5);
+  EXPECT_LT(std::abs(min_x - 0.5), 1e-5);
+  EXPECT_LT(std::abs(min_y - 0.5), 1e-5);
+  EXPECT_LT(std::abs(max_x - 1.0), 1e-5);
+  EXPECT_LT(std::abs(max_y - 1.0), 1e-5);
 
   Eigen::Matrix<double, 2, 1> lt_corner = rect_a.GetLeftTopCorner();
   Eigen::Matrix<double, 2, 1> rb_corner = rect_a.GetRightBottomCorner();
-  ASSERT_LT(std::abs(lt_corner(0) - 0.5), 1e-5);
-  ASSERT_LT(std::abs(lt_corner(1) - 0.5), 1e-5);
-  ASSERT_LT(std::abs(rb_corner(0) - 1.0), 1e-5);
-  ASSERT_LT(std::abs(rb_corner(1) - 1.0), 1e-5);
+  EXPECT_LT(std::abs(lt_corner(0) - 0.5), 1e-5);
+  EXPECT_LT(std::abs(lt_corner(1) - 0.5), 1e-5);
+  EXPECT_LT(std::abs(rb_corner(0) - 1.0), 1e-5);
+  EXPECT_LT(std::abs(rb_corner(1) - 1.0), 1e-5);
 
   Rect2D<double> rect_b(rect_a);
-  ASSERT_LT(std::abs(rect_b.GetMinX() - 0.5), 1e-5);
+  EXPECT_LT(std::abs(rect_b.GetMinX() - 0.5), 1e-5);
 
   Rect2D<double> rect_c = rect_b;
-  ASSERT_LT(std::abs(rect_c.GetMinX() - 0.5), 1e-5);
+  EXPECT_LT(std::abs(rect_c.GetMinX() - 0.5), 1e-5);
 }
 
 }  // namespace msf

modules/localization/msf/common/util/system_utility_test.cc

@@ -23,54 +23,45 @@ namespace apollo {
 namespace localization {
 namespace msf {
 
-class SystemUtilityTestSuite : public ::testing::Test {
- protected:
-  SystemUtilityTestSuite() {}
-  virtual ~SystemUtilityTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-/**@brief Rect2DTest. */
-TEST_F(SystemUtilityTestSuite, SystemTest) {
+TEST(SystemUtilityTestSuite, SystemTest) {
   bool flag = system::IsExists(
       "/apollo/modules/localization/msf/common/test_data/test_folder/"
       "file1.txt");
-  ASSERT_TRUE(flag);
+  EXPECT_TRUE(flag);
   flag = system::IsExists(
       "/apollo/modules/localization/msf/common/test_data/file4.txt");
-  ASSERT_FALSE(flag);
+  EXPECT_FALSE(flag);
   flag =
       system::IsDirectory("/apollo/modules/localization/msf/common/test_data");
-  ASSERT_TRUE(flag);
+  EXPECT_TRUE(flag);
   flag = system::IsDirectory("/apollo/modules/localization/msf/common/test");
-  ASSERT_FALSE(flag);
+  EXPECT_FALSE(flag);
   flag = system::CreateDirectory(
       "/apollo/modules/localization/msf/common/test_data/tem");
-  ASSERT_TRUE(flag);
+  EXPECT_TRUE(flag);
   unsigned int size;
   flag = system::GetFileSize(
       "/apollo/modules/localization/msf/common/test_data/test_folder/file1.txt",
       &size);
-  ASSERT_TRUE(flag);
-  ASSERT_EQ(size, 1);
+  EXPECT_TRUE(flag);
+  EXPECT_EQ(size, 1);
   flag = system::CopyFile(
       "/apollo/modules/localization/msf/common/test_data/test_folder/file1.txt",
       "/apollo/modules/localization/msf/common/test_data/tem/file1.txt");
-  ASSERT_TRUE(flag);
+  EXPECT_TRUE(flag);
   std::vector<std::string> ret1;
   system::GetFilesInFolderRecursive(
       "/apollo/modules/localization/msf/common/test_data", ".txt", &ret1);
-  ASSERT_EQ(ret1.size(), 4);
+  EXPECT_EQ(ret1.size(), 4);
   std::vector<std::string> ret2;
   system::GetFilesInFolder(
       "/apollo/modules/localization/msf/common/test_data/test_folder", ".txt",
       &ret2);
-  ASSERT_EQ(ret2.size(), 3);
+  EXPECT_EQ(ret2.size(), 3);
   std::vector<std::string> ret3;
   system::GetFoldersInFolder(
       "/apollo/modules/localization/msf/common/test_data/", &ret3);
-  ASSERT_EQ(ret3.size(), 2);
+  EXPECT_EQ(ret3.size(), 2);
   boost::filesystem::remove_all(
       "/apollo/modules/localization/msf/common/test_data/tem");
 }

modules/localization/msf/local_map/base_map/map_node_index_test.cc

@@ -22,21 +22,13 @@ namespace apollo {
 namespace localization {
 namespace msf {
 
-class BaseMapNodeIndexTestSuite : public ::testing::Test {
- protected:
-  BaseMapNodeIndexTestSuite() {}
-  virtual ~BaseMapNodeIndexTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
 /**@brief Test the get method. */
-TEST_F(BaseMapNodeIndexTestSuite, GetMethodTest) {
+TEST(BaseMapNodeIndexTestSuite, GetMethodTest) {
   MapNodeIndex node_index;
-  ASSERT_EQ(node_index.resolution_id_, 0);
-  ASSERT_EQ(node_index.zone_id_, 50);
-  ASSERT_EQ(node_index.m_, 0);
-  ASSERT_EQ(node_index.n_, 0);
+  EXPECT_EQ(node_index.resolution_id_, 0);
+  EXPECT_EQ(node_index.zone_id_, 50);
+  EXPECT_EQ(node_index.m_, 0);
+  EXPECT_EQ(node_index.n_, 0);
 
   BaseMapConfig option;
   option.map_resolutions_.push_back(0.125);
@@ -49,32 +41,29 @@ TEST_F(BaseMapNodeIndexTestSuite, GetMethodTest) {
   MapNodeIndex node_index2 =
       MapNodeIndex::GetMapNodeIndex(option, coordinate2d, 0, 50);
 
-  ASSERT_TRUE(node_index1 == node_index2);
+  EXPECT_TRUE(node_index1 == node_index2);
 }
 
 /**@brief Test the operators. */
-TEST_F(BaseMapNodeIndexTestSuite, OperatorTest) {
+TEST(BaseMapNodeIndexTestSuite, OperatorTest) {
   MapNodeIndex node_index1;
-  ASSERT_EQ(node_index1.resolution_id_, 0);
-  ASSERT_EQ(node_index1.zone_id_, 50);
-  ASSERT_EQ(node_index1.m_, 0);
-  ASSERT_EQ(node_index1.n_, 0);
+  EXPECT_EQ(node_index1.resolution_id_, 0);
+  EXPECT_EQ(node_index1.zone_id_, 50);
+  EXPECT_EQ(node_index1.m_, 0);
+  EXPECT_EQ(node_index1.n_, 0);
 
   MapNodeIndex node_index2;
   node_index2.n_ = 1;
 
   bool res = node_index1 < node_index2;
-  ASSERT_TRUE(res);
+  EXPECT_TRUE(res);
 
   res = node_index1 != node_index2;
-  ASSERT_TRUE(res);
+  EXPECT_TRUE(res);
 
   node_index2.n_ = 0;
   res = node_index1 == node_index2;
-  ASSERT_TRUE(res);
-
-  std::cout << node_index2 << std::endl;
-  ASSERT_TRUE(true);
+  EXPECT_TRUE(res);
 }
 
 }  // namespace msf

modules/localization/msf/local_map/lossless_map/lossless_map_config_test.cc

@@ -25,11 +25,11 @@ namespace msf {
 /**@brief Test load and set methods in LosslessMapConfig. */
 TEST(LosslessMapConfigTestSuite, LoadSetTest) {
   BaseMapConfig config("lossless_map");
-  ASSERT_TRUE(
+  EXPECT_TRUE(
       config.Load("/apollo/modules/localization/msf/local_map/"
                   "test_data/lossless_single_map/config.xml"));
   config.SetMultiResolutions();
-  ASSERT_EQ(config.map_resolutions_.size(), 10);
+  EXPECT_EQ(config.map_resolutions_.size(), 10);
   EXPECT_DOUBLE_EQ(config.map_resolutions_[0], 0.03125);
 
   config.ResizeMapRange();
@@ -39,7 +39,7 @@ TEST(LosslessMapConfigTestSuite, LoadSetTest) {
   EXPECT_DOUBLE_EQ(config.map_range_.GetMaxY(), 630.0 * 16.0 * 1024);
 
   config.SetSingleResolutions();
-  ASSERT_EQ(config.map_resolutions_.size(), 1);
+  EXPECT_EQ(config.map_resolutions_.size(), 1);
   EXPECT_DOUBLE_EQ(config.map_resolutions_[0], 0.125);
 
   BaseMapConfig config2;
@@ -51,7 +51,7 @@ TEST(LosslessMapConfigTestSuite, LoadSetTest) {
 /**@brief Test save method. */
 TEST(LosslessMapConfigTestSuite, SaveTest) {
   BaseMapConfig config("lossless_map");
-  ASSERT_TRUE(
+  EXPECT_TRUE(
       config.Load("/apollo/modules/localization/msf/local_map/"
                   "test_data/lossless_single_map/config.xml"));
   EXPECT_TRUE(config.Save("/tmp/temp_output_file.xml"));

modules/localization/msf/local_map/lossless_map/map_pool_test.cc

@@ -48,11 +48,11 @@ TEST_F(BaseMapPoolTestSuite, MapNodePoolTest) {
   pool.FreeMapNodeTask(node3);
 
   unsigned int pool_size = pool.GetPoolSize();
-  ASSERT_EQ(pool_size, 3);
+  EXPECT_EQ(pool_size, 3);
 
   pool.Release();
   pool_size = pool.GetPoolSize();
-  ASSERT_EQ(pool_size, 0);
+  EXPECT_EQ(pool_size, 0);
 }
 
 }  // namespace msf

modules/localization/msf/local_map/lossy_map/lossy_map_config_2d_test.cc

@@ -25,11 +25,11 @@ namespace msf {
 /**@brief Test load and set methods in LossyMapConfig2D. */
 TEST(LossyMapConfig2DTestSuite, LoadSetTest) {
   BaseMapConfig config("lossy_map");
-  ASSERT_TRUE(
+  EXPECT_TRUE(
       config.Load("/apollo/modules/localization/msf/local_map/"
                   "test_data/lossy_single_map/config.xml"));
   config.SetMultiResolutions();
-  ASSERT_EQ(config.map_resolutions_.size(), 10);
+  EXPECT_EQ(config.map_resolutions_.size(), 10);
   EXPECT_DOUBLE_EQ(config.map_resolutions_[0], 0.03125);
 
   config.ResizeMapRange();
@@ -39,7 +39,7 @@ TEST(LossyMapConfig2DTestSuite, LoadSetTest) {
   EXPECT_DOUBLE_EQ(config.map_range_.GetMaxY(), 630.0 * 16.0 * 1024);
 
   config.SetSingleResolutions();
-  ASSERT_EQ(config.map_resolutions_.size(), 1);
+  EXPECT_EQ(config.map_resolutions_.size(), 1);
   EXPECT_DOUBLE_EQ(config.map_resolutions_[0], 0.125);
 
   BaseMapConfig config2;
@@ -51,7 +51,7 @@ TEST(LossyMapConfig2DTestSuite, LoadSetTest) {
 /**@brief Test save method. */
 TEST(LossyMapConfig2DTestSuite, SaveTest) {
   BaseMapConfig config("lossy_map");
-  ASSERT_TRUE(
+  EXPECT_TRUE(
       config.Load("/apollo/modules/localization/msf/local_map/"
                   "test_data/lossy_single_map/config.xml"));
   EXPECT_TRUE(config.Save("/tmp/temp_output_file.xml"));

modules/localization/ndt/localization_pose_buffer_test.cc

@@ -44,8 +44,8 @@ TEST_F(NDTLocalizationTest, UpdateLidarPose) {
   pose_buffer_ptr_->UpdateLidarPose(time_now, lidar_pose, odometry_pose);
   time_now = apollo::common::time::Clock::NowInSeconds();
   pose_buffer_ptr_->UpdateLidarPose(time_now, lidar_pose, odometry_pose);
-  ASSERT_EQ(pose_buffer_ptr_->GetUsedBufferSize(), 2);
-  ASSERT_EQ(pose_buffer_ptr_->GetHeadIndex(), 0);
+  EXPECT_EQ(pose_buffer_ptr_->GetUsedBufferSize(), 2);
+  EXPECT_EQ(pose_buffer_ptr_->GetHeadIndex(), 0);
 }
 
 TEST_F(NDTLocalizationTest, UpdateOdometryPose) {
@@ -62,7 +62,7 @@ TEST_F(NDTLocalizationTest, UpdateOdometryPose) {
   time_now = apollo::common::time::Clock::NowInSeconds();
   Eigen::Affine3d pose =
       pose_buffer_ptr_->UpdateOdometryPose(time_now, odometry_pose);
-  ASSERT_LE(std::abs(pose.translation()[0] - 1.0), 1e-5);
+  EXPECT_LE(std::abs(pose.translation()[0] - 1.0), 1e-5);
 }
 
 }  // namespace ndt

modules/localization/ndt/ndt_localization_test.cc

@@ -41,8 +41,8 @@ TEST_F(NDTLocalizationTest, Init) {
   FLAGS_local_utm_zone_id = 10;
   FLAGS_online_resolution = 0.25;
   ndt_localization_ptr_->Init();
-  ASSERT_EQ(ndt_localization_ptr_->GetZoneId(), 10);
-  ASSERT_LE(std::abs(ndt_localization_ptr_->GetOnlineResolution() - 0.25),
+  EXPECT_EQ(ndt_localization_ptr_->GetZoneId(), 10);
+  EXPECT_LE(std::abs(ndt_localization_ptr_->GetOnlineResolution() - 0.25),
             0.01);
 }
 

modules/localization/ndt/ndt_locator/lidar_locator_ndt_test.cc

@@ -31,15 +31,7 @@ namespace apollo {
 namespace localization {
 namespace ndt {
 
-class LidarLocatorNdtTestSuite : public ::testing::Test {
- protected:
-  LidarLocatorNdtTestSuite() {}
-  virtual ~LidarLocatorNdtTestSuite() {}
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-TEST_F(LidarLocatorNdtTestSuite, LidarLocatorNdt) {
+TEST(LidarLocatorNdtTestSuite, LidarLocatorNdt) {
   const std::string map_folder =
       "/apollo/modules/localization/ndt/test_data/ndt_map";
   const std::string poses_file =
@@ -90,14 +82,14 @@ TEST_F(LidarLocatorNdtTestSuite, LidarLocatorNdt) {
       lidar_frame.intensities.push_back(intensities[i]);
     }
     int ret = locator.Update(0, poses[frame_idx], lidar_frame);
-    ASSERT_LE(std::fabs(ret - 0), 1e-6);
+    EXPECT_LE(std::fabs(ret - 0), 1e-6);
 
     location = locator.GetPose();
   }
-  ASSERT_LE(std::fabs(location.translation()[0] - 588349.337377345), 0.1);
-  ASSERT_LE(std::fabs(location.translation()[1] - 4141239.53859664), 0.1);
-  ASSERT_LE(std::fabs(location.translation()[2] + 30.0964486966756), 0.1);
-  ASSERT_EQ(frame_idx, 2);
+  EXPECT_LE(std::fabs(location.translation()[0] - 588349.337377345), 0.1);
+  EXPECT_LE(std::fabs(location.translation()[1] - 4141239.53859664), 0.1);
+  EXPECT_LE(std::fabs(location.translation()[2] + 30.0964486966756), 0.1);
+  EXPECT_EQ(frame_idx, 2);
 }
 
 }  // namespace ndt