Header parsing

Updated more error checking in the header check.
Now looking at name space and and bit timing section.

Bit timing is not used so maybe not include parsing of that?

Author: LinuxDevon

src/dbc.hpp

@@ -18,7 +18,10 @@ namespace libdbc {
 
 	class DbcParser : public Parser {
 	public:
-		DbcParser() : version(""), version_re("(VERSION)\\s\"(.*)\"") {}
+		DbcParser() : version(""), version_re("^(VERSION)\\s\"(.*)\""),
+					  bit_timing_re("^(BS_:)"), name_space_re("^(_NS)\\s \\:") {
+
+		}
 
 		virtual ~DbcParser() = default;
 
@@ -29,7 +32,7 @@ namespace libdbc {
 			parse_dbc_header(s);
 
 			while(!s.eof()) {
-				utils::SafeString::get_line(s, line);
+				utils::StreamHandler::get_line(s, line);
 
 			}
 
@@ -43,19 +46,59 @@ namespace libdbc {
 		std::string version;
 
 		const std::regex version_re;
+		const std::regex bit_timing_re;
+		const std::regex name_space_re;
 
 		void parse_dbc_header(std::istream& file_stream) {
 			std::string line;
 			std::smatch match;
-
-			utils::SafeString::get_line(file_stream, line);
+			bool is_blank = true;
+			bool not_blank = true;
+
+			std::vector<std::string> symbols = {"CM_",
+											   "BA_DEF_",
+											   "BA_",
+											   "VAL",
+											   "CAT_DEF_",
+											   "CAT_",
+											   "FILTER",
+											   "BA_DEF_DEF_",
+											   "EV_DATA_",
+											   "ENVVAR_DATA_",
+											   "SGTYPE_",
+											   "SGTYPE_VALTYPE_",
+											   "BA_DEF_SGTYPE_",
+											   "BA_SGTYPE_",
+											   "SIG_TYPE_REF_",
+											   "VAL_TABLE_",
+											   "SIG_GROUP_",
+											   "SIG_VALTYPE_",
+											   "SIGTYPE_VALTYPE_",
+											   "BO_TX_BU_",
+											   "BA_DEF_REL_",
+											   "BA_REL_",
+											   "BA_DEF_DEF_REL_",
+											   "BU_SG_REL_",
+											   "BU_EV_REL_",
+											   "BU_BO_REL_"};
+
+			utils::StreamHandler::get_line(file_stream, line);
 
 			if(!std::regex_search(line, match, version_re)) {
 				throw validity_error();
 			}
 
 			version = match.str(2);
 
+			utils::StreamHandler::get_next_non_blank_line( file_stream, line );
+
+			utils::StreamHandler::skip_to_next_blank_line( file_stream, line );
+
+			utils::StreamHandler::get_next_non_blank_line( file_stream, line );
+
+			if(!std::regex_search(line, match, bit_timing_re))
+				throw validity_error();
+
 		}
 
 	};

src/util/utils.cpp

@@ -1,8 +1,10 @@
 #include "util/utils.hpp"
 
+#include <regex>
+
 namespace utils {
 
-	std::istream & SafeString::get_line( std::istream & stream, std::string & line ) {
+	std::istream & StreamHandler::get_line( std::istream & stream, std::string & line ) {
 		std::string newline;
 
 		std::getline( stream, newline );
@@ -20,4 +22,46 @@ namespace utils {
 		return stream;
 	}
 
+
+	std::istream & StreamHandler::get_next_non_blank_line( std::istream & stream, std::string & line ) {
+		bool is_blank = true;
+
+		const std::regex whitespace_re("\\s*(.*)");
+		std::smatch match;
+
+		while(is_blank) {
+			utils::StreamHandler::get_line(stream, line);
+
+			std::regex_search(line, match, whitespace_re);
+
+			if((!line.empty() && !match.empty()) || (stream.eof())){
+				if((match.length(1) > 0) || (stream.eof())){
+					is_blank = false;
+				}
+			}
+		}
+
+		return stream;
+	}
+
+	std::istream & StreamHandler::skip_to_next_blank_line( std::istream & stream, std::string & line ) {
+		bool line_is_empty = false;
+
+		const std::regex whitespace_re("\\s*(.*)");
+		std::smatch match;
+
+		while(!line_is_empty) {
+			utils::StreamHandler::get_line(stream, line);
+
+			std::regex_search(line, match, whitespace_re);
+
+			if((match.length(1) == 0) || (stream.eof())){
+				line_is_empty = true;
+			}
+		}
+
+		return stream;
+	}
+
+
 }	// Namespace Utils

src/util/utils.hpp

@@ -4,7 +4,7 @@
 
 namespace utils {
 
-	class SafeString {
+	class StreamHandler {
 	public:
 		/**
 		 * This is a safe non line ending specific get_ine function. This is to help with files
@@ -17,6 +17,11 @@ namespace utils {
 		 */
 		static std::istream & get_line( std::istream & stream, std::string & line );
 
+
+		static std::istream & get_next_non_blank_line( std::istream & stream, std::string & line );
+
+		static std::istream & skip_to_next_blank_line( std::istream & stream, std::string & line );
+
 	};
 
 }

test/test_dbc.cpp

@@ -2,17 +2,24 @@
 #include "defines.hpp"
 #include "dbc.hpp"
 
-TEST_CASE("Testing dbc file loading", "[fileio]") {
+TEST_CASE("Testing dbc file loading error issues", "[fileio][error]") {
 	auto parser = std::unique_ptr<libdbc::DbcParser>(new libdbc::DbcParser());
 
 	SECTION("Loading a non dbc file should throw an error", "[error]") {
 		REQUIRE_THROWS_AS(parser->parse_file(TEXT_FILE), libdbc::validity_error);
 	}
 
-	// Undecided on the type of error yet. Need to think about this.
-	// SECTION("Loading a dbc with bad headers throws an error", "[error]") {
-	// 	REQUIRE_THROWS_AS(parser->parse_file(MISSING_VERSION_DBC_FILE), libdbc::header_error);
-	// }
+	SECTION("Loading a dbc with bad headers throws an error", "[error]") {
+		REQUIRE_THROWS_AS(parser->parse_file(MISSING_VERSION_DBC_FILE), libdbc::validity_error);
+	}
+
+	SECTION("Loading a dbc without the required bit timing section (BS_:)", "[error]") {
+		REQUIRE_THROWS_AS(parser->parse_file(MISSING_BIT_TIMING_DBC_FILE), libdbc::validity_error);
+	}
+}
+
+TEST_CASE("Testing dbc file loading", "[fileio]") {
+	auto parser = std::unique_ptr<libdbc::DbcParser>(new libdbc::DbcParser());
 
 	SECTION("Loading a single simple dbc file", "[dbc]") {
 		std::vector<libdbc::Message> messages;

test/test_utils.cpp

@@ -2,6 +2,8 @@
 #include "defines.hpp"
 #include "util/utils.hpp"
 
+#include <sstream>
+
 using namespace utils;
 
 TEST_CASE("Basic file input with safe get_line that is non line ending specific", "") {
@@ -13,16 +15,62 @@ TEST_CASE("Basic file input with safe get_line that is non line ending specific"
 		CHECK(TextFile.is_open());
 
 		if(TextFile.is_open()) {
-			SafeString::get_line(TextFile, test);
+			StreamHandler::get_line(TextFile, test);
 			REQUIRE(test == "This is a non dbc formatted file.");
-			SafeString::get_line(TextFile, test);
+			StreamHandler::get_line(TextFile, test);
 			REQUIRE(test == "");
-			SafeString::get_line(TextFile, test);
+			StreamHandler::get_line(TextFile, test);
 			REQUIRE(test == "Make sure things pass with this");
-			SafeString::get_line(TextFile, test);
+			StreamHandler::get_line(TextFile, test);
 			REQUIRE(test == "Who knows 	what might happen.");
 
 			TextFile.close();
 		}
 	}
 }
+
+TEST_CASE("Test line finding utility functions", "") {
+	std::string line;
+	std::string test_string = \
+"hello\n\
+	\n\
+		 \n\
+  \n\
+this is not blank\n\
+maybe not this one either\n\
+\n\
+Someone wrote something....\n\
+   b\n\
+end";
+
+	std::istringstream stream(test_string);
+
+	SECTION("Test skipping empty lines") {
+		StreamHandler::get_line(stream, line);
+
+		CHECK(line == "hello");
+
+		StreamHandler::get_next_non_blank_line(stream, line);
+		REQUIRE(line == "this is not blank");
+
+		StreamHandler::skip_to_next_blank_line(stream, line);
+		REQUIRE(line == "");
+
+		StreamHandler::get_next_non_blank_line(stream, line);
+		REQUIRE(line == "Someone wrote something....");
+
+		StreamHandler::get_next_non_blank_line(stream, line);
+		REQUIRE(line == "   b");
+
+		StreamHandler::get_next_non_blank_line(stream, line);
+		REQUIRE(line == "end");
+
+		SECTION("Test end of the files", "[edge case]") {
+			StreamHandler::get_next_non_blank_line(stream, line);
+			REQUIRE(line == "");
+
+			StreamHandler::skip_to_next_blank_line(stream, line);
+			REQUIRE(line == "");
+		}
+	}
+}