9 files changed, 237 insertions, 47 deletions

diff --git a/src/exception.cpp b/src/exception.cpp
index 291a198..3cde134 100644
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -2,7 +2,8 @@
 #include <stdarg.h>
 
 Exception::Exception( const char *lpFormat, ... ) throw() :
-        nErrorCode( 0 )
+        nErrorCode( 0 ),
+        sWhat( NULL )
 {
         va_list ap;
 
@@ -12,7 +13,8 @@ Exception::Exception( const char *lpFormat, ... ) throw() :
 }
 
 Exception::Exception( int nCode, const char *lpFormat, ... ) throw() :
-        nErrorCode( nCode )
+        nErrorCode( nCode ),
+        sWhat( NULL )
 {
         va_list ap;
 
@@ -29,11 +31,16 @@ Exception::Exception( int nCode ) throw() :
 
 Exception::~Exception() throw()
 {
-        delete[] sWhat;
+        if( sWhat )
+        {
+                delete[] sWhat;
+                sWhat = NULL;
+        }
 }
 
 void Exception::setWhat( const char *lpFormat, va_list &vargs )
 {
+        if( sWhat ) delete[] sWhat;
         int nSize;
 
         nSize = vsnprintf( NULL, 0, lpFormat, vargs );
diff --git a/src/unit/hashtable.cpp b/src/unit/hashtable.cpp
new file mode 100644
index 0000000..b2e1cf5
--- /dev/null
+++ b/src/unit/hashtable.cpp
@@ -0,0 +1,107 @@
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <cpptest.h>
+#include <string.h>
+#include <set>
+#include <map>
+
+#include "hashfunctionstring.h"
+#include "hashfunctioncasestring.h"
+#include "hashfunctionint.h"
+
+class HashFunctionSuite : public Test::Suite
+{
+public:
+        HashFunctionSuite()
+        {
+                TEST_ADD( HashFunctionSuite::functionString )
+                TEST_ADD( HashFunctionSuite::functionCaseString )
+                TEST_ADD( HashFunctionSuite::functionInt )
+        }
+
+private:
+        void functionStringWorker( HashFunction &hf, std::set<unsigned long> &sCodes, char *str, int nLevel, int nMax )
+        {
+                for( char let = 'A'; let <= 'z'; let += 3 )
+                {
+                        str[nLevel+1] = '\0';
+                        str[nLevel] = let;
+                        unsigned long x = hf.hash( str );
+                        TEST_ASSERT( sCodes.find( x ) == sCodes.end() );
+                        TEST_ASSERT( hf.cmpIDs( str, str ) );
+                        sCodes.insert( x );
+
+                        if( nLevel < nMax )
+                                functionStringWorker( hf, sCodes, str, nLevel+1, nMax );
+                }
+        }
+        
+        void functionString()
+        {
+                HashFunctionString hf;
+                char str[10];
+
+                std::set<unsigned long> sCodes;
+
+                functionStringWorker( hf, sCodes, str, 0, 3 );
+        }
+        
+        void functionCaseStringWorker( HashFunction &hf, std::map<unsigned long, char *> &sCodes, char *str, int nLevel, int nMax )
+        {
+                for( char let = 'A'; let <= 'z'; let += 3 )
+                {
+                        str[nLevel+1] = '\0';
+                        str[nLevel] = let;
+                        unsigned long x = hf.hash( str );
+                        std::map<unsigned long, char *>::iterator i = sCodes.find( x );
+                        if( i == sCodes.end() )
+                        {
+                                sCodes[x] = strdup( str );
+                        }
+                        else
+                        {
+                                TEST_ASSERT( strcasecmp( (*i).second, str ) == 0 );
+                                TEST_ASSERT( hf.cmpIDs( (*i).second, str ) == true );
+                        }
+
+                        if( nLevel < nMax )
+                                functionCaseStringWorker( hf, sCodes, str, nLevel+1, nMax );
+                }
+        }
+        
+        void functionCaseString()
+        {
+                HashFunctionCaseString hf;
+                char str[10];
+
+                std::map<unsigned long, char *> sCodes;
+
+                functionCaseStringWorker( hf, sCodes, str, 0, 3 );
+
+                std::map<unsigned long, char *>::iterator i;
+                for( i = sCodes.begin(); i != sCodes.end(); i++ )
+                {
+                        free( (*i).second );
+                }
+        }
+
+        void functionInt()
+        {
+                HashFunctionInt hf;
+
+                for( long i = -100000; i <= 100000; i += 100 )
+                {
+                        TEST_ASSERT( ((long)hf.hash( (void *)i )) == i );
+                        TEST_ASSERT( ((long)hf.cmpIDs( (void *)i, (void *)i )) );
+                }
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        Test::TextOutput output( Test::TextOutput::Verbose );
+        HashFunctionSuite ts;
+        return ts.run( output ) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
diff --git a/src/unit/xml.cpp b/src/unit/xml.cpp
new file mode 100644
index 0000000..559b2f4
--- /dev/null
+++ b/src/unit/xml.cpp
@@ -0,0 +1,43 @@
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <cpptest.h>
+#include <string.h>
+
+#include "xmlstringreader.h"
+#include "xmlexception.h"
+
+class XmlCoreTestSuite : public Test::Suite
+{
+public:
+        XmlCoreTestSuite()
+        {
+                TEST_ADD( XmlCoreTestSuite::badXml01 )
+                TEST_ADD( XmlCoreTestSuite::badXml02 )
+                TEST_ADD( XmlCoreTestSuite::badXml03 )
+        }
+        
+private:
+        void badXml01()
+        {
+                TEST_THROWS( XmlStringReader r("<hello></bye>"), XmlException & );
+        }
+        
+        void badXml02()
+        {
+                TEST_THROWS( XmlStringReader r("<hello>"), XmlException & );
+        }
+
+        void badXml03()
+        {
+                TEST_THROWS( XmlStringReader r("<hello param=\"stuff?"), XmlException & );
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        Test::TextOutput output( Test::TextOutput::Verbose );
+        XmlCoreTestSuite ts;
+        return ts.run( output ) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
diff --git a/src/xmlexception.cpp b/src/xmlexception.cpp
new file mode 100644
index 0000000..7012ee6
--- /dev/null
+++ b/src/xmlexception.cpp
@@ -0,0 +1,27 @@
+#include "xmlexception.h"
+#include <stdarg.h>
+
+XmlException::XmlException( const char *lpFormat, ... ) throw() :
+        Exception( 0 )
+{
+        va_list ap;
+
+        va_start(ap, lpFormat);
+        setWhat( lpFormat, ap );
+        va_end(ap);
+}
+
+XmlException::XmlException( int nCode, const char *lpFormat, ... ) throw() :
+        Exception( nCode )
+{
+        va_list ap;
+
+        va_start(ap, lpFormat);
+        setWhat( lpFormat, ap );
+        va_end(ap);
+}
+
+XmlException::XmlException( int nCode ) throw() :
+        Exception( nCode )
+{
+}
diff --git a/src/xmlexception.h b/src/xmlexception.h
new file mode 100644
index 0000000..9437ba3
--- /dev/null
+++ b/src/xmlexception.h
@@ -0,0 +1,34 @@
+#ifndef XML_EXCEPTION_H
+#define XML_EXCEPTION_H
+
+#include <string>
+#include "exception.h"
+#include <stdarg.h>
+
+/**
+ * A generalized Exception base class.  This is nice for making general and
+ * flexible child classes that can create new error code classes.
+ */
+class XmlException : public Exception
+{
+public:
+        /**
+         * Construct an exception with an error code of zero, but with a
+         * description.  The use of this is not reccomended most of the time, it's
+         * generally best to include an error code with the exception so your
+         * program can handle the exception in a better way.
+         * @param sFormat The format of the text.  See printf for more info.
+         */
+        XmlException( const char *sFormat, ... ) throw();
+        
+        /**
+         * 
+         * @param nCode 
+         * @param sFormat
+         */
+        XmlException( int nCode, const char *sFormat, ... ) throw();
+        
+        XmlException( int nCode=0 ) throw();
+};
+
+#endif
diff --git a/src/xmlfilereader.cpp b/src/xmlfilereader.cpp
index 216c08a..dd4bc82 100644
--- a/src/xmlfilereader.cpp
+++ b/src/xmlfilereader.cpp
@@ -1,4 +1,5 @@
 #include "xmlfilereader.h"
+#include "xmlexception.h"
 #include <string.h>
 
 XmlFileReader::XmlFileReader( const char *sFile, bool bStrip )
@@ -8,7 +9,7 @@ XmlFileReader::XmlFileReader( const char *sFile, bool bStrip )
 
         if( fh == NULL )
         {
-                reportError("Couldn't open file.");
+                throw XmlException("Couldn't open file: %s", sFile );
                 //nError = 1;
         }
         else
@@ -50,7 +51,7 @@ char XmlFileReader::getChar( int nIndex )
         }
         else
         {
-                return '\0';
+                throw XmlException("End of XML stream read.");
         }
 }
 
diff --git a/src/xmlreader.cpp b/src/xmlreader.cpp
index bb24157..76c6258 100644
--- a/src/xmlreader.cpp
+++ b/src/xmlreader.cpp
@@ -1,10 +1,10 @@
 #include "xmlreader.h"
+#include "xmlexception.h"
 #include <string.h>
 
-XmlReader::XmlReader( bool bStrip )
+XmlReader::XmlReader( bool bStrip ) :
+        bStrip( bStrip )
 {
-        nError = 0;
-        this->bStrip = bStrip;
 }
 
 XmlReader::~XmlReader()
@@ -68,13 +68,12 @@ bool XmlReader::node()
                 }
                 else
                 {
-                        reportError("Close node in singleNode malformed!");
-                        return false;
+                        throw XmlException("Close node in singleNode malformed!");
                 }
         }
         else
         {
-                reportError("Close node expected, but not found.");
+                throw XmlException("Close node expected, but not found.");
                 return false;
         }
 
@@ -108,8 +107,7 @@ bool XmlReader::startNode()
                                         }
                                         else
                                         {
-                                                reportError("Got a mismatched node close tag.");
-                                                return false;
+                                                throw XmlException("Got a mismatched node close tag.");
                                         }
                                 }
                                 else
