[Feature] Verify toolchain (#169)

Author: coder137

buildcc/lib/args/test/test_register.cpp

@@ -2,6 +2,8 @@
 
 #include "expect_command.h"
 
+#include "mock_command_copier.h"
+
 // NOTE, Make sure all these includes are AFTER the system and header includes
 #include "CppUTest/CommandLineTestRunner.h"
 #include "CppUTest/MemoryLeakDetectorNewMacros.h"
@@ -531,7 +533,9 @@ TEST(RegisterTestGroup, Register_Test) {
         target);
     reg.Test(stateSuccess, "{executable}", target);
 
-    buildcc::m::CommandExpect_Execute(1, true);
+    std::vector<std::string> stdout_data;
+    std::vector<std::string> stderr_data;
+    buildcc::m::CommandExpect_Execute(1, true, &stdout_data, &stderr_data);
     reg.RunTest();
   }
 
@@ -601,7 +605,8 @@ TEST(RegisterTestGroup, Register_TestWithOutput) {
             {}, {},
             buildcc::TestOutput(buildcc::TestOutput::Type::TestPrintOnStderr)));
 
-    buildcc::m::CommandExpect_Execute(1, true);
+    std::vector<std::string> stderr_data;
+    buildcc::m::CommandExpect_Execute(1, true, nullptr, &stderr_data);
     reg.RunTest();
   }
 
@@ -618,7 +623,8 @@ TEST(RegisterTestGroup, Register_TestWithOutput) {
             {}, {},
             buildcc::TestOutput(buildcc::TestOutput::Type::TestPrintOnStdout)));
 
-    buildcc::m::CommandExpect_Execute(1, true);
+    std::vector<std::string> stdout_data;
+    buildcc::m::CommandExpect_Execute(1, true, &stdout_data, nullptr);
     reg.RunTest();
   }
 
@@ -635,7 +641,9 @@ TEST(RegisterTestGroup, Register_TestWithOutput) {
                  buildcc::TestOutput(
                      buildcc::TestOutput::Type::TestPrintOnStderrAndStdout)));
 
-    buildcc::m::CommandExpect_Execute(1, true);
+    std::vector<std::string> stdout_data;
+    std::vector<std::string> stderr_data;
+    buildcc::m::CommandExpect_Execute(1, true, &stdout_data, &stderr_data);
     reg.RunTest();
   }
 
@@ -676,5 +684,7 @@ TEST(RegisterTestGroup, Register_TestWithOutput) {
 
 int main(int ac, char **av) {
   MemoryLeakWarningPlugin::turnOffNewDeleteOverloads();
+  buildcc::m::VectorStringCopier copier;
+  mock().installCopier(TEST_VECTOR_STRING_TYPE, copier);
   return CommandLineTestRunner::RunAllTests(ac, av);
 }

buildcc/lib/command/CMakeLists.txt

@@ -57,15 +57,12 @@ if(${BUILDCC_BUILD_AS_INTERFACE})
     )
     target_compile_options(command PRIVATE ${BUILD_COMPILE_FLAGS})
     target_link_options(command PRIVATE ${BUILD_LINK_FLAGS})
+endif()
 
-
-    # Command install
-    if (${BUILDCC_INSTALL})
+if (${BUILDCC_INSTALL})
+    if(${BUILDCC_BUILD_AS_INTERFACE})
         install(TARGETS command DESTINATION lib EXPORT commandConfig)
         install(EXPORT commandConfig DESTINATION "${BUILDCC_INSTALL_LIB_PREFIX}/command")
     endif()
-endif()
-
-if (${BUILDCC_INSTALL})
     install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION "${BUILDCC_INSTALL_HEADER_PREFIX}")
 endif()

buildcc/lib/command/mock/execute.cpp

@@ -1,10 +1,14 @@
 #include "command/command.h"
 
