Tidy up parameterised test names

test/utils/utils.cpp

@@ -0,0 +1,130 @@
+#include "utils.h"
+
+#include <fstream>
+
+namespace fs = std::filesystem;
+
+bool ends_with(const std::string& str, const std::string& suffix) {
+  return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+std::vector<std::string> split(const std::string& text, char sep) {
+  std::vector<std::string> tokens;
+  std::size_t start = 0, end = 0;
+  while ((end = text.find(sep, start)) != std::string::npos) {
+    tokens.push_back(text.substr(start, end - start));
+    start = end + 1;
+  }
+  tokens.push_back(text.substr(start));
+  return tokens;
+}
+
+void print_frame(const CAN_frame& frame) {
+  std::cout << "ID: " << std::hex << frame.ID << ", DLC: " << (int)frame.DLC << ", Data: ";
+  for (int i = 0; i < frame.DLC; ++i) {
+    std::cout << std::hex << (int)frame.data.u8[i] << " ";
+  }
+  std::cout << std::dec << "\n";
+}
+
+std::string snake_case_to_camel_case(const std::string& str) {
+  std::string result;
+  bool toUpper = false;
+  for (char ch : str) {
+    if (ch == '_') {
+      toUpper = true;
+    } else if (ch < '0' || (ch > '9' && ch < 'A') || (ch > 'Z' && ch < 'a') || ch > 'z') {
+      // skip non-alphanumeric characters
+      toUpper = true;
+    } else {
+      if (toUpper) {
+        result += toupper(ch);
+        toUpper = false;
+      } else {
+        result += ch;
+      }
+    }
+  }
+  return result;
+}
+
+CAN_frame parse_can_log_line(const std::string& logLine) {
+  std::stringstream ss(logLine);
+  CAN_frame frame = {};
+  char dummy;
+
+  double timestamp;
+  std::string interfaceName;
+
+  // timestamp and interface name are parsed but not used
+  ss >> dummy >> timestamp >> dummy;
+  ss >> interfaceName;
+
+  // parse hexadecimal CAN ID
+  ss >> std::hex >> frame.ID;
+  if (ss.fail()) {
+    throw std::runtime_error("Invalid format: Failed to parse CAN ID.");
+  }
+  // check whether the ID is in the extended range
+  frame.ext_ID = (frame.ID > 0x7FF);
+
+  // parse the data length
+  int dlc_val;
+  ss >> dummy;  // Consume '['
+  if (ss.fail() || dummy != '[') {
+    throw std::runtime_error("Invalid format: Missing opening bracket for data length.");
+  }
+  ss >> dlc_val;
+  frame.DLC = static_cast<uint8_t>(dlc_val);
+  ss >> dummy;  // Consume ']'
+  if (ss.fail() || dummy != ']') {
+    throw std::runtime_error("Invalid format: Missing closing bracket for data length.");
+  }
+  // crudely assume CAN FD if DLC > 8
+  frame.FD = (frame.DLC > 8);
+
+  // parse the actual data bytes
+  unsigned int byte;
+  for (int i = 0; i < frame.DLC; ++i) {
+    ss >> std::hex >> byte;
+    if (ss.fail()) {
+      throw std::runtime_error("Fewer data bytes than specified by data length.");
+    }
+    frame.data.u8[i] = static_cast<uint8_t>(byte);
+  }
+
+  return frame;
+}
+
+std::vector<CAN_frame> parse_can_log_file(const fs::path& filePath) {
+  std::ifstream logFile(filePath);
+  if (!logFile.is_open()) {
+    std::cerr << "Error: Could not open file " << filePath << std::endl;
+    return {};
+  }
+
+  std::vector<CAN_frame> frames;
+  std::string line;
+  int lineNumber = 0;
+
+  // read the file line by line
+  while (std::getline(logFile, line)) {
+    lineNumber++;
+    if (line.empty()) {
+      continue;
+    }
+
+    if (line[0] == '#' || line[0] == ';') {
+      continue;  // skip comment lines
+    }
+
+    try {
+      frames.push_back(parse_can_log_line(line));
+    } catch (const std::runtime_error& e) {
+      std::cerr << "Warning: Skipping malformed line " << lineNumber << " in " << filePath.filename()
+                << ". Reason: " << e.what() << std::endl;
+    }
+  }
+
+  return frames;
+}