Added some more tests to the Version class. Documented the header file.

3 files changed, 99 insertions, 16 deletions

diff --git a/server/src/Makefile.am b/server/src/Makefile.am
index cdc4bfe..bb791aa 100644
--- a/server/src/Makefile.am
+++ b/server/src/Makefile.am
@@ -125,7 +125,7 @@ test_clean:
 	rm -f $(TESTFILES)
 
 test_versionstr: versionstr.cc
-	@../../tools/test versionstr.cc
+	@../../tools/test versionstr.cc $(BASICS)
 
 test_macrolist: macrolist.cc
 	@../../tools/test macrolist.cc versionstr.cc macroheaderparser.cc $(PARSERBASICS) $(BASICS)
diff --git a/server/src/versionstr.cc b/server/src/versionstr.cc
index 0d334b3..47451aa 100644
--- a/server/src/versionstr.cc
+++ b/server/src/versionstr.cc
@@ -27,6 +27,8 @@
  */
 #include "versionstr.h"
 
+#include "exception.h"
+
 #include <memory.h>
 #include <stdlib.h>
 
@@ -53,17 +55,17 @@ void VersionStr::set(std::string v)
   size_t idx = 0;
   for(size_t i = 0; i < v.length(); i++) {
     if(v[i] == '.') {
-      if(idx > 2) printf("Too long\n");
+      if(idx > 2) throw Exception("Version string is too long\n");
       version[idx] = atoi(num.c_str());
       idx++;
       num = "";
     } else if(v[i] >= '0' && v[i] <= '9') {
       num.append(1, v[i]);
     } else {
-      printf("Illigal character: [%c]\n", v[i]);
+      throw Exception(std::string("Version string contains illegal character: [")+v[i]+"]\n");
     }
   }
-  if(idx > 2) printf("Too long\n");
+  if(idx > 2) throw Exception("Version string is too long\n");
   version[idx] = atoi(num.c_str());
 }
 
@@ -112,43 +114,79 @@ size_t VersionStr::patch() const
 #ifdef TEST_VERSIONSTR
 
 #include <set>
+#include <vector>
 
 int main()
 {
+  // Test normal constructor and string conversion
   VersionStr v1("1.2.3");
   printf("VersionStr: %s\n", ((std::string)v1).c_str());
   if((std::string)v1 != "1.2.3") return 1;
 
+  // Test smaller version number and string conversion
   VersionStr v2("1.2");
   printf("VersionStr: %s\n", ((std::string)v2).c_str());
   if((std::string)v2 != "1.2") return 1;
   
+  // Test even smaller version number and string conversion
   VersionStr v3("1");
   printf("VersionStr: %s\n", ((std::string)v3).c_str());
   if((std::string)v3 != "1.0") return 1;
 
-  VersionStr v4("1.2.3.4"); // too long
-  printf("VersionStr: %s\n", ((std::string)v4).c_str());
-  if((std::string)v4 != "1.2.3") return 1;
-
-  VersionStr v5("1.2.a"); // illigal character
-  printf("VersionStr: %s\n", ((std::string)v5).c_str());
-  if((std::string)v5 != "1.2") return 1;
-
+  // Test too long version number (should throw an exception)
+  try {
+    VersionStr v4("1.2.3.4"); // too long
+    printf("VersionStr: %s\n", ((std::string)v4).c_str());
+    if((std::string)v4 != "1.2.3") return 1;
+  } catch(Exception &e) {
+    goto nextone;
+  }
+  return 1;
+
+ nextone:
+  // Test illegal character in version number (should throw an exception)
+  try { 
+    VersionStr v5("1.2.a"); // illegal character
+    printf("VersionStr: %s\n", ((std::string)v5).c_str());
+    if((std::string)v5 != "1.2") return 1;
+  } catch(Exception &e) {
+    goto nextoneagain;
+  }
+  return 1;
+
+ nextoneagain:
+  // Test string assignment
+  VersionStr v6("1.0");
+  v6 = "1.1";
+  if((std::string)v6 != "1.1") return 1;
+    
+  // Test sorting
   std::set<VersionStr> versions;
-  versions.insert(VersionStr("1.0"));
+  versions.insert(VersionStr("1.0")); // These two should be the same
   versions.insert(VersionStr("1.0.0"));
-  versions.insert(VersionStr("2.0"));
+
+  versions.insert(VersionStr("2.0")); // These should be sorted
   versions.insert(VersionStr("1.1"));
   versions.insert(VersionStr("0.1"));
   versions.insert(VersionStr("1.0.1"));
   versions.insert(VersionStr("1.0.3"));
   versions.insert(VersionStr("1.0.2"));
 
+  std::vector<std::string> refs; // Sorting reference values.
+  refs.push_back("2.0");
+  refs.push_back("1.1");
+  refs.push_back("1.0.3");
+  refs.push_back("1.0.2");
+  refs.push_back("1.0.1");
+  refs.push_back("1.0");
+  refs.push_back("0.1");
+
   std::set<VersionStr>::iterator i = versions.begin();
+  std::vector<std::string>::iterator j = refs.begin();
   while(i != versions.end()) {
-    printf("%s\n", ((std::string)*i).c_str());
-    i++;
+    printf("%s should be %s\n", ((std::string)*i).c_str(), j->c_str());
+    if(((std::string)*i) != *j) return false;
+    i++; j++;
   }
 
   return 0;
diff --git a/server/src/versionstr.h b/server/src/versionstr.h
index a840bd2..ceed42f 100644
--- a/server/src/versionstr.h
+++ b/server/src/versionstr.h
@@ -41,15 +41,60 @@
 #undef patch
 #endif
 
+/**
+ * VersionStr class.
+ * It hold a version number and is capable of correct sorting, as well as string 
+ * conversion both ways.
+ */
 class VersionStr {
 public:
+  /**
+   * Constructor.
+   * @param v A std::string containing a version string on the form a.b or a.b.c
+   */
   VersionStr(std::string v);
+
+  /**
+   * Constructor.
+   * @param major A size_t containing the major version number.
+   * @param minor A size_t containing the minor version number.
+   * @param patch A size_t containing the patch level.
+   */
+  VersionStr(size_t major = 0, size_t minor = 0, size_t patch = 0);
+
+  /**
+   * Typecast to std::string operator.
+   * It simply converts the version numbers into a string of the form major.minor
+   * (if patch i 0) or major.minor.patch
+   */
   operator std::string() const;
+
+  /**
+   * Assignment from std::string operator.
+   * Same as in the VersionStr(std::string v) constructor.
+   */
   void operator=(std::string v);
+
+  /**
+   * Comparison operator.
+   * The version objects are sorted according to their major, minor and patch
+   * level numbers.
+   */
   bool operator<(const VersionStr &other) const;
 
+  /**
+   * @return Major version number.
+   */
   size_t major() const;
+
+  /**
+   * @return Minor version number.
+   */
   size_t minor() const;
+
+  /**
+   * @return Patch level.
+   */
   size_t patch() const;
 
 private: