Merge pull request #1221 from ingve/unittests

Unittests additions

Author: fwsGonzo

etc/service.cmake

@@ -293,6 +293,7 @@ target_link_libraries(service
     cxxabi
     libos
     libc
+    libos
     libm
     libg
     libgcc

src/kernel/syscalls.cpp

@@ -32,7 +32,6 @@
 #include <info>
 #include <smp>
 
-
 #if defined (UNITTESTS) && !defined(__MACH__)
 #define THROW throw()
 #else
@@ -56,40 +55,6 @@ void _exit(int status) {
   default_exit();
 }
 
-int execve(const char*,
-           char* const*,
-           char* const*)
-{
-  panic("SYSCALL EXECVE NOT SUPPORTED");
-  return -1;
-}
-
-int fork() {
-  panic("SYSCALL FORK NOT SUPPORTED");
-  return -1;
-}
-
-int fstat(int, struct stat* st) {
-  debug("SYSCALL FSTAT Dummy, returning OK 0");
-  st->st_mode = S_IFCHR;
-  return 0;
-}
-
-int getpid() {
-  debug("SYSCALL GETPID Dummy, returning 1");
-  return 1;
-}
-
-int link(const char*, const char*) {
-  panic("SYSCALL LINK unsupported");
-  return -1;
-}
-
-int unlink(const char*) {
-  panic("SYSCALL UNLINK unsupported");
-  return -1;
-}
-
 void* sbrk(ptrdiff_t incr) {
   /// NOTE:
   /// sbrk gets called really early on, before everything else
@@ -102,14 +67,6 @@ void* sbrk(ptrdiff_t incr) {
   return (void*) prev_heap_end;
 }
 
-/*
-int stat(const char*, struct stat *st) {
-  debug("SYSCALL STAT Dummy");
-  st->st_mode = S_IFCHR;
-  return 0;
-}
-*/
-
 clock_t times(struct tms*) {
   panic("SYSCALL TIMES Dummy, returning -1");
   return -1;
@@ -252,4 +209,3 @@ void _init_syscalls()
   // make sure that the buffers length is zero so it won't always show up in crashes
   _crash_context_buffer[0] = 0;
 }
-

src/posix/sys/stat.cpp

@@ -219,3 +219,9 @@ mode_t umask(mode_t cmask)
   (void) cmask;
   return DEFAULT_UMASK;
 }
+
+int fstat(int, struct stat* st) {
+  debug("SYSCALL FSTAT Dummy, returning OK 0");
+  st->st_mode = S_IFCHR;
+  return 0;
+}

src/posix/unistd.cpp

@@ -416,3 +416,31 @@ long pathconf(const char *path, int name) {
   close(fd);
   return res;
 }
+
+int execve(const char*,
+           char* const*,
+           char* const*)
+{
+  panic("SYSCALL EXECVE NOT SUPPORTED");
+  return -1;
+}
+
+int fork() {
+  panic("SYSCALL FORK NOT SUPPORTED");
+  return -1;
+}
+
+int getpid() {
+  debug("SYSCALL GETPID Dummy, returning 1");
+  return 1;
+}
+
+int link(const char*, const char*) {
+  panic("SYSCALL LINK unsupported");
+  return -1;
+}
+
+int unlink(const char*) {
+  panic("SYSCALL UNLINK unsupported");
+  return -1;
+}

src/util/statman.cpp

@@ -103,8 +103,9 @@ Stat& Statman::create(const Stat::Stat_type type, const std::string& name) {
   if(idx >= stats_.size()) {
     throw Stats_out_of_memory{};
   }
-
-  return (*new (&stats_[next_available_++]) Stat{type, idx, name});
+  auto& stat = *new (&stats_[next_available_]) Stat(type, idx, name);
+  next_available_++;
+  return stat;
 }
 
 ///////////////////////////////////////////////////////////////////////////////

test/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 2.8.9)
 project(unittests C CXX)
 
 option(COVERAGE "Build with coverage generation" OFF)
+option(SILENT_BUILD "Build with some warnings turned off" ON)
 
 if ("${ARCH}" STREQUAL "")
   set (ARCH "ARCH_X86")
@@ -204,7 +205,12 @@ if ("${ARCH}" STREQUAL "ARCH_ARMv7")
   set_property(SOURCE ${SOURCES} PROPERTY COMPILE_FLAGS -mfpu=vfpv3-d16)
 endif("${ARCH}" STREQUAL "ARCH_ARMv7")
 
+if(SILENT_BUILD)
+  message(STATUS "NOTE: Building with some warnings turned off")
+  set_property(SOURCE ${SOURCES} APPEND_STRING PROPERTY COMPILE_FLAGS
+  "-Wno-unused-variable -Wno-unused-parameter -Wno-sign-compare -Wno-format")
+endif()
+
 add_executable(unittests ${SOURCES})
 install(TARGETS unittests DESTINATION ${TEST})
 install(DIRECTORY lest/include/lest DESTINATION ${CMAKE_INSTALL_PREFIX}/include)
-

test/net/unit/http_request_test.cpp

@@ -124,3 +124,13 @@ CASE("make_request makes requests")
   auto req_ptr = http::make_request("GET / HTTP/1.1");
   EXPECT(req_ptr->version().to_string() == "HTTP/1.1");
 }
+
+CASE("operator std::string converts request to string")
+{
+  http::Request r("GET /");
+  r.set_method(http::HEAD);
+  r.set_uri(uri::URI("/data/json/includeos_stats"));
+  r.set_version(http::Version(1, 1));
+  std::string s = r;
+  EXPECT(s.size() > 30);
+}

test/net/unit/http_time_test.cpp

@@ -30,7 +30,26 @@ CASE("from_time_t() returns time as string")
 
 CASE("to_time_t() returns time_t from string")
 {
-  auto str = "Tue, 01 Jan 1980 00:00:00 GMT"s;
-  time_t time {http::time::to_time_t(str)};
-  EXPECT(time != std::time_t{});
+  auto str1 = "Tue, 01 Jan 1980 00:00:00 GMT"s;
+  time_t time1 {http::time::to_time_t(str1)};
+  EXPECT(time1 != std::time_t{});
+
+  auto str2 = "Tuesday, 01-Jan-80 00:00:00 GMT"s;
+  time_t time2 {http::time::to_time_t(str2)};
+  EXPECT(time2 != std::time_t{});
+
+  auto str3 = "Tue Jan  1 00:00:00 1980"s;
+  time_t time3 {http::time::to_time_t(str3)};
+  EXPECT(time3 != std::time_t{});
+
+  // invalid
+  auto str4 = "Zxe Jyn 32 23:59:99 1930"s;
+  time_t time4 {http::time::to_time_t(str4)};
+  EXPECT(time4 == std::time_t{});
+}
+
+CASE("now() returns current time")
+{
+  auto str = http::time::now();
+  EXPECT(str.size() > 0ul);
 }

test/util/unit/statman.cpp

@@ -285,3 +285,53 @@ CASE("A Stat is accessible through index operator")
     free(buffer);
   }
 }
