void nta::ArrayTest::testArrayTyping()
{
TestCaseIterator testCase;
for(testCase = testCases_.begin(); testCase != testCases_.end(); testCase++)
{
//testArrayCreation() already validates that ArrayBase objects can't be created
//using invalid NTA_BasicType parameters, so we skip those test cases here
if(testCase->second.testUsesInvalidParameters)
{
continue;
}
ArrayBase a(testCase->second.dataType);
TESTEQUAL2("Test case: " +
testCase->first +
" - the type of a created ArrayBase should match the requested "
"type",
testCase->second.dataType, a.getType());
std::string name(BasicType::getName(a.getType()));
TESTEQUAL2("Test case: " +
testCase->first +
" - the string representation of a type contained in a "
"created ArrayBase should match the expected string",
testCase->second.dataTypeText,
name);
}
}
void TesterTest::RunTestsShouldFail()
{
// These are probably the only tests in our test suite that should fail.
TESTEQUAL2("Integer test, should fail",1,0);
TESTEQUAL2("Double test, should fail",23.42,23.421);
TESTEQUAL2_STR("String test, should fail","Numenta","Numenta ");
TESTEQUAL(1,0);
TESTEQUAL(23.42,23.421);
EXPECT_STREQ("Numenta","Numenta ");
TEST(false);
TEST2("TEST2(false)", false);
}
void FastCLAClassifierTest::testBasic()
{
vector<UInt> steps;
steps.push_back(1);
FastCLAClassifier c = FastCLAClassifier(steps, 0.1, 0.1, 0);
// Create a vector of input bit indices
vector<UInt> input1;
input1.push_back(1);
input1.push_back(5);
input1.push_back(9);
ClassifierResult result1;
c.fastCompute(0, input1, 4, 34.7, false, true, true, &result1);
// Create a vector of input bit indices
vector<UInt> input2;
input2.push_back(1);
input2.push_back(5);
input2.push_back(9);
ClassifierResult result2;
c.fastCompute(1, input2, 4, 34.7, false, true, true, &result2);
{
bool foundMinus1 = false;
bool found1 = false;
for (auto it = result2.begin();
it != result2.end(); ++it)
{
if (it->first == -1)
{
// The -1 key is used for the actual values
TESTEQUAL2("already found key -1 in classifier result",
false, foundMinus1);
foundMinus1 = true;
TESTEQUAL2("Expected five buckets since it has only seen bucket 4 "
"(so it has buckets 0-4).", (long unsigned int)5, it->second->size());
TEST2("Incorrect actual value for bucket 4",
fabs(it->second->at(4) - 34.7) < 0.000001);
} else if (it->first == 1) {
// Check the one-step prediction
TESTEQUAL2("already found key 1 in classifier result", false, found1);
found1 = true;
TESTEQUAL2("expected five bucket predictions", (long unsigned int)5, it->second->size());
TEST2("incorrect prediction for bucket 0",
fabs(it->second->at(0) - 0.2) < 0.000001);
TEST2("incorrect prediction for bucket 1",
fabs(it->second->at(1) - 0.2) < 0.000001);
TEST2("incorrect prediction for bucket 2",
fabs(it->second->at(2) - 0.2) < 0.000001);
TEST2("incorrect prediction for bucket 3",
fabs(it->second->at(3) - 0.2) < 0.000001);
TEST2("incorrect prediction for bucket 4",
fabs(it->second->at(4) - 0.2) < 0.000001);
}
}
TESTEQUAL2("key -1 not found in classifier result", true, foundMinus1);
TESTEQUAL2("key 1 not found in classifier result", true, found1);
}
}
void nta::ArrayTest::testBufferAssignment()
{
TestCaseIterator testCase;
for(testCase = testCases_.begin(); testCase != testCases_.end(); testCase++)
{
boost::scoped_array<char> buf(new char[testCase->second.dataTypeSize *
testCase->second.allocationSize]);
ArrayBase a(testCase->second.dataType);
a.setBuffer(buf.get(), testCase->second.allocationSize);
TESTEQUAL2("Test case: " +
testCase->first +
" - setBuffer() should used the assigned buffer",
buf.get(),
a.getBuffer());
boost::scoped_array<char> buf2(new char[testCase->second.dataTypeSize *
testCase->second.allocationSize]);
bool caughtException = false;
try
{
a.setBuffer(buf2.get(), testCase->second.allocationSize);
}
catch(nta::Exception)
{
caughtException = true;
}
TEST2("Test case: " +
testCase->first +
" - setting a buffer when one is already set should raise an "
"exception",
caughtException);
}
}
// Run all appropriate tests
void TesterTest::RunTests()
{
TESTEQUAL2("Integer test, should succeed",1,1);
TESTEQUAL2("Double test, should succeed",23.42,23.42);
TESTEQUAL2_STR("String test, should succeed","Numenta","Numenta");
// Repeat the above for TESTEQUAL
TESTEQUAL(1,1);
TESTEQUAL(23.42,23.42);
EXPECT_STREQ("Numenta","Numenta");
// Test functions in Common
TESTEQUAL2("Max test", 23.3, Max(23.2, 23.3));
TESTEQUAL2("Min test", 23.2, Min(23.2, 23.3));
TESTEQUAL2("Max test", 'b', Max('a', 'b'));
TESTEQUAL2("Min test", 'a', Min('a', 'b'));
// Repeat the above for TESTEQUAL
TESTEQUAL(23.3, Max(23.2, 23.3));
TESTEQUAL(23.2, Min(23.2, 23.3));
TESTEQUAL('b', Max('a', 'b'));
TESTEQUAL('a', Min('a', 'b'));
// TESTEQUAL_FLOAT allows error less than 0.000001
TESTEQUAL_FLOAT(23.42,23.4200009);
// Tests for TEST
TEST(true);
TEST2("TEST2(true)", true);
// Tests for throws
nupic::LoggingException e(__FILE__, __LINE__);
e << "This exception should be thrown.";
SHOULDFAIL(throw e);
SHOULDFAIL_WITH_MESSAGE(
throw e,
"This exception should be thrown.");
}
void MemStreamTest::RunTests()
{
// -------------------------------------------------------
// Test input stream
// -------------------------------------------------------
{
std::string test("hi there");
IMemStream ms((char*)(test.data()), test.size());
std::stringstream ss(test);
for (int i=0; i<5; i++)
{
std::string s1, s2;
ms >> s1;
ss >> s2;
TESTEQUAL2("in", s2, s1);
TESTEQUAL2("in fail", ss.fail(), ms.fail());
TESTEQUAL2("in eof", ss.eof(), ms.eof());
}
// Test changing the buffer
std::string test2("bye now");
ms.str((char*)(test2.data()), test2.size());
ms.seekg(0);
ms.clear();
std::stringstream ss2(test2);
for (int i=0; i<5; i++)
{
std::string s1, s2;
ms >> s1;
ss2 >> s2;
TESTEQUAL2("in2", s2, s1);
TESTEQUAL2("in2 fail", ss2.fail(), ms.fail());
TESTEQUAL2("in2 eof", ss2.eof(), ms.eof());
}
}
// -------------------------------------------------------
// Test setting the buffer on a default input stream
// -------------------------------------------------------
{
std::string test("third test");
IMemStream ms;
ms.str((char*)(test.data()), test.size());
std::stringstream ss(test);
for (int i=0; i<5; i++)
{
std::string s1, s2;
ms >> s1;
ss >> s2;
TESTEQUAL2("in2", s2, s1);
TESTEQUAL2("in2 fail", ss.fail(), ms.fail());
TESTEQUAL2("in2 eof", ss.eof(), ms.eof());
}
}
// -------------------------------------------------------
// Test output stream
// -------------------------------------------------------
{
OMemStream ms;
std::stringstream ss;
for (int i=0; i<500; i++)
{
ms << i << " ";
ss << i << " ";
}
const char* dataP = ms.str();
size_t size = ms.pcount();
std::string msStr(dataP, size);
std::string ssStr = ss.str();
TESTEQUAL2("out data", msStr, ssStr);
TESTEQUAL2("out eof", ms.eof(), ss.eof());
TESTEQUAL2("out fail", ms.fail(), ss.fail());
}
// -------------------------------------------------------
// Test memory limits
// -------------------------------------------------------
// Set max at 0x10000000 for day to day testing so that test doesn't take too long.
// To determine the actual memory limits, change this max to something very large and
// see where we break.
size_t max = 0x10000000L;
size_t sizeLimit = memLimitsTest(max);
TESTEQUAL2("maximum stream size", sizeLimit >= max, true);
}
void nta::ArrayTest::testBufferAllocation()
{
bool caughtException;
TestCaseIterator testCase;
for(testCase = testCases_.begin(); testCase != testCases_.end(); testCase++)
{
caughtException = false;
ArrayBase a(testCase->second.dataType);
try
{
a.allocateBuffer((size_t) (testCase->second.allocationSize));
}
catch(std::exception& )
{
caughtException = true;
}
if(testCase->second.testUsesInvalidParameters)
{
TESTEQUAL2("Test case: " +
testCase->first +
" - allocation of an ArrayBase of invalid size should raise an "
"exception",
caughtException,
true);
}
else
{
TESTEQUAL2("Test case: " +
testCase->first +
" - Allocation of an ArrayBase of valid size should return a "
"valid pointer",
caughtException,
false);
caughtException = false;
try
{
a.allocateBuffer(10);
}
catch(nta::Exception)
{
caughtException = true;
}
TEST2("Test case: " +
testCase->first +
" - allocating a buffer when one is already allocated should "
"raise an exception",
caughtException);
TESTEQUAL2("Test case: " +
testCase->first +
" - Size of allocated ArrayBase should match requested size",
(size_t) testCase->second.allocationSize,
a.getCount());
}
}
}
void nta::ArrayTest::testArrayCreation()
{
boost::scoped_ptr<ArrayBase> arrayP;
TestCaseIterator testCase;
for(testCase = testCases_.begin(); testCase != testCases_.end(); testCase++)
{
char *buf = (char *) -1;
if(testCase->second.testUsesInvalidParameters)
{
bool caughtException = false;
try
{
arrayP.reset(new ArrayBase(testCase->second.dataType));
}
catch(nta::Exception)
{
caughtException = true;
}
TEST2("Test case: " +
testCase->first +
" - Should throw an exception on trying to create an invalid "
"ArrayBase",
caughtException);
}
else
{
arrayP.reset(new ArrayBase(testCase->second.dataType));
buf = (char *) arrayP->getBuffer();
TEST2("Test case: " +
testCase->first +
" - When not passed a size, a newly created ArrayBase should "
"have a NULL buffer",
buf == NULL);
TESTEQUAL2("Test case: " +
testCase->first +
" - When not passed a size, a newly created ArrayBase should "
"have a count equal to zero",
(size_t) 0,
arrayP->getCount());
boost::scoped_array<char> buf2(new char[testCase->second.dataTypeSize *
testCase->second.allocationSize]);
arrayP.reset(new ArrayBase(testCase->second.dataType,
buf2.get(),
testCase->second.allocationSize));
buf = (char *) arrayP->getBuffer();
TEST2("Test case: " +
testCase->first +
" - Preallocating a buffer for a newly created ArrayBase should "
"use the provided buffer",
buf == buf2.get());
TESTEQUAL2("Test case: " +
testCase->first +
" - Preallocating a buffer should have a count equal to our "
"allocation size",
(size_t) testCase->second.allocationSize,
arrayP->getCount());
}
}
}
