Moved other FIFOBuffer tests to BasicFIFOBufferTest

Foundation/testsuite/src/BasicFIFOBufferTest.cpp

@@ -13,6 +13,9 @@
 #include "BasicFIFOBufferTest.h"
 #include "CppUnit/TestCaller.h"
 #include "CppUnit/TestSuite.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include "Poco/Delegate.h"
 #include "Poco/FIFOBuffer.h"
 #include <iostream>
 #include <memory>
@@ -20,6 +23,10 @@
 
 // NOTE: using for certain namespace
 using Poco::BasicFIFOBuffer;
+using Poco::FIFOBuffer;
+using Poco::Buffer;
+using Poco::InvalidAccessException;
+using Poco::delegate;
 using std::memcpy;
 
 BasicFIFOBufferTest::BasicFIFOBufferTest(const std::string& name): CppUnit::TestCase(name)
@@ -31,6 +38,18 @@ BasicFIFOBufferTest::~BasicFIFOBufferTest()
 {
 }
 
+void BasicFIFOBufferTest::onReadable(bool& b)
+{
+	if (b) ++_notToReadable;
+	else ++_readableToNot;
+};
+
+
+void BasicFIFOBufferTest::onWritable(bool& b)
+{
+	if (b) ++_notToWritable;
+	else ++_writableToNot;
+}
 
 void BasicFIFOBufferTest::testNextWrite()
 {
@@ -55,16 +74,593 @@ void BasicFIFOBufferTest::testNextWrite()
 	buffer.peek(c_buffer, buffer.used());
 
 	assert(std::string("Quick Brown Dog Jumps Over The Lazy Fox.The ") == std::string(c_buffer, buffer.used()));
+}
 
-	/*
-	std::istringstream istr("foo");
-	std::ostringstream ostr;
-	TeeInputStream tis(istr);
-	tis.addStream(ostr);
-	std::string s;
-	tis >> s;
-	assert (ostr.str() == "foo");
-	*/
+
+void BasicFIFOBufferTest::testEOFAndError()
+{
+	typedef FIFOBuffer::Type T;
+
+	FIFOBuffer f(20, true);
+	
+	assert (f.isEmpty());
+	assert (!f.isFull());
+
+	Buffer<T> b(10);
+	std::vector<T> v;
+
+	f.readable += delegate(this, &BasicFIFOBufferTest::onReadable);
+	f.writable += delegate(this, &BasicFIFOBufferTest::onWritable);
+
+	for (T c = '0'; c < '0' +  10; ++c)
+		v.push_back(c);
+
+	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
+	assert(0 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert (10 == f.write(b));
+	assert(1 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert (20 == f.size());
+	assert (10 == f.used());
+	assert (!f.isEmpty());
+	f.setEOF();
+	assert(0 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert (f.hasEOF());
+	assert (!f.isEOF());
+	assert(1 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert (20 == f.size());
+	assert (10 == f.used());
+	assert (0 == f.write(b));
+	assert (!f.isEmpty());
+	assert (5 == f.read(b, 5));
+	assert(1 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert (f.hasEOF());
+	assert (!f.isEOF());
+	assert (5 == f.read(b, 5));
+	assert(1 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert (f.hasEOF());
+	assert (f.isEOF());
+	assert(0 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	f.setEOF(false);
+	assert (!f.hasEOF());
+	assert (!f.isEOF());
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert(1 == _notToReadable);
+	assert(1 == _readableToNot);
+
+	assert (5 == f.write(b));
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert(2 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert (20 == f.size());
+	assert (5 == f.used());
+	f.setError();
+	assert (0 == f.write(b));
+	
+	try
+	{
+		f.copy(b.begin(), 5);
+		fail ("must throw InvalidAccessException");
+	}
+	catch (InvalidAccessException&) { }
+
+	try
+	{
+		f.advance(5);
+		fail ("must throw InvalidAccessException");
+	}
+	catch (InvalidAccessException&) { }
+	
+	assert(1 == _notToWritable);
+	assert(2 == _writableToNot);
+	assert(2 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert (20 == f.size());
+	assert (0 == f.used());
+	f.setError(false);
+	assert(2 == _notToWritable);
+	assert(2 == _writableToNot);
+	assert(2 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert (20 == f.size());
+	assert (0 == f.used());
+	assert (5 == f.write(b));
+	assert(2 == _notToWritable);
+	assert(2 == _writableToNot);
+	assert(3 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert (20 == f.size());
+	assert (5 == f.used());
+}
+
+
+void BasicFIFOBufferTest::testChar()
+{
+	typedef FIFOBuffer::Type T;
+
+	FIFOBuffer f(20, true);
+	
+	assert (f.isEmpty());
+	assert (!f.isFull());
+
+	Buffer<T> b(10);
+	std::vector<T> v;
+
+	f.readable += delegate(this, &BasicFIFOBufferTest::onReadable);
+	f.writable += delegate(this, &BasicFIFOBufferTest::onWritable);
+
+	for (T c = '0'; c < '0' +  10; ++c)
+		v.push_back(c);
+
+	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
+	assert(0 == _notToReadable);
+	assert(0 == _readableToNot);
+	f.write(b);
+	assert(1 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert (20 == f.size());
+	assert (10 == f.used());
+	assert (!f.isEmpty());
+	assert ('0' == f[0]);
+	assert ('1' == f[1]);
+	assert ('2' == f[2]);
+	assert ('3' == f[3]);
+	assert ('4' == f[4]);
+	assert ('5' == f[5]);
+	assert ('6' == f[6]);
+	assert ('7' == f[7]);
+	assert ('8' == f[8]);
+	assert ('9' == f[9]);
+
+	b.resize(5);
+	f.read(b, b.size());
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert ('5' == f[0]);
+	assert ('6' == f[1]);
+	assert ('7' == f[2]);
+	assert ('8' == f[3]);
+	assert ('9' == f[4]);
+	try { T i = f[10]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	v.clear();
+	for (T c = 'a'; c < 'a' + 10; ++c)
+		v.push_back(c);
+
+	b.resize(10);
+	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
+	f.write(b);
+	assert (20 == f.size());
+	assert (15 == f.used());
+	assert (!f.isEmpty());
+	assert ('5' == f[0]);
+	assert ('6' == f[1]);
+	assert ('7' == f[2]);
+	assert ('8' == f[3]);
+	assert ('9' == f[4]);
+	assert ('a' == f[5]);
+	assert ('b' == f[6]);
+	assert ('c' == f[7]);
+	assert ('d' == f[8]);
+	assert ('e' == f[9]);
+	assert ('f' == f[10]);
+	assert ('g' == f[11]);
+	assert ('h' == f[12]);
+	assert ('i' == f[13]);
+	assert ('j' == f[14]);
+	try { T i = f[15]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	f.read(b, 10);
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert ('f' == f[0]);
+	assert ('g' == f[1]);
+	assert ('h' == f[2]);
+	assert ('i' == f[3]);
+	assert ('j' == f[4]);
+	try { T i = f[5]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	assert(1 == _notToReadable);
+	assert(0 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+	f.read(b, 6);
+	assert(1 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+
+	assert (5 == b.size());
+	assert (20 == f.size());
+	assert (0 == f.used());
+	try { T i = f[0]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+	assert (f.isEmpty());
+
+	assert(1 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+	assert (5 == f.write(b));
+	assert(2 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert ('f' == f[0]);
+	assert ('g' == f[1]);
+	assert ('h' == f[2]);
+	assert ('i' == f[3]);
+	assert ('j' == f[4]);
+
+	f.resize(10);
+	assert (10 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert ('f' == f[0]);
+	assert ('g' == f[1]);
+	assert ('h' == f[2]);
+	assert ('i' == f[3]);
+	assert ('j' == f[4]);
+
+	assert(2 == _notToReadable);
+	assert(1 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+	f.resize(3, false);
+	assert(2 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+	assert (3 == f.size());
+	assert (0 == f.used());
+	assert (f.isEmpty());
+
+	b.resize(3);
+	b[0] = 'x';
+	b[1] = 'y';
+	b[2] = 'z';
+	f.resize(3);
+
+	assert(2 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(0 == _writableToNot);
+	f.write(b);
+	assert(3 == _notToReadable);
+	assert(2 == _readableToNot);
+	assert(0 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert (f.isFull());
+
+	f.read(b);
+	assert(3 == _notToReadable);
+	assert(3 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert (f.isEmpty());
+
+	f.resize(10);
+	assert (10 == f.size());
+	assert (0 == f.used());
+	assert (10 == f.available());
+	assert (f.isEmpty());
+
+	assert(3 == _notToReadable);
+	assert(3 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+	f.write(b);
+	assert(4 == _notToReadable);
+	assert(3 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (10 == f.size());
+	assert (3 == f.used());
+	assert (7 == f.available());
+	assert (!f.isEmpty());
+
+	f.drain(1);
+	assert(4 == _notToReadable);
+	assert(3 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (10 == f.size());
+	assert (2 == f.used());
+	assert (8 == f.available());
+	assert (!f.isEmpty());
+
+	f.drain(2);
+	assert(4 == _notToReadable);
+	assert(4 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (10 == f.size());
+	assert (0 == f.used());
+	assert (10 == f.available());
+	assert (f.isEmpty());
+
+	f.write(b);
+	assert(5 == _notToReadable);
+	assert(4 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (10 == f.size());
+	assert (3 == f.used());
+	assert (7 == f.available());
+	assert (!f.isEmpty());
+
+	f.drain();
+	assert(5 == _notToReadable);
+	assert(5 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+	assert (10 == f.size());
+	assert (0 == f.used());
+	assert (10 == f.available());
+	assert (f.isEmpty());
+
+	f.write(b, 2);
+	assert (10 == f.size());
+	assert (2 == f.used());
+	assert (8 == f.available());
+	assert (!f.isEmpty());
+
+	assert(6 == _notToReadable);
+	assert(5 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	f.drain();
+	assert(6 == _notToReadable);
+	assert(6 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (3 == f.write(b, 10));
+	assert (10 == f.size());
+	assert (3 == f.used());
+	assert (7 == f.available());
+	assert (!f.isEmpty());
+
+	assert(7 == _notToReadable);
+	assert(6 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	const char arr[3] = {'4', '5', '6' };
+	try
+	{
+		f.copy(&arr[0], 8);
+		fail("must fail");
+	} catch (InvalidAccessException&) { }
+
+	f.copy(&arr[0], 3);
+	assert(7 == _notToReadable);
+	assert(6 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(1 == _writableToNot);
+
+	assert (10 == f.size());
+	assert (6 == f.used());
+	assert (4 == f.available());
+
+	f.copy(&arr[0], 4);
+	assert(7 == _notToReadable);
+	assert(6 == _readableToNot);
+	assert(1 == _notToWritable);
+	assert(2 == _writableToNot);
+	assert (f.isFull());
+
+	assert (10 == f.size());
+	assert (10 == f.used());
+	assert (0 == f.available());
+
+	try
+	{
+		f.copy(&arr[0], 1);
+		fail("must fail");
+	} catch (InvalidAccessException&) { }
+
+	f.drain(1);
+	assert(7 == _notToReadable);
+	assert(6 == _readableToNot);
+	assert(2 == _notToWritable);
+	assert(2 == _writableToNot);
+
+	f.drain(9);
+	assert (10 == f.size());
+	assert (0 == f.used());
+	assert (10 == f.available());
+
+	const char e[10] = { '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
+	f.copy(&e[0], 10);
+	assert (10 == f.size());
+	assert (10 == f.used());
+	assert (0 == f.available());
+	f.drain(1);
+	f.write(e, 1);
+	assert (10 == f.size());
+	assert (10 == f.used());
+	assert (0 == f.available());
+	
+	assert(f[0] == '2');
+	assert(f[1] == '3');
+	assert(f[2] == '4');
+	assert(f[3] == '5');
+	assert(f[4] == '6');
+	assert(f[5] == '7');
+	assert(f[6] == '8');
+	assert(f[7] == '9');
+	assert(f[8] == '0');
+	assert(f[9] == '1');
+
+	f.readable -= delegate(this, &BasicFIFOBufferTest::onReadable);
+	f.writable -= delegate(this, &BasicFIFOBufferTest::onReadable);
+}
+
+
+void BasicFIFOBufferTest::testInt()
+{
+	typedef int T;
+
+	BasicFIFOBuffer<T> f(20);
+	Buffer<T> b(10);
+	std::vector<T> v;
+
+	for (T c = 0; c < 10; ++c)
+		v.push_back(c);
+
+	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
+	f.write(b);
+	assert (20 == f.size());
+	assert (10 == f.used());
+	assert (!f.isEmpty());
+	assert (0 == f[0]);
+	assert (1 == f[1]);
+	assert (2 == f[2]);
+	assert (3 == f[3]);
+	assert (4 == f[4]);
+	assert (5 == f[5]);
+	assert (6 == f[6]);
+	assert (7 == f[7]);
+	assert (8 == f[8]);
+	assert (9 == f[9]);
+
+	b.resize(5);
+	f.read(b, b.size());
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert (5 == f[0]);
+	assert (6 == f[1]);
+	assert (7 == f[2]);
+	assert (8 == f[3]);
+	assert (9 == f[4]);
+	try { T i = f[10]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	v.clear();
+	for (T c = 10; c < 20; ++c)
+		v.push_back(c);
+
+	b.resize(10);
+	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
+	f.write(b);
+	assert (20 == f.size());
+	assert (15 == f.used());
+	assert (!f.isEmpty());
+	assert (5 == f[0]);
+	assert (6 == f[1]);
+	assert (7 == f[2]);
+	assert (8 == f[3]);
+	assert (9 == f[4]);
+	assert (10 == f[5]);
+	assert (11 == f[6]);
+	assert (12 == f[7]);
+	assert (13 == f[8]);
+	assert (14 == f[9]);
+	assert (15 == f[10]);
+	assert (16 == f[11]);
+	assert (17 == f[12]);
+	assert (18 == f[13]);
+	assert (19 == f[14]);
+	try { T i = f[15]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	f.read(b, 10);
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert (15 == f[0]);
+	assert (16 == f[1]);
+	assert (17 == f[2]);
+	assert (18 == f[3]);
+	assert (19 == f[4]);
+	try { T i = f[5]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	f.read(b, 6);
+	assert (5 == b.size());
+	assert (20 == f.size());
+	assert (0 == f.used());
+	try { T i = f[0]; fail ("must fail"); }
+	catch (InvalidAccessException&) { }
+
+	assert (f.isEmpty());
+
+	assert (5 == f.write(b));
+	assert (20 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert (15 == f[0]);
+	assert (16 == f[1]);
+	assert (17 == f[2]);
+	assert (18 == f[3]);
+	assert (19 == f[4]);
+
+	f.resize(10);
+	assert (10 == f.size());
+	assert (5 == f.used());
+	assert (!f.isEmpty());
+	assert (15 == f[0]);
+	assert (16 == f[1]);
+	assert (17 == f[2]);
+	assert (18 == f[3]);
+	assert(19 == f[4]);
+
+	f.drain(9);
+	assert(10 == f.size());
+	assert(0 == f.used());
+	assert(10 == f.available());
+
+	const int e[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
+	f.copy(&e[0], 10);
+	assert(10 == f.size());
+	assert(10 == f.used());
+	assert(0 == f.available());
+	f.drain(1);
+	f.write(e, 1);
+	assert(10 == f.size());
+	assert(10 == f.used());
+	assert(0 == f.available());
+
+	assert(f[0] == 2);
+	assert(f[1] == 3);
+	assert(f[2] == 4);
+	assert(f[3] == 5);
+	assert(f[4] == 6);
+	assert(f[5] == 7);
+	assert(f[6] == 8);
+	assert(f[7] == 9);
+	assert(f[8] == 0);
+	assert(f[9] == 1);
+
+	f.resize(3, false);
+	assert (3 == f.size());
+	assert (0 == f.used());
+	assert (f.isEmpty());
 }
 
 void BasicFIFOBufferTest::setUp()
@@ -82,6 +678,9 @@ CppUnit::Test* BasicFIFOBufferTest::suite()
 	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("BasicFIFOBufferTest");
 
 	CppUnit_addTest(pSuite, BasicFIFOBufferTest, testNextWrite);
+	CppUnit_addTest(pSuite, BasicFIFOBufferTest, testChar);
+	CppUnit_addTest(pSuite, BasicFIFOBufferTest, testInt);
+	CppUnit_addTest(pSuite, BasicFIFOBufferTest, testEOFAndError);
 
 	return pSuite;
 }

Foundation/testsuite/src/BasicFIFOBufferTest.h

@@ -27,13 +27,24 @@ public:
 	~BasicFIFOBufferTest();
 
 	void testNextWrite();
+	void testChar();
+	void testInt();
+	void testEOFAndError();
 
 	void setUp();
 	void tearDown();
 
 	static CppUnit::Test* suite();
 
+protected:
+	void onReadable(bool& b);
+	void onWritable(bool& b);
+
 private:
+	int _notToReadable;
+	int _notToWritable;
+	int _readableToNot;
+	int _writableToNot;
 };
 
 

Foundation/testsuite/src/CoreTest.cpp

@@ -39,8 +39,6 @@ using Poco::Environment;
 using Poco::Thread;
 using Poco::Runnable;
 using Poco::Buffer;
-using Poco::BasicFIFOBuffer;
-using Poco::FIFOBuffer;
 using Poco::AtomicCounter;
 using Poco::Nullable;
 using Poco::Ascii;
@@ -319,591 +317,6 @@ void CoreTest::testBuffer()
 }
 
 
-void CoreTest::testFIFOBufferEOFAndError()
-{
-	typedef FIFOBuffer::Type T;
-
-	FIFOBuffer f(20, true);
-	
-	assert (f.isEmpty());
-	assert (!f.isFull());
-
-	Buffer<T> b(10);
-	std::vector<T> v;
-
-	f.readable += delegate(this, &CoreTest::onReadable);
-	f.writable += delegate(this, &CoreTest::onWritable);
-
-	for (T c = '0'; c < '0' +  10; ++c)
-		v.push_back(c);
-
-	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
-	assert(0 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert (10 == f.write(b));
-	assert(1 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert (20 == f.size());
-	assert (10 == f.used());
-	assert (!f.isEmpty());
-	f.setEOF();
-	assert(0 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert (f.hasEOF());
-	assert (!f.isEOF());
-	assert(1 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert (20 == f.size());
-	assert (10 == f.used());
-	assert (0 == f.write(b));
-	assert (!f.isEmpty());
-	assert (5 == f.read(b, 5));
-	assert(1 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert (f.hasEOF());
-	assert (!f.isEOF());
-	assert (5 == f.read(b, 5));
-	assert(1 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert (f.hasEOF());
-	assert (f.isEOF());
-	assert(0 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	f.setEOF(false);
-	assert (!f.hasEOF());
-	assert (!f.isEOF());
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert(1 == _notToReadable);
-	assert(1 == _readableToNot);
-
-	assert (5 == f.write(b));
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert(2 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert (20 == f.size());
-	assert (5 == f.used());
-	f.setError();
-	assert (0 == f.write(b));
-	
-	try
-	{
-		f.copy(b.begin(), 5);
-		fail ("must throw InvalidAccessException");
-	}
-	catch (InvalidAccessException&) { }
-
-	try
-	{
-		f.advance(5);
-		fail ("must throw InvalidAccessException");
-	}
-	catch (InvalidAccessException&) { }
-	
-	assert(1 == _notToWritable);
-	assert(2 == _writableToNot);
-	assert(2 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert (20 == f.size());
-	assert (0 == f.used());
-	f.setError(false);
-	assert(2 == _notToWritable);
-	assert(2 == _writableToNot);
-	assert(2 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert (20 == f.size());
-	assert (0 == f.used());
-	assert (5 == f.write(b));
-	assert(2 == _notToWritable);
-	assert(2 == _writableToNot);
-	assert(3 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert (20 == f.size());
-	assert (5 == f.used());
-}
-
-
-void CoreTest::testFIFOBufferChar()
-{
-	typedef FIFOBuffer::Type T;
-
-	FIFOBuffer f(20, true);
-	
-	assert (f.isEmpty());
-	assert (!f.isFull());
-
-	Buffer<T> b(10);
-	std::vector<T> v;
-
-	f.readable += delegate(this, &CoreTest::onReadable);
-	f.writable += delegate(this, &CoreTest::onWritable);
-
-	for (T c = '0'; c < '0' +  10; ++c)
-		v.push_back(c);
-
-	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
-	assert(0 == _notToReadable);
-	assert(0 == _readableToNot);
-	f.write(b);
-	assert(1 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert (20 == f.size());
-	assert (10 == f.used());
-	assert (!f.isEmpty());
-	assert ('0' == f[0]);
-	assert ('1' == f[1]);
-	assert ('2' == f[2]);
-	assert ('3' == f[3]);
-	assert ('4' == f[4]);
-	assert ('5' == f[5]);
-	assert ('6' == f[6]);
-	assert ('7' == f[7]);
-	assert ('8' == f[8]);
-	assert ('9' == f[9]);
-
-	b.resize(5);
-	f.read(b, b.size());
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert ('5' == f[0]);
-	assert ('6' == f[1]);
-	assert ('7' == f[2]);
-	assert ('8' == f[3]);
-	assert ('9' == f[4]);
-	try { T i = f[10]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	v.clear();
-	for (T c = 'a'; c < 'a' + 10; ++c)
-		v.push_back(c);
-
-	b.resize(10);
-	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
-	f.write(b);
-	assert (20 == f.size());
-	assert (15 == f.used());
-	assert (!f.isEmpty());
-	assert ('5' == f[0]);
-	assert ('6' == f[1]);
-	assert ('7' == f[2]);
-	assert ('8' == f[3]);
-	assert ('9' == f[4]);
-	assert ('a' == f[5]);
-	assert ('b' == f[6]);
-	assert ('c' == f[7]);
-	assert ('d' == f[8]);
-	assert ('e' == f[9]);
-	assert ('f' == f[10]);
-	assert ('g' == f[11]);
-	assert ('h' == f[12]);
-	assert ('i' == f[13]);
-	assert ('j' == f[14]);
-	try { T i = f[15]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	f.read(b, 10);
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert ('f' == f[0]);
-	assert ('g' == f[1]);
-	assert ('h' == f[2]);
-	assert ('i' == f[3]);
-	assert ('j' == f[4]);
-	try { T i = f[5]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	assert(1 == _notToReadable);
-	assert(0 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-	f.read(b, 6);
-	assert(1 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-
-	assert (5 == b.size());
-	assert (20 == f.size());
-	assert (0 == f.used());
-	try { T i = f[0]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-	assert (f.isEmpty());
-
-	assert(1 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-	assert (5 == f.write(b));
-	assert(2 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert ('f' == f[0]);
-	assert ('g' == f[1]);
-	assert ('h' == f[2]);
-	assert ('i' == f[3]);
-	assert ('j' == f[4]);
-
-	f.resize(10);
-	assert (10 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert ('f' == f[0]);
-	assert ('g' == f[1]);
-	assert ('h' == f[2]);
-	assert ('i' == f[3]);
-	assert ('j' == f[4]);
-
-	assert(2 == _notToReadable);
-	assert(1 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-	f.resize(3, false);
-	assert(2 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-	assert (3 == f.size());
-	assert (0 == f.used());
-	assert (f.isEmpty());
-
-	b.resize(3);
-	b[0] = 'x';
-	b[1] = 'y';
-	b[2] = 'z';
-	f.resize(3);
-
-	assert(2 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(0 == _writableToNot);
-	f.write(b);
-	assert(3 == _notToReadable);
-	assert(2 == _readableToNot);
-	assert(0 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert (f.isFull());
-
-	f.read(b);
-	assert(3 == _notToReadable);
-	assert(3 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert (f.isEmpty());
-
-	f.resize(10);
-	assert (10 == f.size());
-	assert (0 == f.used());
-	assert (10 == f.available());
-	assert (f.isEmpty());
-
-	assert(3 == _notToReadable);
-	assert(3 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-	f.write(b);
-	assert(4 == _notToReadable);
-	assert(3 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (10 == f.size());
-	assert (3 == f.used());
-	assert (7 == f.available());
-	assert (!f.isEmpty());
-
-	f.drain(1);
-	assert(4 == _notToReadable);
-	assert(3 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (10 == f.size());
-	assert (2 == f.used());
-	assert (8 == f.available());
-	assert (!f.isEmpty());
-
-	f.drain(2);
-	assert(4 == _notToReadable);
-	assert(4 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (10 == f.size());
-	assert (0 == f.used());
-	assert (10 == f.available());
-	assert (f.isEmpty());
-
-	f.write(b);
-	assert(5 == _notToReadable);
-	assert(4 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (10 == f.size());
-	assert (3 == f.used());
-	assert (7 == f.available());
-	assert (!f.isEmpty());
-
-	f.drain();
-	assert(5 == _notToReadable);
-	assert(5 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-	assert (10 == f.size());
-	assert (0 == f.used());
-	assert (10 == f.available());
-	assert (f.isEmpty());
-
-	f.write(b, 2);
-	assert (10 == f.size());
-	assert (2 == f.used());
-	assert (8 == f.available());
-	assert (!f.isEmpty());
-
-	assert(6 == _notToReadable);
-	assert(5 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	f.drain();
-	assert(6 == _notToReadable);
-	assert(6 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (3 == f.write(b, 10));
-	assert (10 == f.size());
-	assert (3 == f.used());
-	assert (7 == f.available());
-	assert (!f.isEmpty());
-
-	assert(7 == _notToReadable);
-	assert(6 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	const char arr[3] = {'4', '5', '6' };
-	try
-	{
-		f.copy(&arr[0], 8);
-		fail("must fail");
-	} catch (InvalidAccessException&) { }
-
-	f.copy(&arr[0], 3);
-	assert(7 == _notToReadable);
-	assert(6 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(1 == _writableToNot);
-
-	assert (10 == f.size());
-	assert (6 == f.used());
-	assert (4 == f.available());
-
-	f.copy(&arr[0], 4);
-	assert(7 == _notToReadable);
-	assert(6 == _readableToNot);
-	assert(1 == _notToWritable);
-	assert(2 == _writableToNot);
-	assert (f.isFull());
-
-	assert (10 == f.size());
-	assert (10 == f.used());
-	assert (0 == f.available());
-
-	try
-	{
-		f.copy(&arr[0], 1);
-		fail("must fail");
-	} catch (InvalidAccessException&) { }
-
-	f.drain(1);
-	assert(7 == _notToReadable);
-	assert(6 == _readableToNot);
-	assert(2 == _notToWritable);
-	assert(2 == _writableToNot);
-
-	f.drain(9);
-	assert (10 == f.size());
-	assert (0 == f.used());
-	assert (10 == f.available());
-
-	const char e[10] = { '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
-	f.copy(&e[0], 10);
-	assert (10 == f.size());
-	assert (10 == f.used());
-	assert (0 == f.available());
-	f.drain(1);
-	f.write(e, 1);
-	assert (10 == f.size());
-	assert (10 == f.used());
-	assert (0 == f.available());
-	
-	assert(f[0] == '2');
-	assert(f[1] == '3');
-	assert(f[2] == '4');
-	assert(f[3] == '5');
-	assert(f[4] == '6');
-	assert(f[5] == '7');
-	assert(f[6] == '8');
-	assert(f[7] == '9');
-	assert(f[8] == '0');
-	assert(f[9] == '1');
-
-	f.readable -= delegate(this, &CoreTest::onReadable);
-	f.writable -= delegate(this, &CoreTest::onReadable);
-}
-
-
-void CoreTest::testFIFOBufferInt()
-{
-	typedef int T;
-
-	BasicFIFOBuffer<T> f(20);
-	Buffer<T> b(10);
-	std::vector<T> v;
-
-	for (T c = 0; c < 10; ++c)
-		v.push_back(c);
-
-	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
-	f.write(b);
-	assert (20 == f.size());
-	assert (10 == f.used());
-	assert (!f.isEmpty());
-	assert (0 == f[0]);
-	assert (1 == f[1]);
-	assert (2 == f[2]);
-	assert (3 == f[3]);
-	assert (4 == f[4]);
-	assert (5 == f[5]);
-	assert (6 == f[6]);
-	assert (7 == f[7]);
-	assert (8 == f[8]);
-	assert (9 == f[9]);
-
-	b.resize(5);
-	f.read(b, b.size());
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert (5 == f[0]);
-	assert (6 == f[1]);
-	assert (7 == f[2]);
-	assert (8 == f[3]);
-	assert (9 == f[4]);
-	try { T i = f[10]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	v.clear();
-	for (T c = 10; c < 20; ++c)
-		v.push_back(c);
-
-	b.resize(10);
-	std::memcpy(b.begin(), &v[0], sizeof(T) * v.size());
-	f.write(b);
-	assert (20 == f.size());
-	assert (15 == f.used());
-	assert (!f.isEmpty());
-	assert (5 == f[0]);
-	assert (6 == f[1]);
-	assert (7 == f[2]);
-	assert (8 == f[3]);
-	assert (9 == f[4]);
-	assert (10 == f[5]);
-	assert (11 == f[6]);
-	assert (12 == f[7]);
-	assert (13 == f[8]);
-	assert (14 == f[9]);
-	assert (15 == f[10]);
-	assert (16 == f[11]);
-	assert (17 == f[12]);
-	assert (18 == f[13]);
-	assert (19 == f[14]);
-	try { T i = f[15]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	f.read(b, 10);
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert (15 == f[0]);
-	assert (16 == f[1]);
-	assert (17 == f[2]);
-	assert (18 == f[3]);
-	assert (19 == f[4]);
-	try { T i = f[5]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	f.read(b, 6);
-	assert (5 == b.size());
-	assert (20 == f.size());
-	assert (0 == f.used());
-	try { T i = f[0]; fail ("must fail"); }
-	catch (InvalidAccessException&) { }
-
-	assert (f.isEmpty());
-
-	assert (5 == f.write(b));
-	assert (20 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert (15 == f[0]);
-	assert (16 == f[1]);
-	assert (17 == f[2]);
-	assert (18 == f[3]);
-	assert (19 == f[4]);
-
-	f.resize(10);
-	assert (10 == f.size());
-	assert (5 == f.used());
-	assert (!f.isEmpty());
-	assert (15 == f[0]);
-	assert (16 == f[1]);
-	assert (17 == f[2]);
-	assert (18 == f[3]);
-	assert(19 == f[4]);
-
-	f.drain(9);
-	assert(10 == f.size());
-	assert(0 == f.used());
-	assert(10 == f.available());
-
-	const int e[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
-	f.copy(&e[0], 10);
-	assert(10 == f.size());
-	assert(10 == f.used());
-	assert(0 == f.available());
-	f.drain(1);
-	f.write(e, 1);
-	assert(10 == f.size());
-	assert(10 == f.used());
-	assert(0 == f.available());
-
-	assert(f[0] == 2);
-	assert(f[1] == 3);
-	assert(f[2] == 4);
-	assert(f[3] == 5);
-	assert(f[4] == 6);
-	assert(f[5] == 7);
-	assert(f[6] == 8);
-	assert(f[7] == 9);
-	assert(f[8] == 0);
-	assert(f[9] == 1);
-
-	f.resize(3, false);
-	assert (3 == f.size());
-	assert (0 == f.used());
-	assert (f.isEmpty());
-}
 
 
 void CoreTest::testAtomicCounter()
@@ -1121,19 +534,6 @@ void CoreTest::testAscii()
 }
 
 
-void CoreTest::onReadable(bool& b)
-{
-	if (b) ++_notToReadable;
-	else ++_readableToNot;
-};
-
-
-void CoreTest::onWritable(bool& b)
-{
-	if (b) ++_notToWritable;
-	else ++_writableToNot;
-}
-
 
 void CoreTest::setUp()
 {
@@ -1158,9 +558,6 @@ CppUnit::Test* CoreTest::suite()
 	CppUnit_addTest(pSuite, CoreTest, testBugcheck);
 	CppUnit_addTest(pSuite, CoreTest, testEnvironment);
 	CppUnit_addTest(pSuite, CoreTest, testBuffer);
-	CppUnit_addTest(pSuite, CoreTest, testFIFOBufferChar);
-	CppUnit_addTest(pSuite, CoreTest, testFIFOBufferInt);
-	CppUnit_addTest(pSuite, CoreTest, testFIFOBufferEOFAndError);
 	CppUnit_addTest(pSuite, CoreTest, testAtomicCounter);
 	CppUnit_addTest(pSuite, CoreTest, testNullable);
 	CppUnit_addTest(pSuite, CoreTest, testAscii);

Foundation/testsuite/src/CoreTest.h

@@ -32,9 +32,6 @@ public:
 	void testFPE();
 	void testEnvironment();
 	void testBuffer();
-	void testFIFOBufferChar();
-	void testFIFOBufferInt();
-	void testFIFOBufferEOFAndError();
 	void testAtomicCounter();
 	void testNullable();
 	void testAscii();
@@ -45,13 +42,9 @@ public:
 	static CppUnit::Test* suite();
 
 protected:
-	void onReadable(bool& b);
-	void onWritable(bool& b);
-
-private:
 	int _readableToNot;
-	int _notToReadable;
 	int _writableToNot;
+	int _notToReadable;
 	int _notToWritable;
 };