Adding unit tests

Author: hummeltech

src/CMakeLists.txt

@@ -294,17 +294,32 @@ set(unit_test_protocol_helper_SRCS
 )
 set(unit_test_protocol_helper_LIBS
   ${GLIB_LIBRARIES}
-  ${INIPARSER_LIBRARIES}
 )
 add_executable(unit_test_protocol_helper ${unit_test_protocol_helper_SRCS})
 set_target_properties(unit_test_protocol_helper PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/tests)
-target_compile_definitions(unit_test_protocol_helper PRIVATE
-  RENDERD_CONF="${PROJECT_SOURCE_DIR}/etc/renderd/renderd.conf.examples"
-)
 target_include_directories(unit_test_protocol_helper PRIVATE ${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/tests)
 target_link_libraries(unit_test_protocol_helper ${unit_test_protocol_helper_LIBS})
 
 
+#-----------------------------------------------------------------------------
+#
+#  unit_test_render_submit_queue
+#
+#-----------------------------------------------------------------------------
+
+set(unit_test_render_submit_queue_SRCS
+  $<TARGET_OBJECTS:catch_main_o>
+  ${PROJECT_SOURCE_DIR}/tests/unit_test_render_submit_queue.cpp
+)
+set(unit_test_render_submit_queue_LIBS
+  ${GLIB_LIBRARIES}
+)
+add_executable(unit_test_render_submit_queue ${unit_test_render_submit_queue_SRCS})
+set_target_properties(unit_test_render_submit_queue PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/tests)
+target_include_directories(unit_test_render_submit_queue PRIVATE ${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/tests)
+target_link_libraries(unit_test_render_submit_queue ${unit_test_render_submit_queue_LIBS})
+
+
 #-----------------------------------------------------------------------------
 #
 #  unit_test_renderd_config

src/cache_expire.c

@@ -32,9 +32,9 @@
  * URL.
  * RFC for HTCP can be found at http://www.htcp.org/
  */
-static void cache_expire_url(int sock, char * url)
+static void cache_expire_url(int sock, char *url)
 {
-	char * buf;
+	char *buf;
 
 	if (sock < 0) {
 		return;
@@ -44,66 +44,66 @@ static void cache_expire_url(int sock, char * url)
 	int url_len;
 
 	url_len = strlen(url);
-	buf = (char *) malloc(12 + 22 + url_len);
+	buf = (char *)malloc(12 + 22 + url_len);
 
 	if (!buf) {
 		return;
 	}
 
 	idx = 0;
 
-	//16 bit: Overall length of the datagram packet, including this header
+	// 16 bit: Overall length of the datagram packet, including this header
 	*((uint16_t *)(&buf[idx])) = htons(12 + 22 + url_len);
 	idx += 2;
 
-	//HTCP version. Currently at 0.0
-	buf[idx++] = 0; //Major version
-	buf[idx++] = 0; //Minor version
+	// HTCP version. Currently at 0.0
+	buf[idx++] = 0; // Major version
+	buf[idx++] = 0; // Minor version
 
-	//Length of HTCP data, including this field
+	// Length of HTCP data, including this field
 	*((uint16_t *)(&buf[idx])) = htons(8 + 22 + url_len);
 	idx += 2;
 
-	//HTCP opcode CLR=4
+	// HTCP opcode CLR=4
 	buf[idx++] = 4;
-	//Reserved
+	// Reserved
 	buf[idx++] = 0;
 
-	//32 bit transaction id;
+	// 32 bit transaction id;
 	*((uint32_t *)(&buf[idx])) = htonl(255);
 	idx += 4;
 
 	buf[idx++] = 0;
-	buf[idx++] = 0; //HTCP reason
+	buf[idx++] = 0; // HTCP reason
 
-	//Length of the Method string
+	// Length of the Method string
 	*((uint16_t *)(&buf[idx])) = htons(4);
 	idx += 2;
 
-	///Method string
+	/// Method string
 	memcpy(&buf[idx], "HEAD", 4);
 	idx += 4;
 
-	//Length of the url string
+	// Length of the url string
 	*((uint16_t *)(&buf[idx])) = htons(url_len);
 	idx += 2;
 
-	//Url string
+	// Url string
 	memcpy(&buf[idx], url, url_len);
 	idx += url_len;
 
-	//Length of version string
+	// Length of version string
 	*((uint16_t *)(&buf[idx])) = htons(8);
 	idx += 2;
 
-	//version string
+	// version string
 	memcpy(&buf[idx], "HTTP/1.1", 8);
 	idx += 8;
 
-	//Length of request headers. Currently 0 as we don't have any headers to send
+	// Length of request headers. Currently 0 as we don't have any headers to send
 	*((uint16_t *)(&buf[idx])) = htons(0);
 
-	if (send(sock, (void *) buf, (12 + 22 + url_len), 0) < (12 + 22 + url_len)) {
+	if (send(sock, (void *)buf, (12 + 22 + url_len), 0) < (12 + 22 + url_len)) {
 		g_logger(G_LOG_LEVEL_ERROR, "Failed to send HTCP purge for %s", url);
 	};
 
@@ -117,13 +117,13 @@ void cache_expire(int sock, const char *host, const char *uri, int x, int y, int
 		return;
 	}
 
-	char * url = (char *)malloc(1024);
+	char *url = (char *)malloc(1024);
 	snprintf(url, 1024, "http://%s%s%i/%i/%i.png", host, uri, z, x, y);
 	cache_expire_url(sock, url);
 	free(url);
 }
 
-int init_cache_expire(const char * htcphost)
+int init_cache_expire(const char *htcphost)
 {
 	struct addrinfo hints;
 	struct addrinfo *result, *rp;
@@ -132,7 +132,7 @@ int init_cache_expire(const char * htcphost)
 	/* Obtain address(es) matching host/port */
 
 	memset(&hints, 0, sizeof(struct addrinfo));
-	hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
+	hints.ai_family = AF_UNSPEC;	/* Allow IPv4 or IPv6 */
 	hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
 	hints.ai_flags = 0;
 	hints.ai_protocol = 0; /* Any protocol */
@@ -157,7 +157,7 @@ int init_cache_expire(const char * htcphost)
 		}
 
 		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) {
-			break;        /* Success */
+			break; /* Success */
 		}
 
 		close(sfd);
@@ -171,5 +171,4 @@ int init_cache_expire(const char * htcphost)
 	freeaddrinfo(result); /* No longer needed */
 
 	return sfd;
-
 }

src/metatile.cpp

@@ -28,8 +28,7 @@
 #include "render_config.h"
 #include "store.h"
 
-metaTile::metaTile(const std::string &xmlconfig, const std::string &options, int x, int y, int z):
-	x_(x), y_(y), z_(z), xmlconfig_(xmlconfig), options_(options)
+metaTile::metaTile(const std::string &xmlconfig, const std::string &options, int x, int y, int z) : x_(x), y_(y), z_(z), xmlconfig_(xmlconfig), options_(options)
 {
 	clear();
 }
@@ -59,13 +58,13 @@ int metaTile::xyz_to_meta_offset(int x, int y, int z)
 	return (x & mask) * METATILE + (y & mask);
 }
 
-void metaTile::save(struct storage_backend * store)
+void metaTile::save(struct storage_backend *store)
 {
 	int ox, oy, limit;
 	ssize_t offset;
 	struct meta_layout m;
 	struct entry offsets[METATILE * METATILE];
-	char * metatilebuffer;
+	char *metatilebuffer;
 	char *tmp;
 
 	memset(&m, 0, sizeof(m));
@@ -86,12 +85,12 @@ void metaTile::save(struct storage_backend * store)
 		for (oy = 0; oy < limit; oy++) {
 			int mt = xyz_to_meta_offset(x_ + ox, y_ + oy, z_);
 			offsets[mt].offset = offset;
-			offsets[mt].size   = tile[ox][oy].size();
+			offsets[mt].size = tile[ox][oy].size();
 			offset += offsets[mt].size;
 		}
 	}
 
-	metatilebuffer = (char *) malloc(offset);
+	metatilebuffer = (char *)malloc(offset);
 
 	if (metatilebuffer == 0) {
 		g_logger(G_LOG_LEVEL_WARNING, "Failed to write metatile. Out of memory");
@@ -118,7 +117,6 @@ void metaTile::save(struct storage_backend * store)
 	free(metatilebuffer);
 }
 
-
 void metaTile::expire_tiles(int sock, const char *host, const char *uri)
 {
 	if (sock < 0) {

src/render_submit_queue.c

@@ -174,7 +174,7 @@ static struct protocol *fetch(void)
 	pthread_cond_signal(&qCondNotFull);
 	pthread_mutex_unlock(&qLock);
 
-	struct protocol *cmd = malloc(sizeof(struct protocol));
+	struct protocol *cmd = (struct protocol *)malloc(sizeof(struct protocol));
 
 	cmd->ver = 2;
 	cmd->cmd = cmdRenderBulk;
@@ -192,7 +192,7 @@ static struct protocol *fetch(void)
 void enqueue(const char *xmlname, int x, int y, int z)
 {
 	// Add this path in the local render queue
-	struct qItem *e = malloc(sizeof(struct qItem));
+	struct qItem *e = (struct qItem *)malloc(sizeof(struct qItem));
 
 	e->mapname = strdup(xmlname);
 	e->x = x;
@@ -265,7 +265,7 @@ int make_connection(const char *spath)
 		if (!hostname_len) {
 			hostname = strdup(RENDERD_HOST);
 		} else {
-			hostname = malloc(hostname_len + sizeof('\0'));
+			hostname = (char *)malloc(hostname_len + sizeof('\0'));
 			assert(hostname != NULL);
 			strncpy(hostname, spath, hostname_len);
 		}
@@ -408,7 +408,7 @@ void spawn_workers(int num, const char *spath, int max_load)
 	qMaxLen = no_workers;
 
 	g_logger(G_LOG_LEVEL_MESSAGE, "Starting %d rendering threads", no_workers);
-	workers = calloc(sizeof(pthread_t), no_workers);
+	workers = (pthread_t *)calloc(sizeof(pthread_t), no_workers);
 
 	if (!workers) {
 		g_logger(G_LOG_LEVEL_CRITICAL, "Error allocating worker memory: %s", strerror(errno));

tests/CMakeLists.txt

@@ -240,6 +240,11 @@ add_test(
   COMMAND unit_test_protocol_helper
 )
 
+add_test(
+  NAME unit_test_render_submit_queue
+  COMMAND unit_test_render_submit_queue
+)
+
 add_test(
   NAME unit_test_renderd_config
   COMMAND unit_test_renderd_config

tests/unit_test_render_submit_queue.cpp

@@ -0,0 +1,100 @@
+#include <chrono>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <string>
+#include <unistd.h>
+
+#include "catch/catch.hpp"
+#include "catch_test_common.hpp"
+#include "render_submit_queue.h"
+#include "sys_utils.h"
+
+extern int exit_status;
+extern bool fail_next_getloadavg;
+extern bool fail_next_socket;
+extern jmp_buf exit_jump;
+extern std::string err_log_lines;
+
+extern "C" {
+#define exit mocked_exit
+#define g_logger mocked_g_logger
+#define getloadavg mocked_getloadavg
+#define socket mocked_socket
+
+#include "protocol_helper.c"
+#include "render_submit_queue.c"
+#include "sys_utils.c"
+
+#undef exit
+#undef g_logger
+#undef getloadavg
+#undef socket
+}
+
+TEST_CASE("check_load function", "[check_load]")
+{
+	err_log_lines.clear();
+
+	maxLoad = 999;
+	auto start = std::chrono::high_resolution_clock::now();
+
+	SECTION("check_load with max load of 999", "should return") {
+		check_load();
+	}
+
+	SECTION("check_load with max load of 999 and unobtainable load average (which returns 1000)", "should return after sleeping 5 seconds") {
+		fail_next_getloadavg = true;
+		check_load();
+		REQUIRE(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::high_resolution_clock::now() - start).count() >= 5);
+	}
+}
+
+TEST_CASE("process function", "[process]")
+{
+	int fd, ret;
+	int pipefd[2];
+	pipe(pipefd);
+	struct protocol *cmd = (struct protocol *)malloc(sizeof(struct protocol));
+
+	err_log_lines.clear();
+
+	fd = pipefd[0];
+
+	SECTION("process", "should return positive") {
+		ret = process(cmd, fd);
+
+		REQUIRE(ret == 0);
+		REQUIRE_THAT(err_log_lines, Catch::Matchers::Contains("Sending request"));
+		REQUIRE_THAT(err_log_lines, Catch::Matchers::Contains("send error: Success"));
+	}
+}
+
+TEST_CASE("make_connection function", "[make_connection]")
+{
+	int ret;
+	std::string socket_path = std::string(P_tmpdir) + "/renderd.sock";
+
+	err_log_lines.clear();
+	exit_status = 0;
+
+	SECTION("make_connection", "should return positive") {
+		ret = make_connection(socket_path.c_str());
+
+		// REQUIRE(ret > 0);
+	}
+
+	SECTION("make_connection handles socket failure by exiting", "should exit 2") {
+		fail_next_socket = true;
+
+		if (setjmp(exit_jump) == 0) {
+			make_connection(socket_path.c_str());
+			FAIL("make_connection should have called exit() but didn't");
+		} else {
+			SUCCEED("Captured expected exit() call due to socket failure");
+		}
+
+		REQUIRE(exit_status == 2);
+		REQUIRE_THAT(err_log_lines, Catch::Matchers::Contains("failed to create unix socket"));
+	}
+}

tests/unit_test_sys_utils.cpp

@@ -10,13 +10,15 @@
 extern bool fail_next_getloadavg;
 extern std::string err_log_lines;
 
+extern "C" {
 #define g_logger mocked_g_logger
 #define getloadavg mocked_getloadavg
 
 #include "sys_utils.c"
 
 #undef g_logger
 #undef getloadavg
+}
 
 TEST_CASE("get_load_avg function", "[get_load_avg]")
 {