summaryrefslogtreecommitdiff
path: root/server/src
diff options
context:
space:
mode:
Diffstat (limited to 'server/src')
-rw-r--r--server/src/Makefile.am2
-rw-r--r--server/src/versionstr.cc68
-rw-r--r--server/src/versionstr.h45
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: