🎨 decouple funtionality from the Utility header into seperate files

Author: kris-jusiak

CMakeLists.txt

@@ -63,16 +63,26 @@ else()
     endfunction()
 endif()
 
+test(example/GMock)
+test(example/GTest)
+test(example/GScenario)
+
+include_directories(test)
 test(test/GMake)
 test(test/GMock)
 test(test/GScenario)
+test(test/Features/Calc/Steps/CalcSteps)
+test(test/Features/Table/Steps/TableSteps)
+test(test/Features/Tags/Steps/TagsSteps)
 test(test/GTest)
 test(test/GTest-Lite)
+test(test/Detail/FileUtils)
 test(test/Detail/Preprocessor)
+test(test/Detail/ProgUtils)
+test(test/Detail/RegexUtils)
+test(test/Detail/StringUtils)
 test(test/Detail/TypeTraits)
 test(test/Detail/Utility)
-test(example/GMock)
-test(example/GTest)
 
 include_directories(benchmark)
 test(benchmark/GUnit/test)

example/GScenario.cpp

@@ -0,0 +1,34 @@
+//
+// Copyright (c) 2016-2017 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#include <vector>
+#include <string>
+#include <iostream>
+#include "GUnit/GScenario.h"
+#include "GUnit/GTest.h"
+
+STEPS("Example*") = [](auto steps) {
+  std::vector<std::string> given_steps{};
+
+  steps.Given("I have step {name}") = [&](const std::string& step) {
+    given_steps.emplace_back(step);
+  };
+
+  steps.When("I run the scenario") = []{
+    std::cout << "Running...\n";
+  };
+
+  steps.Then("The following steps should be shown on the screen", "steps") = [&](const testing::Table& table) {
+    ASSERT_EQ(given_steps.size(), table.size());
+    auto i = 0;
+    for (auto row : table) {
+      EXPECT_EQ(row["step"], given_steps[i++]);
+    }
+  };
+
+  return steps;
+};

example/GScenario.feature

@@ -0,0 +1,13 @@
+Feature: Example
+  In order to show off GScenario
+  As a new user
+  I want to be told how to use it
+
+  Scenario: Showing off
+    Given I have step a
+      And I have step b
+     When I run the scenario
+     Then The following steps should be shown on the screen
+      | step |
+      | a    |
+      | b    |

include/GUnit/Detail/FileUtils.h