@@ -127,8 +125,7 @@ bool XmlReader::startNode()
                         }
                         else
                         {
-                                reportError("Got extra junk data instead of node close tag.");
-                                return false;
+                                throw XmlException("Got extra junk data instead of node close tag.");
                         }
                 }
                 else
@@ -146,8 +143,7 @@ bool XmlReader::startNode()
         }
         else
         {
-                reportError("Expected to find node opening char, '<'.\n");
-                return false;
+                throw XmlException("Expected to find node opening char, '<'.");
         }
 
         return true;
@@ -306,7 +302,7 @@ bool XmlReader::param()
         }
         else
         {
-                reportError("Expected an equals to seperate the params.");
+                throw XmlException("Expected an equals to seperate the params.");
                 return false;
         }
 
@@ -352,8 +348,7 @@ bool XmlReader::content()
                                                 }
                                                 else
                                                 {
-                                                        reportError("Mismatched close tag found.");
-                                                        return false;
+                                                        throw XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName(), fbName.getData() );
                                                 }
                                         }
                                         else
@@ -370,8 +365,7 @@ bool XmlReader::content()
                                 }
                                 else
                                 {
-                                        reportError("Malformed close tag.");
-                                        return false;
+                                        throw XmlException("Malformed close tag.");
                                 }
                         }
                         else
