Added more tests and minor changes

CMakeLists.txt

@@ -12,7 +12,7 @@ add_definitions(-DMLOGTRACE)
 
 # boost
 # you should define BOOST_ROOT first
-find_package(Boost COMPONENTS system filesystem unit_test_framework random)
+find_package(Boost COMPONENTS system filesystem unit_test_framework random regex)
 include_directories(Boost_INCLUDE_DIR ${Boost_INCLUDE_DIRS})
 if(MSVC)
     # disable auto link on windows

mlog/file_logger.hpp

@@ -43,12 +43,13 @@ class file_logger : public logger<file_logger> {
 
 	template <typename M, typename T>
 	void write_to_log(M &&metadata, T &&log_text) {
-		std::string str = metadata.to_string(std::forward<T>(log_text));
+		std::string str = metadata.to_string(std::forward<T>(log_text), true);
 		m_stream.write(str.c_str(), str.size());
-		boost::iostreams::put(m_stream, '\n');
-		m_offset += str.size() + 1;
+		//boost::iostreams::put(m_stream, '\n');
+		m_offset += str.size(); // + 1;
 
-		flush();
+		if(m_flush_immediately)
+			flush();
 
 		if (max_file_size() != 0 && m_offset > max_file_size()) {
 			m_stream.open(
@@ -65,9 +66,24 @@ class file_logger : public logger<file_logger> {
 
 	inline bool is_open() const { return m_stream.is_open(); }
 
-	virtual void flush();
+	void flush();
+
+	inline bool flush_immediately() const {
+		return m_flush_immediately;
+	}
+
+	template<typename T>
+	void flush_immediately(T&& value) {
+		m_flush_immediately = value;
+	}
+
+
+
 
       private:
+
+	bool m_flush_immediately;
+
 	boost::iostreams::file_sink m_stream;
 	std::string m_log_name;
 	std::string m_log_directory;

mlog/impl/file_logger.hpp

@@ -10,7 +10,8 @@ namespace mlog {
 
 file_logger::file_logger(std::string log_name, std::string log_directory,
 			 mlog_bytes max_file_size)
-    : m_stream(get_next_logfile(log_directory, log_name, max_file_size,
+    : m_flush_immediately(true),
+      m_stream(get_next_logfile(log_directory, log_name, max_file_size,
 				&m_offset),
 	       BOOST_IOS::app),
       m_log_name(std::move(log_name)),
@@ -19,9 +20,6 @@ file_logger::file_logger(std::string log_name, std::string log_directory,
 
 file_logger::~file_logger() {}
 
-
-
-
 void file_logger::flush() { m_stream.flush(); }
 
 std::string file_logger::get_next_logfile(const std::string &directory,
@@ -40,8 +38,7 @@ std::string file_logger::get_next_logfile(const std::string &directory,
 		bool exists(false);
 		do {
 			new_path.reset(new boost::filesystem::path(
-			    path.string() + "." +
-			    std::to_string(i)));
+			    path.string() + "." + std::to_string(i)));
 			i++;
 			exists = boost::filesystem::exists(*new_path);
 		} while (exists && (max_file_size == 0 ||

mlog/impl/logger.hpp

@@ -64,7 +64,7 @@ log_metadata::log_metadata(mlog_level &&lvl, short session_id, bool _use_time,
 		thread_id = THREAD_GET_ID();
 }
 
-std::string log_metadata::to_string(const std::string& end_string) const {
+std::string log_metadata::to_string(const std::string& end_string, bool end_line) const {
 	char buffer[1024];
 	if (use_time) {
 
@@ -159,10 +159,12 @@ std::string log_metadata::to_string(const std::string& end_string) const {
 	} else {
 		std::size_t len = strlen(buffer);
 		std::string result;
-		result.resize(len + end_string.size());
+		result.resize(len + end_string.size() + (end_line ? 1 : 0 ));
 		char* rbuf = const_cast<char*>(result.c_str());
 		memcpy(rbuf, buffer, len);
 		memcpy(&rbuf[len], end_string.c_str(), end_string.size());
+		if(end_line)
+			rbuf[result.size()-1] = '\n';
 		return result;
 	}
 }

mlog/logger.hpp

@@ -98,7 +98,7 @@ struct log_metadata {
 		     bool _use_thread_id, const log_position &position,
 		     bool _use_position);
 
-	std::string to_string(const std::string& end_string = std::string()) const;
+	std::string to_string(const std::string& end_string = std::string(), bool end_line = false) const;
 
 	std::ostream &output(std::ostream &stream) const;
 };

manager.hpp → mlog/manager.hpp

@@ -50,6 +50,11 @@ struct mlog_manager {
 
 	inline bool use_position() const { return m_use_position; }
 	inline bool session() const { return m_session; }
+	inline void set_default_settings() {
+		use_time(false);
+		use_thread_id(false);
+		use_position(false);
+	}
 
       private:
 	std::atomic<logger_base *> m_log;

test_src/test.cpp

@@ -14,6 +14,7 @@
 #include <boost/random.hpp>
 #include <boost/generator_iterator.hpp>
 #include <boost/algorithm/string.hpp>
+#include <boost/regex.hpp>
 
 
 #ifdef _MSC_VER
@@ -91,7 +92,7 @@ BOOST_AUTO_TEST_CASE(mlog_logger_cleanup_test) {
 	std::cout << "mlog_logger_cleanup_test passed." << std::endl;
 }
 
-BOOST_AUTO_TEST_CASE(mlog_memory_logger_atomic_test) {
+BOOST_AUTO_TEST_CASE(mlog_memory_logger_mt_test) {
 
 	mlog::memory_logger_normal log;
 	mlog::manager->set_log(log);
@@ -154,12 +155,161 @@ BOOST_AUTO_TEST_CASE(mlog_async_test) {
 		result[n]++;
 	}
 
-	std::cout << "1" << std::endl;
 	for (auto &&i : result) {
 		BOOST_CHECK_EQUAL(i, 8);
 	}
 	std::cout << "mlog_async_test passed." << std::endl;
 }
+
+BOOST_AUTO_TEST_CASE(mlog_marco_test) {
+	const std::string filename = "macro_test.log";
+	std::remove(filename.c_str());
+	mlog::file_logger_thread_safe log(filename);
+	mlog::manager->set_log(log);
+
+	MLOG_INFO("info");
+	MLOG_DEBUG("debug");
+	MLOG_ERROR("error");
+	MLOG_FATAL("fatal");
+	MLOG_TRACE("trace");
+	MLOG_WARNING("warning");
+	log.get().flush();
+
+	std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
+	BOOST_CHECK_EQUAL(file.is_open(), true);
+	std::string str; 
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{info\\}: info$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{debug\\}: debug$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{error\\}: error$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{fatal\\}: fatal$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{trace\\}: trace$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9].\\]\\{warning\\}: warning$") ), true);
+	std::remove(filename.c_str());
+	std::cout << "mlog_marco_test passed." << std::endl;
+}
+
+BOOST_AUTO_TEST_CASE(mlog_options_test) {
+	const std::string filename = "options_test.log";
+	std::remove(filename.c_str());
+	mlog::file_logger_thread_safe log(filename);
+	mlog::manager->set_log(log);
+	MLOG_INFO("none");
+	mlog::manager->use_thread_id(true);
+	MLOG_INFO("thread_id");
+	mlog::manager->use_thread_id(false);
+	mlog::manager->use_time(true);	
+	MLOG_INFO("time");
+	mlog::manager->use_time(false);	
+	mlog::manager->use_position(true);
+	MLOG_INFO("position");
+	mlog::manager->use_thread_id(true);
+	mlog::manager->use_time(true);	
+	MLOG_INFO("all");
+	mlog::manager->set_default_settings();
+	log.get().flush();
+	std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
+	BOOST_CHECK_EQUAL(file.is_open(), true);
+	std::string str; 
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9]*\\]\\{info\\}: none$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[0-9]*-.*\\]\\{info\\}: thread_id$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^.*\\[[0-9].\\]\\{info\\}: time$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^\\[[^:]*:[0-9]* [0-9]*\\]\\{info\\}: position$") ), true);
+	std::getline(file, str);
+	BOOST_CHECK_EQUAL(boost::regex_match(str, boost::regex("^.*\\[[^:]*:[0-9]* [0-9]*-.*\\]\\{info\\}: all$") ), true);
+	std::remove(filename.c_str());
+	std::cout << "mlog_marco_test passed." << std::endl;
+}
+
+
+
+boost::regex stdline("^\\[[0-9].\\]\\{(info|debung|trace|warning|error|fatal)\\}: [0-9]*$");
+
+BOOST_AUTO_TEST_CASE(mlog_file_logger_test) {
+
+	const std::string filename = "file_logger_test.log";
+	std::remove(filename.c_str());
+	mlog::file_logger_thread_safe log(filename);
+	mlog::manager->set_log(log);
+	for(int i = 0;i < 512; i++) {
+		MLOG_INFO(boost::lexical_cast<std::string>(i));
+	}
+
+	log.get().flush();
+	std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
+	BOOST_CHECK_EQUAL(file.is_open(), true);
+
+	int i = 0;
+	for (std::string str; std::getline(file, str);i++) {
+		int index = str.find_last_of(" ");
+		BOOST_CHECK(index != std::string::npos); 
+		std::string num = str.substr(index+1);
+		BOOST_CHECK_EQUAL(std::atoi(num.c_str()), i);
+		BOOST_CHECK_EQUAL(boost::regex_match(str,stdline), true);
+	}
+	std::remove(filename.c_str());
+	std::cout << "mlog_file_logger_test passed." << std::endl;
+}
+
+
+
+
+BOOST_AUTO_TEST_CASE(mlog_file_logger_mt_test) {
+
+	const std::string filename = "file_logger_test.log";
+	std::remove(filename.c_str());
+	mlog::file_logger_thread_safe log(filename);
+	mlog::manager->set_log(log);
+	const std::size_t t = 8;
+	std::thread threads[t];
+
+	for (int i = 0; i < t; ++i)
+		threads[i] = std::thread([&]() {
+			for (int k = 0; k < 512; k++) { // (log size) / 8 = 512
+				MLOG_INFO(boost::lexical_cast<std::string>(k));
+			}
+		});
+
+	for (auto &t : threads)
+		t.join();
+
+	log.get().flush();
+
+	int result[512];
+	for (auto &&i : result) {
+		i = 0;
+	}
+
+
+	std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
+	BOOST_CHECK_EQUAL(file.is_open(), true);
+
+	for (std::string str; std::getline(file, str);) {
+		int index = str.find_last_of(" ");
+		BOOST_CHECK(index != std::string::npos); 
+		std::string num = str.substr(index+1);
+		int n = std::atoi(num.c_str());
+		result[n]++;
+		BOOST_CHECK_EQUAL(boost::regex_match(str,stdline), true);
+
+	}
+
+	for (auto &&i : result) {
+		BOOST_CHECK_EQUAL(i, 8);
+	}
+	std::cout << "mlog_file_logger_mt_test passed." << std::endl;
+}
+
+
 BOOST_AUTO_TEST_CASE(multiple_loggers_test) {
 	mlog::multiple_loggers log;
 	std::unique_ptr<mlog::memory_logger<2> > log1(
@@ -303,7 +453,6 @@ BOOST_AUTO_TEST_CASE(file_logger_speed_test) {
 		  << "ms for each log statment with thread id, timestamp and "
 		     "position." << std::endl;
 }
-
 BOOST_AUTO_TEST_CASE(memory_logger_test) {
 	num_loops = 100000;
 	mlog::memory_logger<2048> log;