+
+CASE("stats names can only be MAX_NAME_LEN characters long")
+{
+  uintptr_t buffer = (uintptr_t)malloc(8192);
+  Statman statman_{buffer, 8192};
+  // ok
+  std::string statname1 {"a.stat"};
+  Stat& stat1 = statman_.create(Stat::UINT32, statname1);
+  // also ok
+  const size_t MAX_NAME_LEN {48};
+  std::string statname2(MAX_NAME_LEN, 'x');
+  Stat& stat2 = statman_.create(Stat::UINT32, statname2);
+  int num_stats_before = statman_.num_stats();
+  // not ok
+  std::string statname3(MAX_NAME_LEN + 1, 'y');
+  EXPECT_THROWS(Stat& stat3 = statman_.create(Stat::FLOAT, statname3));
+  int num_stats_after = statman_.num_stats();
+  EXPECT(num_stats_before == num_stats_after);
+  free((void*)buffer);
+}
+
+CASE("get(\"name\") returns reference to stat with name, throws if not present")
+{
+  uintptr_t buffer = (uintptr_t)malloc(8192);
+  Statman statman_ {buffer, 8192};
+  EXPECT_THROWS(Stat& res1 = statman_.get("some.important.stat"));
+  EXPECT_THROWS(Stat& res2 = statman_.get("other.important.stat"));
+  EXPECT_THROWS(Stat& res3 = statman_.get("very.important.stat"));
+  Stat& stat1 = statman_.create(Stat::UINT32, "some.important.stat");
+  Stat& stat2 = statman_.create(Stat::UINT64, "other.important.stat");
+  Stat& stat3 = statman_.create(Stat::FLOAT, "very.important.stat");
+  ++stat1;
+  ++stat2;
+  ++stat3;
+  EXPECT_NO_THROW(Stat& res1 = statman_.get("some.important.stat"));
+  EXPECT_NO_THROW(Stat& res2 = statman_.get("other.important.stat"));
+  EXPECT_NO_THROW(Stat& res3 = statman_.get("very.important.stat"));
+  EXPECT_THROWS_AS(Stat& res5 = statman_.get("some.missing.stat"), Stats_exception);
+
+  free((void*)buffer);
+}
+
+CASE("total_num_bytes() returns total number of bytes the Statman object takes up")
+{
+  uintptr_t buffer = (uintptr_t)malloc(8192);
+  Statman statman_ {buffer, 8192};
+  Stat& stat1 = statman_.create(Stat::UINT32, "some.important.stat");
+  EXPECT(statman_.total_num_bytes() > 8192);
+  free((void*)buffer);
+}

test/util/unit/uri_test.cpp

@@ -131,4 +131,50 @@ CASE("URI construction, assignment")
   EXPECT_NOT(uri == uri1);
   EXPECT_NOT(uri == uri2);
   EXPECT_NOT(uri == uri3);
+  // test uri with query parameters
+  const uri::URI uri4 {"http://example.com/test/?param1=test&param2=foo&param3=bar"};
+  uri::URI uri5 {uri4};
+  EXPECT(uri4 == uri5);
+  EXPECT_NOT(uri == uri5);
+  uri::URI uri6 = uri5;
+  EXPECT(uri5 == uri6);
+}
+
+CASE("host_and_port() returns the URI's host and port")
+{
+  const uri::URI uri {"http://example.com:8080/?type=float"};
+  EXPECT(uri.host_and_port() == "example.com:8080");
+}
+
+CASE("is_valid returns whether the URI is \"valid\" (has host or path)")
+{
+  const uri::URI uri {"http://example.com"};
+  EXPECT(uri.is_valid());
+  const uri::URI uri2 {"/users/42#email"};
+  EXPECT(uri2.is_valid());
+}
+
+CASE("operator std::string() converts URI to string")
+{
+  const uri::URI uri {"http://example.com/test#p42"};
+  std::string s = uri;
+  EXPECT(s == "http://example.com/test#p42");
+}
+
+CASE("operator bool checks whether uri is valid")
+{
+  const uri::URI uri {"http://example.com/"};
+  bool valid = uri;
+  EXPECT(valid == true);
+}
+
+CASE("operator <")
+{
+  const uri::URI uri1 {"http://example.com/"};
+  const uri::URI uri2 {"http://www.google.com/?hl=en"};
+  bool res = (uri1 < uri2);
+  EXPECT(res == true);
+  const uri::URI uri3 = uri2;
+  res = (uri2 < uri3);
+  EXPECT(res == false);
 }