@@ -400,13 +394,3 @@ bool XmlReader::content()
         }
 }
 
-void XmlReader::reportError( const char *sError )
-{
-        printf("XmlReader error: %s\n", sError );
-}
-
-int XmlReader::getError()
-{
-        return nError;
-}
-
diff --git a/src/xmlreader.h b/src/xmlreader.h
index a8a81f0..19e485a 100644
--- a/src/xmlreader.h
+++ b/src/xmlreader.h
@@ -38,19 +38,6 @@ public:
         ~XmlReader();
 
         /**
-         * Get the error code if an error happened.
-         *@returns The error code (I don't know what they are either)
-         */
-        int getError();
-
-        /**
-         * Report an error to something, this is a really strange mechanism and
-         * should probably just be replaced with the multi-log system.
-         *@param sError The error to report.
-         */
-        void reportError( const char *sError );
-
-        /**
          * Build a document based on some kind of input.  This is called
          * automatically by the constructor.
          */
@@ -127,7 +114,6 @@ private:
         FlexBuf fbParamName;    /**< buffer for the current param's name. */
         FlexBuf fbParamValue;   /**< buffer for the current param's value. */
         bool bStrip;    /**< Are we stripping whitespace? */
-        int nError;             /**< Is there an error? */
 };
 
 #endif
diff --git a/src/xmlstringreader.cpp b/src/xmlstringreader.cpp
index aa7174f..82caacd 100644
--- a/src/xmlstringreader.cpp
+++ b/src/xmlstringreader.cpp
@@ -1,4 +1,5 @@
 #include "xmlstringreader.h"
+#include "xmlexception.h"
 #include <string.h>
 
 XmlStringReader::XmlStringReader( const char *sString, bool bStrip )
@@ -24,7 +25,7 @@ char XmlStringReader::getChar( int nAdd )
         }
         else
         {
-                return '\0';
+                throw XmlException("End of XML stream read.");
         }
 }