The MemBuf works just fine, although it still can't over-write data in the

buffer.

6 files changed, 113 insertions, 5 deletions

diff --git a/src/membuf.cpp b/src/membuf.cpp
index fdb4366..3c394b0 100644
--- a/src/membuf.cpp
+++ b/src/membuf.cpp
@@ -2,7 +2,8 @@
 
 using namespace Bu;
 
-Bu::MemBuf::MemBuf()
+Bu::MemBuf::MemBuf() :
+        nPos( 0 )
 {
 }
 
@@ -16,35 +17,56 @@ void Bu::MemBuf::close()
 
 size_t Bu::MemBuf::read( void *pBuf, size_t nBytes )
 {
+        if( (size_t)sBuf.getSize()-(size_t)nPos < nBytes )
+                nBytes = sBuf.getSize()-nPos;
 
+        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+        nPos += nBytes;
+
+        return nBytes;
 }
         
 size_t Bu::MemBuf::write( const void *pBuf, size_t nBytes )
 {
+        sBuf.append( (const char *)pBuf, nBytes );
+        nPos += nBytes;
+        return nBytes;
 }
 
 long Bu::MemBuf::tell()
 {
+        return nPos;
 }
 
 void Bu::MemBuf::seek( long offset )
 {
+        nPos += offset;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPos( long pos )
 {
+        nPos = pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPosEnd( long pos )
 {
+        nPos = sBuf.getSize()-pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 bool Bu::MemBuf::isEOS()
 {
+        return (nPos == sBuf.getSize());
 }
 
 bool Bu::MemBuf::isOpen()
 {
+        return true;
 }
 
 void Bu::MemBuf::flush()
@@ -53,26 +75,32 @@ void Bu::MemBuf::flush()
 
 bool Bu::MemBuf::canRead()
 {
+        return !isEOS();
 }
 
 bool Bu::MemBuf::canWrite()
 {
+        return isEOS();
 }
 
 bool Bu::MemBuf::isReadable()
 {
+        return true;
 }
 
 bool Bu::MemBuf::isWritable()
 {
+        return true;
 }
 
 bool Bu::MemBuf::isSeekable()
 {
+        return true;
 }
 
 bool Bu::MemBuf::isBlocking()
 {
+        return true;
 }
 
 void Bu::MemBuf::setBlocking( bool bBlocking )
diff --git a/src/membuf.h b/src/membuf.h
index 2cbbbdc..877b35e 100644
--- a/src/membuf.h
+++ b/src/membuf.h
@@ -4,6 +4,7 @@
 #include <stdint.h>
 
 #include "bu/stream.h"
+#include "bu/fstring.h"
 
 namespace Bu
 {
@@ -18,6 +19,12 @@ namespace Bu
 
                 virtual void close();
                 virtual size_t read( void *pBuf, size_t nBytes );
+
+                /**
+                 *@todo Allow writes at the current position, not just appending to
+                 * the current buffer.  This is a silly way to do it, but it covers all
+                 * of our bases for now.
+                 */
                 virtual size_t write( const void *pBuf, size_t nBytes );
                 virtual long tell();
                 virtual void seek( long offset );
diff --git a/src/unit/entities/unit b/src/unit/entities/unit
new file mode 100644
index 0000000..28db45f
--- /dev/null
+++ b/src/unit/entities/unit
@@ -0,0 +1,30 @@
+<?xml version="1.1" ?>
+<entity desc="Unit test framework">
+        <param name="name" required="yes" desc="Name of the class"/>
+        <file
+                name="source"
+                filename="{=name:%tolower}.cpp"
+>#include "bu/unitsuite.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("{=name}");
+                addTest( Unit::test01 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void test01()
+        {
+                unitTest( 0 == 5 );
+        }
+};
+
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }
+</file>
+</entity>
diff --git a/src/unit/file.cpp b/src/unit/file.cpp
index a45b8d7..1eaaf36 100644
--- a/src/unit/file.cpp
+++ b/src/unit/file.cpp
@@ -87,8 +87,14 @@ public:
                 unitTest( sf.isEOS() == false );
                 try
                 {
-                        sf.read( buf, 5 );
-                        unitFailed("No exception thrown");
+                        if( sf.read( buf, 5 ) > 0 )
+                        {
+                                unitFailed("Non-zero read result");
+                        }
+                        else
+                        {
+                                sf.close();
+                        }
                 }
                 catch( Bu::FileException &e )
                 {
diff --git a/src/unit/hash.cpp b/src/unit/hash.cpp
index 588e687..9ea933f 100644
--- a/src/unit/hash.cpp
+++ b/src/unit/hash.cpp
@@ -1,6 +1,6 @@
 #include "bu/fstring.h"
 #include "bu/hash.h"
-#include "unitsuite.h"
+#include "bu/unitsuite.h"
 
 #include <stdio.h>
 
@@ -23,7 +23,7 @@ public:
         {
                 StrIntHash h;
                 char buf[20];
-                for(int i=0;i<10000;i++)
+                for(int i=1;i<10000;i++)
                 {
                         sprintf(buf,"%d",i);
                         Bu::FString sTmp(buf);
diff --git a/src/unit/membuf.cpp b/src/unit/membuf.cpp
new file mode 100644
index 0000000..65ba82a
--- /dev/null
+++ b/src/unit/membuf.cpp
@@ -0,0 +1,37 @@
+#include "bu/unitsuite.h"
+#include "bu/membuf.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("MemBuf");
+                addTest( Unit::testWriteRead01 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void testWriteRead01()
+        {
+                Bu::MemBuf mb;
+                unitTest( mb.write("ab", 2 ) == 2 );
+                unitTest( mb.write("cde", 3 ) == 3 );
+                unitTest( mb.write("FG", 2 ) == 2 );
+
+                mb.setPos( 0 );
+
+                char buf[8];
+                buf[7] = '\0';
+                unitTest( mb.read( buf, 7 ) == 7 );
+                unitTest( !strncmp( buf, "abcdeFG", 7 ) );
+                unitTest( mb.read( buf, 7 ) == 0 );
+                mb.seek( -3 );
+                unitTest( mb.read( buf, 7 ) == 3 );
+                unitTest( !strncmp( buf, "eFG", 3 ) );
+        }
+};
+
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }