TEST(ObserverService, RemoveObserver)
{
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
RefPtr<TestObserver> b = new TestObserver(NS_LITERAL_STRING("B"));
RefPtr<TestObserver> c = new TestObserver(NS_LITERAL_STRING("C"));
svc->AddObserver(a, "Foo", false);
svc->AddObserver(b, "Foo", true);
// Remove from non-existent topic.
nsresult rv = svc->RemoveObserver(a, "Bar");
ASSERT_TRUE(NS_FAILED(rv));
// Remove a.
testResult(svc->RemoveObserver(a, "Foo"));
// Remove b.
testResult(svc->RemoveObserver(b, "Foo"));
// Attempt to remove c.
rv = svc->RemoveObserver(c, "Foo");
ASSERT_TRUE(NS_FAILED(rv));
}
static void TestExpectedCount(
nsIObserverService* svc,
const char* topic,
size_t expected)
{
nsCOMPtr<nsISimpleEnumerator> e;
nsresult rv = svc->EnumerateObservers(topic, getter_AddRefs(e));
testResult(rv);
EXPECT_TRUE(e);
bool hasMore = false;
rv = e->HasMoreElements(&hasMore);
testResult(rv);
if (expected == 0) {
EXPECT_FALSE(hasMore);
return;
}
size_t count = 0;
while (hasMore) {
count++;
// Grab the element.
nsCOMPtr<nsISupports> supports;
e->GetNext(getter_AddRefs(supports));
ASSERT_TRUE(supports);
// Move on.
rv = e->HasMoreElements(&hasMore);
testResult(rv);
}
EXPECT_EQ(count, expected);
}
END_TEST
START_TEST(Server_HistorizingUpdateUpdate)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_Memory(1, 1);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill backend with insert
ck_assert_str_eq(UA_StatusCode_name(updateHistory(UA_PERFORMUPDATETYPE_INSERT, testData, NULL, NULL))
, UA_StatusCode_name(UA_STATUSCODE_GOOD));
testResult(testDataSorted, NULL);
// delete some values
ck_assert_str_eq(UA_StatusCode_name(deleteHistory(DELETE_START_TIME, DELETE_STOP_TIME)),
UA_StatusCode_name(UA_STATUSCODE_GOOD));
testResult(testDataAfterDelete, NULL);
// update all and insert some
UA_StatusCode *result;
size_t resultSize = 0;
ck_assert_str_eq(UA_StatusCode_name(updateHistory(UA_PERFORMUPDATETYPE_UPDATE, testDataSorted, &result, &resultSize))
, UA_StatusCode_name(UA_STATUSCODE_GOOD));
for (size_t i = 0; i < resultSize; ++i) {
ck_assert_str_eq(UA_StatusCode_name(result[i]), UA_StatusCode_name(testDataUpdateResult[i]));
}
UA_Array_delete(result, resultSize, &UA_TYPES[UA_TYPES_STATUSCODE]);
UA_HistoryData data;
UA_HistoryData_init(&data);
testResult(testDataSorted, &data);
for (size_t i = 0; i < data.dataValuesSize; ++i) {
ck_assert_uint_eq(data.dataValues[i].hasValue, true);
ck_assert(data.dataValues[i].value.type == &UA_TYPES[UA_TYPES_INT64]);
ck_assert_uint_eq(*((UA_Int64*)data.dataValues[i].value.data), UA_PERFORMUPDATETYPE_UPDATE);
}
UA_HistoryData_deleteMembers(&data);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
TEST(ObserverService, AddObserver)
{
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
// Add a strong ref.
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
nsresult rv = svc->AddObserver(a, "Foo", false);
testResult(rv);
// Add a few weak ref.
RefPtr<TestObserver> b = new TestObserver(NS_LITERAL_STRING("B"));
rv = svc->AddObserver(b, "Bar", true);
testResult(rv);
}
TEST(ObserverService, TestNotify)
{
nsCString topicA; topicA.Assign( "topic-A" );
nsCString topicB; topicB.Assign( "topic-B" );
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
RefPtr<TestObserver> aObserver = new TestObserver(NS_LITERAL_STRING("Observer-A"));
RefPtr<TestObserver> bObserver = new TestObserver(NS_LITERAL_STRING("Observer-B"));
// Add two observers for topicA.
testResult(svc->AddObserver(aObserver, topicA.get(), false));
testResult(svc->AddObserver(bObserver, topicA.get(), false));
// Add one observer for topicB.
testResult(svc->AddObserver(bObserver, topicB.get(), false));
// Notify topicA.
NS_NAMED_LITERAL_STRING(dataA, "Testing Notify(observer-A, topic-A)");
aObserver->mExpectedData = dataA;
bObserver->mExpectedData = dataA;
nsresult rv =
svc->NotifyObservers(ToSupports(aObserver), topicA.get(), dataA.get());
testResult(rv);
ASSERT_EQ(aObserver->mObservations, 1);
ASSERT_EQ(bObserver->mObservations, 1);
// Notify topicB.
NS_NAMED_LITERAL_STRING(dataB, "Testing Notify(observer-B, topic-B)");
bObserver->mExpectedData = dataB;
rv = svc->NotifyObservers(ToSupports(bObserver), topicB.get(), dataB.get());
testResult(rv);
ASSERT_EQ(aObserver->mObservations, 1);
ASSERT_EQ(bObserver->mObservations, 2);
// Remove one of the topicA observers, make sure it's not notified.
testResult(svc->RemoveObserver(aObserver, topicA.get()));
// Notify topicA, only bObserver is expected to be notified.
bObserver->mExpectedData = dataA;
rv = svc->NotifyObservers(ToSupports(aObserver), topicA.get(), dataA.get());
testResult(rv);
ASSERT_EQ(aObserver->mObservations, 1);
ASSERT_EQ(bObserver->mObservations, 3);
// Remove the other topicA observer, make sure none are notified.
testResult(svc->RemoveObserver(bObserver, topicA.get()));
rv = svc->NotifyObservers(ToSupports(aObserver), topicA.get(), dataA.get());
testResult(rv);
ASSERT_EQ(aObserver->mObservations, 1);
ASSERT_EQ(bObserver->mObservations, 3);
}
//------------------------------------------------------------------------------
void testVerify_P(char* result, PGM_P expect) {
testOut->write('"');
testOut->print(result);
testOut->print("\",\"");
print_P(testOut, expect);
testOut->write('"');
uint8_t n = strlen(result) + strlen_P(expect) + 5;
testResult(!strcmp_P(result, expect), n);
}
//------------------------------------------------------------------------------
void testVerify_P(char* result, PGM_P expect) {
testOut->write('"');
testOut->print(result);
testOut->print("\",\"");
testOut->print((const __FlashStringHelper*)expect);
testOut->write('"');
uint8_t n = strlen(result) + strlenPGM(expect) + 5;
testResult(!strcmp_P(result, expect), n);
}
int testDone(void) {
int status = 0;
epicsMutexMustLock(testLock);
if (perlHarness) {
if (!planned) printf("1..%d\n", tested);
} else {
if (planned && tested > planned) {
printf("\nRan %d tests but only planned for %d!\n", tested, planned);
status = 2;
} else if (planned && tested < planned) {
printf("\nPlanned %d tests but only ran %d\n", planned, tested);
status = 2;
}
printf("\n Results\n =======\n Tests: %-3d\n", tested);
if (tested) {
testResult("Passed", passed);
if (bonus) testResult("Todo Passes", bonus);
if (failed) {
testResult("Failed", failed);
status = 1;
}
if (skipped) testResult("Skipped", skipped);
}
}
if (Harness) {
if (failed) {
testFailure *fault = callocMustSucceed(1, sizeof(testFailure),
"testDone calloc");
fault->name = testing;
fault->tests = tested;
fault->failures = failed;
fault->skips = skipped;
ellAdd(&faults, &fault->node);
}
Programs++;
Tests += tested;
}
epicsMutexUnlock(testLock);
return (status);
}
TEST(ObserverService, EnumerateWeakRefs)
{
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
const size_t kFooCount = 10;
for (size_t i = 0; i < kFooCount; i++) {
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
testResult(svc->AddObserver(a, "Foo", true));
}
// All refs are out of scope, expect enumeration to be empty.
TestExpectedCount(svc, "Foo", 0);
// Now test a mixture.
for (size_t i = 0; i < kFooCount; i++) {
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
RefPtr<TestObserver> b = new TestObserver(NS_LITERAL_STRING("B"));
// Register a as weak for "Foo".
testResult(svc->AddObserver(a, "Foo", true));
// Register b as strong for "Foo".
testResult(svc->AddObserver(b, "Foo", false));
}
// Expect the b instances to stick around.
TestExpectedCount(svc, "Foo", kFooCount);
// Now add a couple weak refs, but don't go out of scope.
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
testResult(svc->AddObserver(a, "Foo", true));
RefPtr<TestObserver> b = new TestObserver(NS_LITERAL_STRING("B"));
testResult(svc->AddObserver(b, "Foo", true));
// Expect all the observers from before and the two new ones.
TestExpectedCount(svc, "Foo", kFooCount + 2);
}
TEST_F(TestPacketFragmentManager, FragmentDefragment)
{
auto halfWay = PacketFragmentManager::FragmentPacket(delta4kBytePayloadServerSequence22);
PacketFragmentManager toTest;
for (auto fragment : halfWay)
{
toTest.AddPacket(PacketFragment(fragment));
}
PacketDelta testResult(toTest.GetDefragmentedPacket());
EXPECT_EQ(testResult, delta4kBytePayloadServerSequence22);
}
TEST(ObserverService, EnumerateEmpty)
{
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
// Try with no observers.
TestExpectedCount(svc, "A", 0);
// Now add an observer and enumerate an unobserved topic.
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
testResult(svc->AddObserver(a, "Foo", false));
TestExpectedCount(svc, "A", 0);
}
TEST(ObserverService, Enumerate)
{
nsCOMPtr<nsIObserverService> svc =
do_CreateInstance("@mozilla.org/observer-service;1");
const size_t kFooCount = 10;
for (size_t i = 0; i < kFooCount; i++) {
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
testResult(svc->AddObserver(a, "Foo", false));
}
const size_t kBarCount = kFooCount / 2;
for (size_t i = 0; i < kBarCount; i++) {
RefPtr<TestObserver> a = new TestObserver(NS_LITERAL_STRING("A"));
testResult(svc->AddObserver(a, "Bar", false));
}
// Enumerate "Foo".
TestExpectedCount(svc, "Foo", kFooCount);
// Enumerate "Bar".
TestExpectedCount(svc, "Bar", kBarCount);
}
int main() {
int score = 0;
printf("\nIniciando o teste do módulo message\n");
score += testResult();
score += testKey();
score += testValue();
score += testEntry();
score += testKeys();
score += testInvalida();
printf("Resultados do teste do módulo message: %d em 6\n\n",score);
return score;
}
TEST_F(TestPacketFragmentManager, FragmentDefragmentOldThenNew)
{
auto halfWayOld = PacketFragmentManager::FragmentPacket(delta4kBytePayloadServerSequence22);
auto halfWayNew = PacketFragmentManager::FragmentPacket(delta4kBytePayloadServerSequence44);
PacketFragmentManager toTest;
for (auto fragment : halfWayOld)
{
toTest.AddPacket(PacketFragment(fragment));
}
for (auto fragment : halfWayNew)
{
toTest.AddPacket(PacketFragment(fragment));
}
// always expect the older one.
PacketDelta testResult(toTest.GetDefragmentedPacket());
EXPECT_EQ(testResult, delta4kBytePayloadServerSequence44);
}
int main(int argc, char *argv[])
{
nsCString topicA; topicA.Assign( "topic-A" );
nsCString topicB; topicB.Assign( "topic-B" );
nsresult rv;
nsresult res = nsComponentManager::CreateInstance("@mozilla.org/observer-service;1",
NULL,
NS_GET_IID(nsIObserverService),
(void **) &anObserverService);
if (res == NS_OK) {
nsIObserver *aObserver = new TestObserver(NS_LITERAL_STRING("Observer-A"));
aObserver->AddRef();
nsIObserver *bObserver = new TestObserver(NS_LITERAL_STRING("Observer-B"));
bObserver->AddRef();
printf("Adding Observer-A as observer of topic-A...\n");
rv = anObserverService->AddObserver(aObserver, topicA.get(), PR_FALSE);
testResult(rv);
printf("Adding Observer-B as observer of topic-A...\n");
rv = anObserverService->AddObserver(bObserver, topicA.get(), PR_FALSE);
testResult(rv);
printf("Adding Observer-B as observer of topic-B...\n");
rv = anObserverService->AddObserver(bObserver, topicB.get(), PR_FALSE);
testResult(rv);
printf("Testing Notify(observer-A, topic-A)...\n");
rv = anObserverService->NotifyObservers( aObserver,
topicA.get(),
NS_LITERAL_STRING("Testing Notify(observer-A, topic-A)").get() );
testResult(rv);
printf("Testing Notify(observer-B, topic-B)...\n");
rv = anObserverService->NotifyObservers( bObserver,
topicB.get(),
NS_LITERAL_STRING("Testing Notify(observer-B, topic-B)").get() );
testResult(rv);
printf("Testing EnumerateObserverList (for topic-A)...\n");
nsCOMPtr<nsISimpleEnumerator> e;
rv = anObserverService->EnumerateObservers(topicA.get(), getter_AddRefs(e));
testResult(rv);
printf("Enumerating observers of topic-A...\n");
if ( e ) {
nsCOMPtr<nsIObserver> observer;
PRBool loop = PR_TRUE;
while( NS_SUCCEEDED(e->HasMoreElements(&loop)) && loop)
{
e->GetNext(getter_AddRefs(observer));
printf("Calling observe on enumerated observer ");
printString(NS_REINTERPRET_CAST(TestObserver*,
NS_REINTERPRET_CAST(void*, observer.get()))->mName);
printf("...\n");
rv = observer->Observe( observer,
topicA.get(),
NS_LITERAL_STRING("during enumeration").get() );
testResult(rv);
}
}
printf("...done enumerating observers of topic-A\n");
printf("Removing Observer-A...\n");
rv = anObserverService->RemoveObserver(aObserver, topicA.get());
testResult(rv);
printf("Removing Observer-B (topic-A)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicB.get());
testResult(rv);
printf("Removing Observer-B (topic-B)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicA.get());
testResult(rv);
}
/// Run all benchmarking tests.
static void RunAllTests()
{
Benchmarker& instance = Instance();
std::vector<Outputter*>& outputters = instance._outputters;
// Get the tests for execution.
std::vector<TestDescriptor*> tests = instance.GetTests();
// Begin output.
for (std::size_t outputterIndex = 0;
outputterIndex < outputters.size();
outputterIndex++)
outputters[outputterIndex]->Begin(tests.size());
// Run through all the tests in ascending order.
std::size_t index = 0;
while (index < tests.size())
{
// Get the test descriptor.
TestDescriptor* descriptor = tests[index++];
// Check if test matches include filters
if (instance._include.size() > 0)
{
bool included = false;
std::string name = descriptor->FixtureName + "." +
descriptor->TestName + descriptor->Parameters;
for (std::size_t i = 0; i <instance._include.size(); i++)
{
if (name.find(instance._include[i]) !=
std::string::npos)
{
included = true;
break;
}
}
if (!included)
continue;
}
// Describe the beginning of the run.
for (std::size_t outputterIndex = 0;
outputterIndex < outputters.size();
outputterIndex++)
outputters[outputterIndex]->BeginTest(
descriptor->FixtureName,
descriptor->TestName,
descriptor->Parameters,
descriptor->Runs,
descriptor->Iterations
);
// Execute each individual run.
int64_t timeTotal = 0,
timeRunMin = std::numeric_limits<int64_t>::max(),
timeRunMax = std::numeric_limits<int64_t>::min();
std::size_t run = descriptor->Runs;
while (run--)
{
// Construct a test instance.
Test* test = descriptor->Factory->CreateTest();
// Run the test.
int64_t time = test->Run(descriptor->Iterations);
// Store the test time.
timeTotal += time;
if (timeRunMin > time)
timeRunMin = time;
if (timeRunMax < time)
timeRunMax = time;
// Dispose of the test instance.
delete test;
}
// Calculate the test result.
TestResult testResult(descriptor->Runs,
descriptor->Iterations,
timeTotal,
timeRunMin,
timeRunMax);
// Describe the end of the run.
for (std::size_t outputterIndex = 0;
outputterIndex < outputters.size();
outputterIndex++)
outputters[outputterIndex]->EndTest(
descriptor->FixtureName,
descriptor->TestName,
descriptor->Parameters,
testResult
);
}
// Begin output.
for (std::size_t outputterIndex = 0;
outputterIndex < outputters.size();
outputterIndex++)
outputters[outputterIndex]->End(tests.size());
}
/*
* Make sure that all of the fitness functions are working correctly. A bug in there
* would be hard to notice without explicitly testing it.
* 1: There is a bug in one of the fitness functions.
*/
int testFitness()
{
if (fullKeyboard == FK_NO) {
printf("\nTesting calcInRoll():\n");
testResult(calcInRoll(0, 0), 0);
testResult(calcInRoll(10, 11), inRoll);
testResult(calcInRoll(14, 15), 0);
testResult(calcInRoll(29, 28), inRoll);
testResult(calcInRoll(3, 4), 0);
testResult(calcInRoll(4, 3), 0);
testResult(calcInRoll(11, 2), 0);
testResult(calcInRoll(2, 11), 0);
printf("\nTesting calcOutRoll():\n");
testResult(calcOutRoll(0, 0), 0);
testResult(calcOutRoll(11, 10), outRoll);
testResult(calcOutRoll(15, 14), 0);
testResult(calcOutRoll(28, 29), outRoll);
testResult(calcOutRoll(3, 4), 0);
testResult(calcOutRoll(14, 13), 0);
printf("\nTesting calcSameFinger():\n");
testResult(calcSameFinger(0, 0), 0);
testResult(calcSameFinger(10, 0), sameFingerP);
testResult(calcSameFinger(11, 21), sameFingerR);
testResult(calcSameFinger(7, 27), sameFingerM);
testResult(calcSameFinger(13, 4), sameFingerI);
testResult(calcSameFinger(0, 4), 0);
printf("\nTesting calcRowChange():\n");
testResult(calcRowChange(8, 8), 0);
testResult(calcRowChange(10, 0), rowChangeUp);
testResult(calcRowChange(11, 0), rowChangeUp + handWarp);
testResult(calcRowChange(13, 2), rowChangeUp + handSmooth);
testResult(calcRowChange(8, 16), rowChangeDown);
testResult(calcRowChange(8, 26), rowChangeDown);
testResult(calcRowChange(28, 9), rowChangeUp + handWarp);
testResult(calcRowChange(25, 5), rowChangeUp);
printf("\nTesting calcHomeJump():\n");
testResult(calcHomeJump(8, 8), 0);
testResult(calcHomeJump(10, 0), 0);
testResult(calcHomeJump(11, 0), 0);
testResult(calcHomeJump(10, 1), 0);
testResult(calcHomeJump(8, 16), 0);
testResult(calcHomeJump(8, 26), homeJump + homeJumpIndex);
testResult(calcHomeJump(28, 9), homeJump);
testResult(calcHomeJump(25, 5), homeJump);
printf("\nTesting calcToCenter():\n");
testResult(calcToCenter(0, 0), 0);
testResult(calcToCenter(13, 14), toCenter);
testResult(calcToCenter(17, 15), toCenter);
testResult(calcToCenter(4, 1), toCenter);
testResult(calcToCenter(25, 9), toCenter);
testResult(calcToCenter(25, 15), 0);
} else if (fullKeyboard == FK_STANDARD) {
printf("\nTesting calcHomeJump():\n");
testResult(calcHomeJump(8, 8), 0);
testResult(calcHomeJump(14, 0), 0);
testResult(calcHomeJump(15, 0), 0);
testResult(calcHomeJump(14, 1), 0);
testResult(calcHomeJump(36, 9), 0);
testResult(calcHomeJump(48, 9), doubleJump + homeJumpIndex);
testResult(calcHomeJump(49, 23), homeJump + homeJumpIndex);
testResult(calcHomeJump(44, 18), homeJump);
testResult(calcHomeJump(44, 3), doubleJump);
} else {
printf("\nTesting calcInRoll():\n");
testResult(calcInRoll(0, 0), 0);
testResult(calcInRoll(2, 3), inRoll);
testResult(calcInRoll(2, 14), 0);
testResult(calcInRoll(13, 3), 0);
testResult(calcInRoll(29, 28), inRoll);
testResult(calcInRoll(28, 27), 0);
printf("\nTesting calcSameFinger():\n");
testResult(calcSameFinger(0, 0), 0);
testResult(calcSameFinger(11, 0), sameFingerP);
testResult(calcSameFinger(12, 23), sameFingerR);
testResult(calcSameFinger(7, 29), sameFingerM);
testResult(calcSameFinger(25, 15), sameFingerI);
testResult(calcSameFinger(0, 4), 0);
printf("\nTesting calcHomeJump():\n");
testResult(calcHomeJump(8, 8), 0);
testResult(calcHomeJump(11, 0), 0);
testResult(calcHomeJump(12, 0), 0);
testResult(calcHomeJump(11, 1), 0);
testResult(calcHomeJump(8, 17), 0);
testResult(calcHomeJump(19, 39), homeJump + homeJumpIndex);
testResult(calcHomeJump(41, 20), homeJump);
testResult(calcHomeJump(38, 16), homeJump);
}
return 0;
}
//------------------------------------------------------------------------------
void testVerify_P(bool b, PGM_P msg) {
testOut->print((const __FlashStringHelper*)msg);
uint8_t n = strlenPGM(msg);
testResult(b, n);
}
void testResultNotEqual(long int result,long int expected){
testResult(result,notequal,expected);
}
int main(int argc, char *argv[])
{
nsCString topicA; topicA.Assign( "topic-A" );
nsCString topicB; topicB.Assign( "topic-B" );
nsresult rv;
nsresult res = CallCreateInstance("@mozilla.org/observer-service;1", &anObserverService);
if (res == NS_OK) {
nsIObserver *aObserver = new TestObserver(NS_LITERAL_STRING("Observer-A"));
aObserver->AddRef();
nsIObserver *bObserver = new TestObserver(NS_LITERAL_STRING("Observer-B"));
bObserver->AddRef();
printf("Adding Observer-A as observer of topic-A...\n");
rv = anObserverService->AddObserver(aObserver, topicA.get(), false);
testResult(rv);
printf("Adding Observer-B as observer of topic-A...\n");
rv = anObserverService->AddObserver(bObserver, topicA.get(), false);
testResult(rv);
printf("Adding Observer-B as observer of topic-B...\n");
rv = anObserverService->AddObserver(bObserver, topicB.get(), false);
testResult(rv);
printf("Testing Notify(observer-A, topic-A)...\n");
rv = anObserverService->NotifyObservers( aObserver,
topicA.get(),
u"Testing Notify(observer-A, topic-A)" );
testResult(rv);
printf("Testing Notify(observer-B, topic-B)...\n");
rv = anObserverService->NotifyObservers( bObserver,
topicB.get(),
u"Testing Notify(observer-B, topic-B)" );
testResult(rv);
printf("Testing EnumerateObserverList (for topic-A)...\n");
nsCOMPtr<nsISimpleEnumerator> e;
rv = anObserverService->EnumerateObservers(topicA.get(), getter_AddRefs(e));
testResult(rv);
printf("Enumerating observers of topic-A...\n");
if ( e ) {
nsCOMPtr<nsIObserver> observer;
bool loop = true;
while( NS_SUCCEEDED(e->HasMoreElements(&loop)) && loop)
{
nsCOMPtr<nsISupports> supports;
e->GetNext(getter_AddRefs(supports));
observer = do_QueryInterface(supports);
printf("Calling observe on enumerated observer ");
printString(reinterpret_cast<TestObserver*>
(reinterpret_cast<void*>(observer.get()))->mName);
printf("...\n");
rv = observer->Observe( observer,
topicA.get(),
u"during enumeration" );
testResult(rv);
}
}
printf("...done enumerating observers of topic-A\n");
printf("Removing Observer-A...\n");
rv = anObserverService->RemoveObserver(aObserver, topicA.get());
testResult(rv);
printf("Removing Observer-B (topic-A)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicB.get());
testResult(rv);
printf("Removing Observer-B (topic-B)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicA.get());
testResult(rv);
}
return 0;
}
//------------------------------------------------------------------------------
void testVerify_P(bool b, PGM_P msg) {
print_P(testOut, msg);
uint8_t n = strlen_P(msg);
testResult(b, n);
}
void testCentroid(void) {
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
std::string header = "Centroid Operations";
testSectionHeader(header);
int testNum = 1; // Test starting number
int numDims = 5; // Dimensions in test arrays (don't go below 2)
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - setCentroid(default)");
Cluster c1(numDims);
std::cout << "Cluster c" << c1.getId() << ";";
std::cout << std::endl;
std::ifstream inFile;
std::cout << "std::ifstream inFile;";
std::cout << std::endl;
// WARNING!! MAKE SURE THE CURRENT WORKING DIRECTORY IS SET TO WHEREVER YOU HAVE main.cpp
inFile.open("infile_1.txt");
std::cout << "inFile.open(\"infile_1.txt\");";
std::cout << std::endl;
inFile >> c1;
std::cout << "inFile >> c" << c1.getId() << ";";
std::cout << std::endl;
c1.setCentroid();
std::cout << "c" << c1.getId() << ".setCentroid();";
std::cout << std::endl;
testResult();
std::cout << "c" << c1.getId() << ".getCentroid(): (" << c1.getCentroid() << ")";
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - setCentroid(point)");
Cluster c1(numDims);
std::cout << "Cluster c" << c1.getId() << ";";
std::cout << std::endl;
std::ifstream inFile;
std::cout << "std::ifstream inFile;";
std::cout << std::endl;
// WARNING!! MAKE SURE THE CURRENT WORKING DIRECTORY IS SET TO WHEREVER YOU HAVE main.cpp
inFile.open("infile_1.txt");
std::cout << "inFile.open(\"infile_1.txt\");";
std::cout << std::endl;
inFile >> c1;
std::cout << "inFile >> c" << c1.getId() << ";";
std::cout << std::endl;
double *p1arr = new double[numDims];
randPt(numDims, 2, 4, p1arr);
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
delete[] p1arr;
std::cout << std::endl;
c1.setCentroid(p1);
std::cout << "c1.setCentroid(p1);";
std::cout << std::endl;
testResult();
std::cout << "c" << c1.getId() << ".getCentroid(): (" << c1.getCentroid() << ")";
std::cout << std::endl;
c1.loud();
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - setCentroid(point) [Not in cluster]");
Cluster c1(numDims);
std::cout << "Cluster c" << c1.getId() << ";";
std::cout << std::endl;
std::ifstream inFile;
std::cout << "std::ifstream inFile;";
std::cout << std::endl;
// WARNING!! MAKE SURE THE CURRENT WORKING DIRECTORY IS SET TO WHEREVER YOU HAVE main.cpp
inFile.open("infile_1.txt");
std::cout << "inFile.open(\"infile_1.txt\");";
std::cout << std::endl;
inFile >> c1;
std::cout << "inFile >> c" << c1.getId() << ";";
std::cout << std::endl;
double *p1arr = new double[numDims];
randPt(numDims, 0, 9, p1arr);
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
delete[] p1arr;
std::cout << std::endl;
c1.setCentroid(p1);
std::cout << "c1.setCentroid(p1);";
std::cout << std::endl;
testResult();
std::cout << "c" << c1.getId() << ".getCentroid(): (" << c1.getCentroid() << ")";
std::cout << std::endl;
c1.loud();
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - computeCentroid() [1]");
Cluster c1(numDims);
std::cout << "Cluster c" << c1.getId() << ";";
std::cout << std::endl;
std::ifstream inFile;
std::cout << "std::ifstream inFile;";
std::cout << std::endl;
// WARNING!! MAKE SURE THE CURRENT WORKING DIRECTORY IS SET TO WHEREVER YOU HAVE main.cpp
inFile.open("infile_1.txt");
std::cout << "inFile.open(\"infile_1.txt\");";
std::cout << std::endl;
inFile >> c1;
std::cout << "inFile >> c" << c1.getId() << ";";
std::cout << std::endl;
c1.setCentroid();
std::cout << "c" << c1.getId() << ".setCentroid();";
std::cout << std::endl;
c1.computeCentroid();
std::cout << "c" << c1.getId() << ".computeCentroid();";
std::cout << std::endl;
testResult();
std::cout << "c" << c1.getId() << ".getCentroid(): (" << c1.getCentroid() << ")";
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - computeCentroid() [2]");
Cluster c1(numDims);
std::cout << "Cluster c" << c1.getId() << ";";
std::cout << std::endl;
double p1arr[] = {21,12,0,0,0};
double p2arr[] = {0,0,15,0,0};
double p3arr[] = {0,0,0,9,3};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c1.add(p3);
std::cout << "c1.add(p3);";
std::cout << std::endl;
c1.setCentroid();
std::cout << "c" << c1.getId() << ".setCentroid();";
std::cout << std::endl;
c1.computeCentroid();
std::cout << "c" << c1.getId() << ".computeCentroid();";
std::cout << std::endl;
testResult();
std::cout << "c" << c1.getId() << ".getCentroid(): (" << c1.getCentroid() << ")";
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
testTitle(testNum++, header, "Centroid Operations - Move(&)");
Cluster c1(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
Cluster c2(numDims);
std::cout << "Cluster c2(numDims);";
std::cout << std::endl;
double p1arr[] = {6,12,0,0,0};
double p2arr[] = {0,0,18,0,0};
double p3arr[] = {0,0,0,24,30};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c1.add(p3);
std::cout << "c1.add(p3);";
std::cout << std::endl;
std::cout << std::endl << std::endl << "[Current Data Formulation]";
std::cout << std::endl;
c1.loud("c1");
std::cout << std::endl;
c2.loud("c2");
std::cout << std::endl;
c1.computeCentroid();
std::cout << std::endl;
std::cout << "c1.computeCentroid(): (" << c1.getCentroid() << ")";
c2.computeCentroid();
std::cout << std::endl;
std::cout << "c2.computeCentroid(): (" << c2.getCentroid() << ")";
std::cout << std::endl;
std::cout << std::endl;
Cluster::Move(&p1,&c1,&c2).perform();
std::cout << "Cluster::Move(&p1,&c1,&c2).perform();";
std::cout << std::endl << std::endl << "[Current Data Formulation]";
std::cout << std::endl;
std::cout << std::endl;
c1.loud("c1");
std::cout << std::endl;
c2.loud("c2");
std::cout << std::endl;
std::cout << std::endl;
std::cout << "c1.computeCentroid(): (" << c1.getCentroid() << ")";
c2.computeCentroid();
std::cout << std::endl;
std::cout << "c2.computeCentroid(): (" << c2.getCentroid() << ")";
Cluster::Move(&p2,&c1,&c2).perform();
std::cout << std::endl;
std::cout << "Cluster::Move(&p2,&c1,&c2).perform();";
std::cout << std::endl << std::endl << "[Current Data Formulation]";
std::cout << std::endl;
std::cout << std::endl;
c1.loud("c1");
std::cout << std::endl;
c2.loud("c2");
std::cout << std::endl;
c1.computeCentroid();
std::cout << std::endl;
std::cout << "c1.computeCentroid(): (" << c1.getCentroid() << ")";
c2.computeCentroid();
std::cout << std::endl;
std::cout << "c2.computeCentroid(): (" << c2.getCentroid() << ")";
std::cout << std::endl;
Cluster::Move(&p3,&c1,&c2).perform();
std::cout << "Cluster::Move(&p3,&c1,&c2).perform();";
std::cout << std::endl << std::endl << "[Current Data Formulation]";
std::cout << std::endl;
c1.loud("c1");
std::cout << std::endl;
c2.loud("c2");
std::cout << std::endl;
testResult();
c1.computeCentroid();
std::cout << std::endl;
std::cout << "c1.computeCentroid(): (" << c1.getCentroid() << ")";
c2.computeCentroid();
std::cout << std::endl;
std::cout << "c2.computeCentroid(): (" << c2.getCentroid() << ")";
std::cout << std::endl;
c1.loud("c1");
std::cout << std::endl;
c2.loud("c2");
std::cout << std::endl;
testCheck();
std::cout << std::endl << "c1.computeCentroid(): [Garbage]";
std::cout << std::endl << "c2.computeCentroid(): (2, 4, 6, 8, 10)";
std::cout << std::endl;
std::cout << std::endl << "c1: Size(0) Centroid: (2.07409e-236)";
std::cout << std::endl << "{}";
std::cout << std::endl;
std::cout << std::endl << "c2: Size(3) Centroid: (2, 4, 6, 8, 10)";
std::cout << std::endl << "{(0,0,0,24,30),(0,0,18,0,0),(6,12,0,0,0)}";
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
numDims = 6; // Dimensions in test arrays (don't go below 2)
testTitle(testNum++, header, "Centroid Operations - pickPoints()");
Cluster c1(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
double p1arr[] = {6,0,0,0,0,0};
double p2arr[] = {0,12,0,0,0,0};
double p3arr[] = {0,0,18,0,0,0};
double p4arr[] = {0,0,0,24,0,0};
double p5arr[] = {0,0,0,0,30,0};
double p6arr[] = {0,0,0,0,0,36};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
std::cout << "double p4arr[" << numDims << "] = ";
testPtArr(numDims, p4arr, "{", "};");
std::cout << std::endl;
std::cout << "double p5arr[" << numDims << "] = ";
testPtArr(numDims, p5arr, "{", "};");
std::cout << std::endl;
std::cout << "double p6arr[" << numDims << "] = ";
testPtArr(numDims, p6arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
Point p4(numDims, p4arr);
std::cout << "Point p4(" << numDims << ", p4arr);";
std::cout << std::endl;
Point p5(numDims, p5arr);
std::cout << "Point p5(" << numDims << ", p5arr);";
std::cout << std::endl;
Point p6(numDims, p6arr);
std::cout << "Point p6(" << numDims << ", p5arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c1.add(p3);
std::cout << "c1.add(p3);";
std::cout << std::endl;
c1.add(p4);
std::cout << "c1.add(p4);";
std::cout << std::endl;
c1.add(p5);
std::cout << "c1.add(p5);";
std::cout << std::endl;
c1.add(p6);
std::cout << "c1.add(p6);";
PointPtr pickArray1[1];
PointPtr pickArray2[2];
PointPtr pickArray3[3];
PointPtr pickArray4[4];
PointPtr pickArray5[5];
PointPtr pickArray6[6];
PointPtr pickArray7[7];
std::cout << std::endl;
c1.pickPoints(1,pickArray1);
std::cout << "c1.pickPoints(1,pickArray1);";
std::cout << std::endl;
c1.pickPoints(2,pickArray2);
std::cout << "c2.pickPoints(2,pickArray2);";
std::cout << std::endl;
c1.pickPoints(3,pickArray3);
std::cout << "c3.pickPoints(3,pickArray3);";
std::cout << std::endl;
c1.pickPoints(4,pickArray4);
std::cout << "c4.pickPoints(4,pickArray4);";
std::cout << std::endl;
c1.pickPoints(5,pickArray5);
std::cout << "c5.pickPoints(5,pickArray5);";
std::cout << std::endl;
c1.pickPoints(6,pickArray6);
std::cout << "c1.pickPoints(6,pickArray6);";
std::cout << std::endl;
c1.pickPoints(7,pickArray7);
std::cout << "c1.pickPoints(7,pickArray7);";
testResult();
std::cout << std::endl << "pickArray1:\n(" << *pickArray1[0] << ")";
std::cout << std::endl << "pickArray2:\n(" << *pickArray2[0] << ")"
<< "\n(" << *pickArray2[1] << ")";
std::cout << std::endl << "pickArray3:\n(" << *pickArray3[0] << ")"
<< "\n(" << *pickArray3[1] << ")"
<< "\n(" << *pickArray3[2] << ")";
std::cout << std::endl << "pickArray4:\n(" << *pickArray4[0] << ")"
<< "\n(" << *pickArray4[1] << ")"
<< "\n(" << *pickArray4[2] << ")"
<< "\n(" << *pickArray4[3] << ")";
std::cout << std::endl << "pickArray5:\n(" << *pickArray5[0] << ")"
<< "\n(" << *pickArray5[1] << ")"
<< "\n(" << *pickArray5[2] << ")"
<< "\n(" << *pickArray5[3] << ")"
<< "\n(" << *pickArray5[4] << ")";
std::cout << std::endl << "pickArray6:\n(" << *pickArray6[0] << ")"
<< "\n(" << *pickArray6[1] << ")"
<< "\n(" << *pickArray6[2] << ")"
<< "\n(" << *pickArray6[3] << ")"
<< "\n(" << *pickArray6[4] << ")"
<< "\n(" << *pickArray6[5] << ")";
std::cout << std::endl << "pickArray6:\n(" << *pickArray7[0] << ")"
<< "\n(" << *pickArray7[1] << ")"
<< "\n(" << *pickArray7[2] << ")"
<< "\n(" << *pickArray7[3] << ")"
<< "\n(" << *pickArray7[4] << ")"
<< "\n(" << *pickArray7[5] << ")";
std::cout << std::endl;
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
numDims = 4; // Dimensions in test arrays (don't go below 2)
testTitle(testNum++, header, "Centroid Operations - intraClusterDistance()");
Cluster c1(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
double p1arr[] = {1,2,3,4};
double p2arr[] = {2,3,4,5};
double p3arr[] = {3,4,5,6};
double p4arr[] = {4,5,6,7};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
std::cout << "double p4arr[" << numDims << "] = ";
testPtArr(numDims, p4arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
Point p4(numDims, p4arr);
std::cout << "Point p4(" << numDims << ", p4arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c1.add(p3);
std::cout << "c1.add(p3);";
std::cout << std::endl;
c1.add(p4);
std::cout << "c1.add(p4);";
testResult();
std::cout << std::endl << "c1.intraClusterDistance(): " << c1.intraClusterDistance();
testCheck();
std::cout << std::endl << "c1.intraClusterDistance(): 20";
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
numDims = 4; // Dimensions in test arrays (don't go below 2)
testTitle(testNum++, header, "Centroid Operations - interClusterDistance()");
Cluster c1(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
Cluster c2(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
double p1arr[] = {1,2,3,4};
double p2arr[] = {2,3,4,5};
double p3arr[] = {3,4,5,6};
double p4arr[] = {4,5,6,7};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
std::cout << "double p4arr[" << numDims << "] = ";
testPtArr(numDims, p4arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
Point p4(numDims, p4arr);
std::cout << "Point p4(" << numDims << ", p4arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c2.add(p3);
std::cout << "c2.add(p3);";
std::cout << std::endl;
c2.add(p4);
std::cout << "c2.add(p4);";
testResult();
std::cout << std::endl << "c1.interClusterDistance(): " << interClusterDistance(c1,c2);
testCheck();
std::cout << std::endl << "c1.interClusterDistance(): 8";
testClose();
}
////////////////////////////// Centroid Operations - Centroid Operations - Centroid Operations /////////////////////////
{
numDims = 4; // Dimensions in test arrays (don't go below 2)
testTitle(testNum++, header, "Centroid Operations - getClusterEdges()");
Cluster c1(numDims);
std::cout << "Cluster c1(numDims);";
std::cout << std::endl;
double p1arr[] = {1,2,3,4};
double p2arr[] = {2,3,4,5};
double p3arr[] = {3,4,5,6};
double p4arr[] = {4,5,6,7};
std::cout << "double p1arr[" << numDims << "] = ";
testPtArr(numDims, p1arr, "{", "};");
std::cout << std::endl;
std::cout << "double p2arr[" << numDims << "] = ";
testPtArr(numDims, p2arr, "{", "};");
std::cout << std::endl;
std::cout << "double p3arr[" << numDims << "] = ";
testPtArr(numDims, p3arr, "{", "};");
std::cout << std::endl;
std::cout << "double p4arr[" << numDims << "] = ";
testPtArr(numDims, p4arr, "{", "};");
std::cout << std::endl;
Point p1(numDims, p1arr);
std::cout << "Point p1(" << numDims << ", p1arr);";
std::cout << std::endl;
Point p2(numDims, p2arr);
std::cout << "Point p2(" << numDims << ", p2arr);";
std::cout << std::endl;
Point p3(numDims, p3arr);
std::cout << "Point p3(" << numDims << ", p3arr);";
std::cout << std::endl;
Point p4(numDims, p4arr);
std::cout << "Point p4(" << numDims << ", p4arr);";
std::cout << std::endl;
c1.add(p1);
std::cout << "c1.add(p1);";
std::cout << std::endl;
c1.add(p2);
std::cout << "c1.add(p2);";
std::cout << std::endl;
c1.add(p3);
std::cout << "c1.add(p3);";
std::cout << std::endl;
c1.add(p4);
std::cout << "c1.add(p4);";
testResult();
std::cout << std::endl << "c1.getClusterEdges(): " << c1.getClusterEdges();
testCheck();
std::cout << std::endl << "c1.getClusterEdges(): 6";
testClose();
}
testSectionClose(header);
}
int main(int argc, char const *argv[])
{
for( int i = 1; i < argc; i++ )
{
if( strncmp( argv[i], "--vutpp:", 8 ) == 0 )
{
std::string strVutppParam = argv[i] + 8;
const size_t seperator = strVutppParam.find( ',' );
if( seperator == std::string::npos )
return -1;
HANDLE readPipe, writePipe;
sscanf( strVutppParam.substr( 0, seperator ).c_str(), "%d", &readPipe );
sscanf( strVutppParam.substr( seperator+1 ).c_str(), "%d", &writePipe );
char readBuffer[1024], writeBuffer[1024];
DWORD dwSize = 0;
strcpy( writeBuffer, "connect" );
if( WriteFile( writePipe, writeBuffer, 1024, &dwSize, NULL ) == false || dwSize != 1024 )
return -1;
while( true )
{
if( ReadFile( readPipe, readBuffer, 1024, &dwSize, NULL ) == false || dwSize != 1024 )
return -1;
if( strncmp( readBuffer, "__VUTPP_FINISH__", 16 ) == 0 )
break;
const char* pSeperator = strchr( readBuffer, ',' );
std::string suiteName( readBuffer, pSeperator - readBuffer ), testName( pSeperator+1 );
testName += "Test";
bool bRun = false;
Test* pTest = TestRegistry::Tests();
while( pTest != NULL )
{
if( strcmp( pTest->name(), testName.c_str() ) == 0 )
{
VUTPP_Result testResult( writePipe );
pTest->run(testResult);
strcpy( writeBuffer, "-1," );
bRun = true;
if( WriteFile( writePipe, writeBuffer, 1024, &dwSize, NULL ) == false || dwSize != 1024 )
return -1;
}
pTest = pTest->getNext();
}
if( bRun == false )
{
sprintf( writeBuffer, "%d,,%s", -2, "can't find test" );
if( WriteFile( writePipe, writeBuffer, 1024, &dwSize, NULL ) == false || dwSize != 1024 )
return -1;
}
}
return 0;
}
}
TestResult tr;
return TestRegistry::runAllTests(tr);
}