+#include "expect_command.h"
+
 #include "CppUTestExt/MockSupport.h"
 
 namespace buildcc {
 
 static constexpr const char *const EXECUTE_FUNCTION = "execute";
+static constexpr const char *const STDOUT_DATA_STRING = "stdout_data";
+static constexpr const char *const STDERR_DATA_STRING = "stderr_data";
 
 // command
 bool Command::Execute(const std::string &command,
@@ -13,15 +17,33 @@ bool Command::Execute(const std::string &command,
                       std::vector<std::string> *stderr_data) {
   (void)command;
   (void)working_directory;
-  (void)stdout_data;
-  (void)stderr_data;
-  return mock().actualCall(EXECUTE_FUNCTION).returnBoolValue();
+  auto &actualcall = mock().actualCall(EXECUTE_FUNCTION);
+  if (stdout_data != nullptr) {
+    actualcall.withOutputParameterOfType(
+        TEST_VECTOR_STRING_TYPE, STDOUT_DATA_STRING, (void *)stdout_data);
+  }
+  if (stderr_data != nullptr) {
+    actualcall.withOutputParameterOfType(
+        TEST_VECTOR_STRING_TYPE, STDERR_DATA_STRING, (void *)stderr_data);
+  }
+  return actualcall.returnBoolValue();
 }
 
 namespace m {
 
-void CommandExpect_Execute(unsigned int calls, bool expectation) {
-  mock().expectNCalls(calls, EXECUTE_FUNCTION).andReturnValue(expectation);
+void CommandExpect_Execute(unsigned int calls, bool expectation,
+                           std::vector<std::string> *stdout_data,
+                           std::vector<std::string> *stderr_data) {
+  auto &expectedcall = mock().expectNCalls(calls, EXECUTE_FUNCTION);
+  if (stdout_data != nullptr) {
+    expectedcall.withOutputParameterOfTypeReturning(
+        TEST_VECTOR_STRING_TYPE, STDOUT_DATA_STRING, (void *)stdout_data);
+  }
+  if (stderr_data != nullptr) {
+    expectedcall.withOutputParameterOfTypeReturning(
+        TEST_VECTOR_STRING_TYPE, STDERR_DATA_STRING, (void *)stderr_data);
+  }
+  expectedcall.andReturnValue(expectation);
 }
 
 } // namespace m

buildcc/lib/command/mock/expect_command.h

@@ -1,9 +1,16 @@
 #ifndef COMMAND_MOCK_EXPECT_COMMAND_H_
 #define COMMAND_MOCK_EXPECT_COMMAND_H_
 
+#include <string>
+#include <vector>
+
+constexpr const char *const TEST_VECTOR_STRING_TYPE = "vector_string";
+
 namespace buildcc::m {
 
-void CommandExpect_Execute(unsigned int calls, bool expectation);
+void CommandExpect_Execute(unsigned int calls, bool expectation,
+                           std::vector<std::string> *stdout_data = nullptr,
+                           std::vector<std::string> *stderr_data = nullptr);
 
 } // namespace buildcc::m
 

buildcc/lib/command/mock/mock_command_copier.h

@@ -0,0 +1,28 @@
+#ifndef COMMAND_MOCK_MOCK_COMMAND_COPIER_H_
+#define COMMAND_MOCK_MOCK_COMMAND_COPIER_H_
+
+#include <string>
+#include <vector>
+
+#include "CppUTestExt/MockSupport.h"
+
+namespace buildcc::m {
+
+class VectorStringCopier : public MockNamedValueCopier {
+public:
+  void copy(void *out, const void *in) override {
+    const std::vector<std::string> *vin = (const std::vector<std::string> *)in;
+    std::vector<std::string> *vout = (std::vector<std::string> *)out;
+
+    if (vout == nullptr || vin == nullptr) {
+      return;
+    }
+
+    vout->clear();
+    vout->insert(vout->end(), vin->begin(), vin->end());
+  }
+};
+
+} // namespace buildcc::m
+
+#endif

buildcc/lib/env/CMakeLists.txt

@@ -40,9 +40,11 @@ set(ENV_SRCS
     include/env/assert_throw.h
     include/env/env.h
     include/env/logging.h
+    include/env/util.h
+
     include/env/host_os.h
     include/env/host_compiler.h
-    include/env/util.h
+    include/env/host_os_util.h
 
     src/task_state.cpp
     include/env/task_state.h

buildcc/lib/env/include/env/host_os_util.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2021 Niket Naidu. 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.
+ */
+
+#ifndef ENV_HOST_OS_UTIL_H_
+#define ENV_HOST_OS_UTIL_H_
+
+#include <stdlib.h>
+
+#include "host_os.h"
+#include "logging.h"
+
+// https://askubuntu.com/questions/156392/what-is-the-equivalent-of-an-exe-file
+namespace buildcc::env {
+
+// Common
+constexpr const char *const kRaiseIssueStr =
+    "Unknown operating system, returning nullptr. Raise an "
+    "issue at http://github.com/coder137/build_in_cpp";
+
+// OS Path delimiters
+constexpr const char *const kWinEnvDelim = ";";
+constexpr const char *const kUnixEnvDelim = ":";
+
+/**
+ * @brief Get the OS environment variable delimiter
+ * ; for windows
+ * : for linux, unix and mac
+ *
+ * @return constexpr char const* for supported operating systems
+ * @return nullptr otherwise with a critical message to raise an issue
+ */
+inline constexpr char const *get_os_envvar_delim() {
+  if constexpr (is_win()) {
+    return kWinEnvDelim;
+  } else if constexpr (is_linux() || is_unix() || is_mac()) {
+    return kUnixEnvDelim;
+  }
+  log_critical(__FUNCTION__, kRaiseIssueStr);
+  return nullptr;
+}
+
+// OS executable extensions
+constexpr const char *const kWinExecutableExt = ".exe";
+constexpr const char *const kUnixExecutableExt = "";
+
+/**
+ * @brief Get the OS executable extension
+ * ".exe" for windows
+ * "" for linux, unix and mac
+ *
+ * @return constexpr const char*  for supported operating systems
+ * @return nullptr otherwise with a critical message to raise an issue
+ */
+inline constexpr const char *get_os_executable_extension() {
+  if constexpr (is_win()) {
+    return kWinExecutableExt;
+  } else if constexpr (is_linux() || is_unix() || is_mac()) {
+    return kUnixExecutableExt;
+  }
+
+  log_critical(__FUNCTION__, kRaiseIssueStr);
+  return nullptr;
+}
+
+} // namespace buildcc::env
+
+#endif

buildcc/lib/env/include/env/util.h

@@ -36,6 +36,7 @@
 #include <filesystem>
 #include <fstream>
 #include <sstream>
+#include <vector>
 
 namespace fs = std::filesystem;
 
@@ -106,6 +107,19 @@ inline bool load_file(const char *name, bool binary, std::string *buf) {
   return !ifs.bad();
 }
 
+// TODO, Shift this to a common apis folder or something
+// https://stackoverflow.com/questions/14265581/parse-split-a-string-in-c-using-string-delimiter-standard-c
+inline std::vector<std::string> split(const std::string &s, char delim) {
+  std::vector<std::string> result;
+  std::stringstream ss(s);
+  std::string item;
+  while (getline(ss, item, delim)) {
+    result.push_back(item);
+  }
+
+  return result;
+}
+
 } // namespace buildcc::env
 
 #endif

buildcc/lib/env/test/test_env_util.cpp

@@ -159,6 +159,28 @@ TEST(EnvUtilTestGroup, Util_LoadFile_CannotOpen) {
   CHECK_FALSE(load);
 }
 
+TEST(EnvUtilTestGroup, Util_Split) {
+  {
+    std::vector<std::string> paths = buildcc::env::split("", ':');
+    CHECK_EQUAL(paths.size(), 0);
+  }
+
+  {
+    std::vector<std::string> paths = buildcc::env::split("path1", ':');
+    CHECK_EQUAL(paths.size(), 1);
+    STRCMP_EQUAL(paths[0].c_str(), "path1");
+  }
+
+  {
+    std::vector<std::string> paths =
+        buildcc::env::split("path1:path2:path3", ':');
+    CHECK_EQUAL(paths.size(), 3);
+    STRCMP_EQUAL(paths[0].c_str(), "path1");
+    STRCMP_EQUAL(paths[1].c_str(), "path2");
+    STRCMP_EQUAL(paths[2].c_str(), "path3");
+  }
+}
+
 int main(int ac, char **av) {
   return CommandLineTestRunner::RunAllTests(ac, av);
 }

buildcc/lib/target/cmake/mock_target.cmake

@@ -23,9 +23,7 @@ target_link_libraries(mock_target PUBLIC
     flatbuffers_header_only
     Taskflow
 
-    mock_env
-    mock_command
-    toolchain
+    mock_toolchain
 
     CppUTest
     CppUTestExt