@@ -0,0 +1,30 @@
+//
+// Copyright (c) 2016-2017 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+
+#include <string>
+#include <fstream>
+#include <stdexcept>
+
+namespace testing {
+inline namespace v1 {
+namespace detail {
+
+inline auto basename(const std::string &path) { return path.substr(path.find_last_of("/\\") + 1); }
+
+inline std::wstring read_file(const std::string &feature) {
+  std::ifstream file{feature};
+  if (!file.good()) {
+    throw std::runtime_error("File \"" + feature + "\" not found!");
+  }
+  return {(std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()};
+}
+
+}  // detail
+}  // v1
+}  // testing

include/GUnit/Detail/ProgUtils.h

@@ -0,0 +1,104 @@
+//
+// Copyright (c) 2016-2017 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+
+#include <string>
+#include <memory>
+#include <cxxabi.h>
+#include <execinfo.h>
+#include "gtest/gtest.h"
+
+#if defined(__APPLE__)
+#include <libproc.h>
+#elif defined(__linux__)
+extern const char *__progname_full;
+#endif
+
+#if !defined(GUNIT_SHOW_STACK_SIZE)
+#define GUNIT_SHOW_STACK_SIZE 1
+#endif
+
+namespace testing {
+inline namespace v1 {
+namespace detail {
+
+inline std::string demangle(const std::string &mangled) {
+  const auto demangled = abi::__cxa_demangle(mangled.c_str(), 0, 0, 0);
+  if (demangled) {
+    std::shared_ptr<char> free{demangled, std::free};
+    return demangled;
+  }
+  return {};
+}
+
+inline auto &progname() {
+#if defined(__linux__)
+  static auto self = __progname_full;
+#elif defined(__APPLE__)
+  static char self[PROC_PIDPATHINFO_MAXSIZE] = {};
+  proc_pidpath(getpid(), self, sizeof(self));
+#endif
+  return self;
+}
+
+inline std::string call_stack(const std::string &newline, int stack_begin = 1, int stack_size = GUNIT_SHOW_STACK_SIZE) {
+  static constexpr auto MAX_CALL_STACK_SIZE = 64;
+  void *bt[MAX_CALL_STACK_SIZE];
+  const auto frames = backtrace(bt, sizeof(bt) / sizeof(bt[0]));
+  const auto symbols = backtrace_symbols(bt, frames);
+  std::shared_ptr<char *> free{symbols, std::free};
+  std::stringstream result;
+  stack_size += stack_begin;
+
+  for (auto i = stack_begin; i < (frames > stack_size ? stack_size : frames); ++i) {
+    const auto symbol = std::string{symbols[i]};
+    const auto name_begin = symbol.find("(");
+    const auto name_end = symbol.find("+");
+    const auto address_begin = symbol.find("[");
+    const auto address_end = symbol.find("]");
+
+    if (i > stack_begin) {
+      result << newline;
+    }
+    if (name_begin != std::string::npos && name_end != std::string::npos && address_begin != std::string::npos &&
+        address_end != std::string::npos) {
+      result << demangle(symbol.substr(name_begin + 1, name_end - name_begin - 1)) << " "
+             << symbol.substr(address_begin, address_end - address_begin + 1);
+    } else {
+      result << symbol;
+    }
+  }
+  return result.str();
+}
+
+inline std::pair<std::string, int> addr2line(void *addr) {
+  std::stringstream cmd;
+  cmd << "addr2line -Cpe " << progname() << " " << addr;
+
+  std::string data;
+  auto fp = popen(cmd.str().c_str(), "r");
+  if (fp) {
+    char buf[64] = {};
+    while (fgets(buf, sizeof(buf), fp)) {
+      data += buf;
+    }
+  } else {
+    return {"", 0};
+  }
+  pclose(fp);
+
+  data.erase(std::remove(data.begin(), data.end(), '\n'), data.end());
+  const auto space = data.find(" ");
+  std::string res2 = data.substr(0, space);
+  const auto colon = res2.find(":");
+  return {res2.substr(0, colon), std::atoi(res2.substr(colon + 1).c_str())};
+}
+
+}  // detail
+}  // v1
+}  // testing

include/GUnit/Detail/RegexUtils.h

@@ -0,0 +1,131 @@
+//
+// Copyright (c) 2016-2017 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "GUnit/Detail/StringUtils.h"
+
+namespace testing {
+inline namespace v1 {
+namespace detail {
+
+template <class T>
+inline constexpr auto args_size(T str) {
+  auto args = 0;
+  for (auto i = 0u; i < str.size(); ++i) {
+    if (str[i] == '{') {
+      ++args;
+    }
+  }
+  return args;
+}
+
+template <class T>
+inline auto matches(T pattern, const std::string &str) {
+  std::vector<std::string> matches{};
+  auto pi = 0u, si = 0u;
+
+  const auto matcher = [&](char b, char e) {
+    const auto match = si;
+    while (str[si] && str[si] != b) ++si;
+    matches.emplace_back(str.substr(match, si - match));
+    while (pattern[pi] && pattern[pi] != e) ++pi;
+    pi++;
+  };
+
+  while (pi < pattern.size() && si < str.size()) {
+    if (pattern[pi] == '\'' && str[si] == '\'' && pattern[pi + 1] == '{') {
+      ++si;
+      matcher('\'', '}');
+    } else if (pattern[pi] == '{') {
+      matcher(' ', '}');
+    } else if (pattern[pi] != str[si]) {
+      return std::vector<std::string>{};
+    }
+    ++pi, ++si;
+  }
+
+  return matches;
+}
+
+template <class T>
+inline auto match(T pattern, const std::string &str) {
+  return not matches(pattern, str).empty() || std::string{pattern.c_str()} == str;
+}
+
+inline bool PatternMatchesString(const char* pattern, const char* str) {
+  switch (*pattern) {
+    case '\0':
+    case ':':  // Either ':' or '\0' marks the end of the pattern.
+      return *str == '\0';
+    case '?':  // Matches any single character.
+      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
+    case '*':  // Matches any string (possibly empty) of characters.
+      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || PatternMatchesString(pattern + 1, str);
+    default:  // Non-special character.  Matches itself.
+      return *pattern == *str && PatternMatchesString(pattern + 1, str + 1);
+  }
+}
+
+inline bool MatchesFilter(const std::string& name, const char* filter) {
+  const char* cur_pattern = filter;
+  for (;;) {
+    if (PatternMatchesString(cur_pattern, name.c_str())) {
+      return true;
+    }
+
+    // Finds the next pattern in the filter.
+    cur_pattern = strchr(cur_pattern, ':');
+
+    // Returns if no more pattern can be found.
+    if (cur_pattern == nullptr) {
+      return false;
+    }
+
+    // Skips the pattern separater (the ':' character).
+    cur_pattern++;
+  }
+}
+
+inline bool FilterMatchesShould(const std::string& name, const std::string& should) {
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = should.c_str();
+  const char* const dash = strchr(p, '-');
+  std::string positive;
+  std::string negative;
+  if (dash == nullptr) {
+    positive = should.c_str();  // Whole string is a positive filter
+    negative = "";
+  } else {
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = "*";
+    }
+  }
+
+  return MatchesFilter(name, positive.c_str()) && !MatchesFilter(name, negative.c_str());
+}
+
+}  // detail
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
+#endif
+
+template <class T, T... Chrs>
+constexpr auto operator""_step() {
+  return detail::string<Chrs...>{};
+}
+
+}  // v1
+}  // testing