Add types & test

test/CMakeLists.txt

@@ -0,0 +1,88 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(mynteye_test VERSION 2.0.0 LANGUAGES C CXX)
+
+get_filename_component(PRO_DIR ${PROJECT_SOURCE_DIR} DIRECTORY)
+
+# flags
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
+
+include(${PRO_DIR}/cmake/DetectCXX11.cmake)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+
+string(STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
+string(STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
+message(STATUS "C_FLAGS: ${CMAKE_C_FLAGS}")
+message(STATUS "CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
+
+# packages
+
+LIST(APPEND CMAKE_PREFIX_PATH ${PRO_DIR}/third_party/glog/_build)
+find_package(glog REQUIRED)
+message(STATUS "Found glog: ${glog_VERSION}")
+
+LIST(APPEND CMAKE_PREFIX_PATH ${PRO_DIR}/_install/lib/cmake)
+find_package(mynteye REQUIRED)
+message(STATUS "Found mynteye: ${mynteye_VERSION}")
+
+LIST(APPEND CMAKE_MODULE_PATH ${PRO_DIR}/cmake)
+
+## gtest
+
+set(TEST_DIR ${PROJECT_SOURCE_DIR})
+set(GMOCK_DIR ${TEST_DIR}/gtest/googlemock)
+set(GTEST_DIR ${TEST_DIR}/gtest/googletest)
+
+set(GMOCK_LIB_DIR ${TEST_DIR}/gtest/_build/googlemock)
+set(GTEST_LIB_DIR ${GMOCK_LIB_DIR}/gtest)
+if(OS_WIN AND NOT MINGW)
+  set(GTEST_LIB_DIR ${GTEST_LIB_DIR}/Release)
+endif()
+
+set(GTEST_LIBS
+  ${GTEST_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}
+  #${GTEST_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main${CMAKE_STATIC_LIBRARY_SUFFIX}
+)
+message(STATUS "Found gtest libs: ${GTEST_LIBS}")
+
+# targets
+
+include(${PRO_DIR}/cmake/Common.cmake)
+
+set(OUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/_output")
+
+set_outdir(
+  "${OUT_DIR}/lib"
+  "${OUT_DIR}/lib"
+  "${OUT_DIR}/bin"
+)
+
+include_directories(
+  ${GTEST_DIR}/include
+)
+
+file(GLOB TEST_PUBLIC_SRC "public/*.cc")
+
+add_executable(${PROJECT_NAME}
+  gtest_main.cc
+  ${TEST_PUBLIC_SRC}
+)
+target_link_libraries(${PROJECT_NAME} ${GTEST_LIBS} mynteye)
+
+if(OS_WIN)
+  target_compile_definitions(${PROJECT_NAME}
+    PUBLIC GLOG_NO_ABBREVIATED_SEVERITIES
+  )
+endif()
+
+#find_package(Threads REQUIRED)
+#if(THREADS_HAVE_PTHREAD_ARG)
+#  target_compile_options(PUBLIC ${PROJECT_NAME} "-pthread")
+#endif()
+#if(CMAKE_THREAD_LIBS_INIT)
+#  target_link_libraries(${PROJECT_NAME} "${CMAKE_THREAD_LIBS_INIT}")
+#endif()

test/gtest_main.cc

@@ -0,0 +1,34 @@
+#include "gtest/gtest.h"
+#include <stdio.h>
+#include "glog/logging.h"
+
+struct glog_init {
+  glog_init(int /*argc*/, char *argv[]) {
+    // FLAGS_logtostderr = true;
+    FLAGS_alsologtostderr = true;
+    FLAGS_colorlogtostderr = true;
+
+    FLAGS_log_dir = ".";
+    FLAGS_max_log_size = 1024;
+    FLAGS_stop_logging_if_full_disk = true;
+
+    // FLAGS_v = 2;
+
+    google::InitGoogleLogging(argv[0]);
+
+    VLOG(2) << __func__;
+  }
+
+  ~glog_init() {
+    VLOG(2) << __func__;
+    google::ShutdownGoogleLogging();
+  }
+};
+
+GTEST_API_ int main(int argc, char **argv) {
+  glog_init _(argc, argv);
+
+  printf("Running main() from gtest_main.cc\n");
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

test/public/types_test.cc

@@ -0,0 +1,57 @@
+#include "gtest/gtest.h"
+
+#include "mynteye/types.h"
+
+MYNTEYE_USE_NAMESPACE
+
+TEST(Stream, VerifyToString) {
+  EXPECT_STREQ("Stream::LEFT", to_string(Stream::LEFT));
+  EXPECT_STREQ("Stream::RIGHT", to_string(Stream::RIGHT));
+  EXPECT_STREQ("Stream::LEFT_RECTIFIED", to_string(Stream::LEFT_RECTIFIED));
+  EXPECT_STREQ("Stream::RIGHT_RECTIFIED", to_string(Stream::RIGHT_RECTIFIED));
+  EXPECT_STREQ("Stream::DISPARITY", to_string(Stream::DISPARITY));
+  EXPECT_STREQ(
+      "Stream::DISPARITY_NORMALIZED", to_string(Stream::DISPARITY_NORMALIZED));
+  EXPECT_STREQ("Stream::DEPTH", to_string(Stream::DEPTH));
+  EXPECT_STREQ("Stream::POINTS", to_string(Stream::POINTS));
+}
+
+TEST(Capabilities, VerifyToString) {
+  EXPECT_STREQ("Capabilities::STEREO", to_string(Capabilities::STEREO));
+  EXPECT_STREQ("Capabilities::COLOR", to_string(Capabilities::COLOR));
+  EXPECT_STREQ("Capabilities::DEPTH", to_string(Capabilities::DEPTH));
+  EXPECT_STREQ("Capabilities::POINTS", to_string(Capabilities::POINTS));
+  EXPECT_STREQ("Capabilities::FISHEYE", to_string(Capabilities::FISHEYE));
+  EXPECT_STREQ("Capabilities::IMU", to_string(Capabilities::IMU));
+}
+
+TEST(Info, VerifyToString) {
+  EXPECT_STREQ("Info::DEVICE_NAME", to_string(Info::DEVICE_NAME));
+  EXPECT_STREQ("Info::SERIAL_NUMBER", to_string(Info::SERIAL_NUMBER));
+  EXPECT_STREQ("Info::FIRMWARE_VERSION", to_string(Info::FIRMWARE_VERSION));
+  EXPECT_STREQ("Info::HARDWARE_VERSION", to_string(Info::HARDWARE_VERSION));
+  EXPECT_STREQ("Info::SPEC_VERSION", to_string(Info::SPEC_VERSION));
+  EXPECT_STREQ("Info::LENS_TYPE", to_string(Info::LENS_TYPE));
+  EXPECT_STREQ("Info::IMU_TYPE", to_string(Info::IMU_TYPE));
+  EXPECT_STREQ("Info::NOMINAL_BASELINE", to_string(Info::NOMINAL_BASELINE));
+}
+
+TEST(Option, VerifyToString) {
+  EXPECT_STREQ("Option::GAIN", to_string(Option::GAIN));
+  EXPECT_STREQ("Option::BRIGHTNESS", to_string(Option::BRIGHTNESS));
+  EXPECT_STREQ("Option::CONTRAST", to_string(Option::CONTRAST));
+  EXPECT_STREQ("Option::FRAME_RATE", to_string(Option::FRAME_RATE));
+  EXPECT_STREQ("Option::IMU_FREQUENCY", to_string(Option::IMU_FREQUENCY));
+  EXPECT_STREQ("Option::EXPOSURE_MODE", to_string(Option::EXPOSURE_MODE));
+  EXPECT_STREQ("Option::MAX_GAIN", to_string(Option::MAX_GAIN));
+  EXPECT_STREQ(
+      "Option::MAX_EXPOSURE_TIME", to_string(Option::MAX_EXPOSURE_TIME));
+  EXPECT_STREQ(
+      "Option::DESIRED_BRIGHTNESS", to_string(Option::DESIRED_BRIGHTNESS));
+  EXPECT_STREQ("Option::IR_CONTROL", to_string(Option::IR_CONTROL));
+  EXPECT_STREQ("Option::HDR_MODE", to_string(Option::HDR_MODE));
+  EXPECT_STREQ(
+      "Option::ZERO_DRIFT_CALIBRATION",
+      to_string(Option::ZERO_DRIFT_CALIBRATION));
+  EXPECT_STREQ("Option::ERASE_CHIP", to_string(Option::ERASE_CHIP));
+}