gl::Error Query11::flush(bool force) { while (!mPendingQueries.empty()) { QueryState *query = &mPendingQueries.front(); do { gl::Error error = testQuery(query); if (error.isError()) { return error; } if (!query->finished && !force) { return gl::Error(GL_NO_ERROR); } } while (!query->finished); mResultSum = MergeQueryResults(getType(), mResultSum, mResult); SafeRelease(query->beginTimestamp); SafeRelease(query->endTimestamp); SafeRelease(query->query); mPendingQueries.pop_front(); } return gl::Error(GL_NO_ERROR); }
GLboolean Query::isResultAvailable() { if (mQuery != NULL) { testQuery(); } return mStatus; }
gl::Error Query11::isResultAvailable(GLuint *available) { gl::Error error = testQuery(); if (error.isError()) { return error; } *available = (mQueryFinished ? GL_TRUE : GL_FALSE); return gl::Error(GL_NO_ERROR); }
gl::Error Query11::isResultAvailable(bool *available) { gl::Error error = testQuery(); if (error.isError()) { return error; } *available = mQueryFinished; return gl::Error(GL_NO_ERROR); }
GLuint Query11::getResult() { if (mQuery != NULL) { while (!testQuery()) { Sleep(0); // explicitly check for device loss, some drivers seem to return S_FALSE // if the device is lost if (mRenderer->testDeviceLost(true)) { return gl::error(GL_OUT_OF_MEMORY, 0); } } } return mResult; }
GLuint Query9::getResult() { if (mQuery != NULL) { while (!testQuery()) { Sleep(0); // explicitly check for device loss // some drivers seem to return S_FALSE even if the device is lost // instead of D3DERR_DEVICELOST like they should if (mRenderer->testDeviceLost(true)) { return gl::error(GL_OUT_OF_MEMORY, 0); } } } return mResult; }
GLuint Query::getResult() { if (mQuery != NULL) { while (!testQuery()) { Sleep(0); // explicitly check for device loss // some drivers seem to return S_FALSE even if the device is lost // instead of D3DERR_DEVICELOST like they should if (gl::getDisplay()->testDeviceLost()) { gl::getDisplay()->notifyDeviceLost(); return error(GL_OUT_OF_MEMORY, 0); } } } return (GLuint)mResult; }
gl::Error Query11::getResult(GLuint *params) { while (!mQueryFinished) { gl::Error error = testQuery(); if (error.isError()) { return error; } if (!mQueryFinished) { Sleep(0); } } ASSERT(mQueryFinished); *params = mResult; return gl::Error(GL_NO_ERROR); }
gl::Error Query11::getResultBase(T *params) { while (!mQueryFinished) { gl::Error error = testQuery(); if (error.isError()) { return error; } if (!mQueryFinished) { ScheduleYield(); } } ASSERT(mQueryFinished); *params = static_cast<T>(mResult); return gl::Error(GL_NO_ERROR); }
int testKeysetQuery( void ) { int status; puts( "Testing general certificate database query..." ); status = testQuery( DATABASE_KEYSET_TYPE, DATABASE_KEYSET_NAME ); if( status == CRYPT_ERROR_NOTAVAIL ) { /* Database keyset access not available */ return( CRYPT_ERROR_NOTAVAIL ); } if( status == CRYPT_ERROR_FAILED ) { puts( "This is probably because you haven't set up a database or " "data source for use\nas a key database. For this test to " "work, you need to set up a database/data\nsource with the " "name '" DATABASE_KEYSET_NAME_ASCII "'.\n" ); return( FALSE ); } if( !status ) return( FALSE ); puts( "Certificate database query succeeded.\n" ); return( TRUE ); }
int main() { testQuery(); return 0; }
/* Executes all of the individual tests against the provided FQL source instance. */ void executeTests(FQLInstancePropertySource src) { /////////////////////////////////////////////////////////////////////// /// Some general tests. These should be moved to proper section ////////////////////////////////////////////////////////////////////// testQuery(src, "IntArrayProp1 = {4, 5, 7}", true); testQuery(src, "IntArrayProp1[2] = 7", true); testQuery(src, "ANY IntArrayProp1 = 7",true); testQuery(src, "ANY IntArrayProp1 = IntScal1",true); testQuery(src, "EVERY IntArrayProp1 < 90",true); testQuery(src, "NOT ANY IntArrayProp1 = 7",false); testQuery(src, "NOT EVERY IntArrayProp1 = 7",true); ///////////////////////////////////////////////////////////////// // Boolean property tests ///////////////////////////////////////////////////////////////// // boolean-scalar-property op literal testQuery(src, "BoolScal1 = true", true); testQuery(src, "BoolScal1 <> true", false); testQuery(src, "BoolScal1 = true", true); testQuery(src, "BoolScal2 = true", false); testQuery(src, "BoolScal2 <> true", true); // boolean-scalar-property op boolean-scalar-property testQuery(src, "BoolScal1 = BoolScal1", true); testQuery(src, "BoolScal1 <> BoolScal2", true); testQuery(src, "BoolScal1 > BoolScal2", true, true); testQuery(src, "BoolScal1 < BoolScal2", true, true); testQuery(src, "BoolScal1 >= BoolScal2", true, true); testQuery(src, "BoolScal1 <= BoolScal2", true, true); testQuery(src, "BoolScal1 > BoolScal2", true, true); // Bool array to literal testQuery(src, "BoolArrayProp1 = {true, false, true }", true); testQuery(src, "BoolArrayProp2 = {true, false, true }", true); // test Bool array to array comparisons testQuery(src, "BoolArrayProp2 = BoolArrayProp2", true); testQuery(src, "BoolArrayProp2 <> BoolArrayProp2", false); testQuery(src, "BoolArrayProp1 = BoolArrayProp2", true); testQuery(src, "BoolArrayProp2 <> BoolArrayProp2", false); testQuery(src, "BoolArrayProp1 = BoolArrayProp3", true); testQuery(src, "BoolArrayProp1 <> BoolArrayProp3", false); // test invalid property name testQuery(src, "BoolArrayProp2 = BoolArrayProp9", true, true); // test invalid operators testQuery(src, "BoolArrayProp2 < BoolArrayProp2", true, true); // Invalid bool array compares testQuery(src, "BoolArrayProp2 > {true, false, true }", true, true); testQuery(src, "BoolArrayProp2 < {true, false, true }", true, true); testQuery(src, "BoolArrayProp2 >= {true, false, true }", true, true); testQuery(src, "BoolArrayProp2 <= {true, false, true }", true, true); // bool aray[x] to literal TODO // bool array[x] to boolscalar TODO ////////////////////////////////////////////////////////// // String property tests ///////////////////////////////////////////////////////// // test String-scalar-property op literal testQuery(src,"strScal1 = \'Test\'", true); testQuery(src,"strScal1 <> \'Test\'", false); testQuery(src,"strScal1 <> \'Testx\'", true); testQuery(src,"strScal1 <> \'test\'", true); testQuery(src,"strScal1 <> \'Tes\'", true); // test String-array-property op array literal testQuery(src, "StrArrayProp1 =" "{\'zero\', \'one\', \'two\', \'three\'}",true); testQuery(src, "StrArrayProp1 <>" "{\'zero\', \'one\', \'two\', \'three\'}",false); testQuery(src, "StrArrayProp1 = {\'zero\', \'one\', \'two\'}",false); testQuery(src, "StrArrayProp1 <> {\'zero\', \'one\', \'two\'}",true); // String-array-Property[index] op scalar literal testQuery(src, "StrArrayProp1[0] = \'zero\'",true); testQuery(src, "StrArrayProp1[1] = \'one\'",true); testQuery(src, "StrArrayProp1[2] = \'two\'",true); testQuery(src, "StrArrayProp1[3] = \'three\'",true); testQuery(src, "StrArrayProp1[1] = \'One\'",false); testQuery(src, "StrArrayProp1[1] <> \'One\'",true); testQuery(src, "StrArrayProp1[1] <> \'\'", true); testQuery(src, "StrArrayProp1[1] = \'\'", false); // String-array-Property[index] op scalar property // TODO // String ANY and EVERY // TODO add < and > ops testQuery(src," ANY StrArrayProp1 = \'zero\'",true); testQuery(src," ANY StrArrayProp1 = \'three\'",true); testQuery(src," ANY StrArrayProp1 = \'notAProperty\'",false); testQuery(src," EVERY StrArrayProp1 = \'three\'",false); // Test LIKE operation testQuery(src,"strScal1 LIKE \'Test\'", true); testQuery(src,"strScal1 LIKE \'T...\'", true); testQuery(src,"strScal1 LIKE \'Tes.\'", true); testQuery(src,"strScal1 LIKE \'.est\'", true); testQuery(src,"strScal1 LIKE \'.*\'", true); testQuery(src,"strScal1 NOT LIKE \'.est\'", false); testQuery(src,"strScal1 NOT LIKE \'.*\'", false); testQuery(src, "StrArrayProp1[1] LIKE \'one\'",true); testQuery(src, "StrArrayProp1[1] LIKE \'.ne\'",true); //////////////////////////////////////////////////////// // Integer properties tests //////////////////////////////////////////////////////// // integer-scalar-property op literal testQuery(src, "IntScal1 = 5", true); testQuery(src, "IntScal2 = 25", true); testQuery(src, "IntScal1 <> 5", false); testQuery(src, "IntScal2 <> 25", false); testQuery(src, "IntScal1 <> 9", true); testQuery(src, "IntScal1 > 4", true); testQuery(src, "IntScal1 < 6", true); testQuery(src, "IntScal2 <> 0", true); testQuery(src, "IntScal3 = -25123", true); testQuery(src, "IntScal4 = 0", true); testQuery(src, "Int64Scal5 = 7340031", true); testQuery(src, "Int64Scal6 = 2147483647", true); testQuery(src, "Int64Scal7 = 4067", true); // tests against hex and binary scalar integer defintions testQuery(src, "IntScal1 = 0X5", true); testQuery(src, "IntScal1 = 101B", true); testQuery(src, "IntScal2 = 0X19", true); testQuery(src, "IntScal2 < 0X1A", true); testQuery(src, "IntScal2 = 0X1A", false); testQuery(src, "IntScal2 = 11001B", true); testQuery(src, "IntScal3 = -0x6223", true); testQuery(src, "IntScal3 = -110001000100011B", true); testQuery(src, "IntScal4 = 0X0", true); testQuery(src, "IntScal4 = 0B", true); testQuery(src, "Int64Scal5 = 0X6fffff", true); testQuery(src, "Int64Scal6 = 2147483647", true); // TODO create an array property with single entry. // TODO create array property that is empty // test integerArray op array literal testQuery(src, "IntArrayProp1 = {3}", false); testQuery(src, "IntArrayProp1 = {4, 5, 7}", true); testQuery(src, "IntArrayProp1 = {4, 5, 8}", false); testQuery(src, "IntArrayProp1 = {4, 5, 8, 9}", false); testQuery(src, "IntArrayProp1 = {4, 5}", false); // test integer Array[x] op scalar testQuery(src,"IntArrayProp1[2] = 7", true); testQuery(src,"IntArrayProp1[1] = 5", true); testQuery(src,"IntArrayProp1[0] = 4", true); testQuery(src,"IntArrayProp1[2] = 8", false); testQuery(src,"IntArrayProp1[2] > 7", false); testQuery(src,"IntArrayProp1[2] < 3", false); // scalar one property against another testQuery(src, "IntScal1 = IntScal2", false); testQuery(src, "IntScal1 <> IntScal2", true); testQuery(src, "IntScal1 < IntScal2", true); testQuery(src, "IntScal1 <= IntScal2", true); testQuery(src, "IntScal1 > IntScal2", false); testQuery(src, "IntScal1 >= IntScal2", false); testQuery(src, "IntScal1 < IntScal1", false); testQuery(src, "IntScal1 > IntScal1", false); testQuery(src, "IntScal1 < Int64Scal7", true); testQuery(src, "IntScal4 = Int64Scal8", true); testQuery(src,"ANY IntArrayProp1 < 90",true); testQuery(src,"NOT EVERY IntArrayProp1 < 90",false); testQuery(src,"EVERY IntArrayProp1 < 90",true); testQuery(src,"EVERY IntArrayProp1 > 90",false); testQuery(src,"ANY IntArrayProp1 = 7",true); testQuery(src,"ANY IntArrayProp1 = 5",true); testQuery(src,"ANY IntArrayProp1 = 4",true); testQuery(src,"ANY IntArrayProp1 = 3",false); testQuery(src,"NOT ANY IntArrayProp1 = 99999",true); testQuery(src," ANY IntArrayProp1 = 99",false); testQuery(src," EVERY IntArrayProp1 = 7",false); testQuery(src,"ANY IntArrayProp1 = IntArrayProp1[0]",true); testQuery(src,"ANY IntArrayProp1 = IntArrayProp1[1]",true); testQuery(src,"ANY IntArrayProp1 = IntArrayProp1[2]",true); testQuery(src,"ANY IntArrayProp1 = IntArrayProp2[0]",true); testQuery(src,"ANY IntArrayProp1 <> IntArrayProp2[2]",true); testQuery(src,"EVERY IntArrayProp1 >= IntArrayProp1[0]",true); testQuery(src,"EVERY IntArrayProp1 <= IntArrayProp1[2]",true); testQuery(src, "IntArrayProp1[1] = IntArrayProp1[1]", true); // Generate exception error because index out of bounds testQuery(src,"ANY IntArrayProp1 = IntArrayProp1[3]",true, true); // Property Index out of bounds. Fails test since that value // does not exist testQuery(src, "IntArrayProp1[20] = 7", false); ///////////////////////////////////////////////////////// // Double type ///////////////////////////////////////////////////////// // real-scalar-property op real-literal testQuery(src,"DoubleScal1 = 20.9", true); testQuery(src,"DoubleScal1 > 0.1", true); testQuery(src,"DoubleScal1 <> 0.1", true); testQuery(src,"DoubleScal1 < 0.1", false); testQuery(src,"DoubleScal1 < 1.2", false); testQuery(src,"DoubleScal1 > 1.2", true); testQuery(src,"DoubleScal1 = 0.9", false); testQuery(src,"DoubleScal1 = 1.2", false); testQuery(src,"DoubleScal1 = 20.9999", false); // real array testQuery(src,"DoubleArrayProp1 = {1011.04, 123456.8, 0.1 }", true); testQuery(src,"DoubleArrayProp1 <> {1011.04, 123456.8, 0.1 }", false); testQuery(src,"DoubleArrayProp1[0] <>1011.04", true); testQuery(src,"ANY DoubleArrayProp1 <> 20.9", true); testQuery(src,"ANY DoubleArrayProp1 > 1011.04", true); testQuery(src,"EVERY DoubleArrayProp1 <> 99999.0", true); testQuery(src,"EVERY DoubleArrayProp1 < 999999.1", true); testQuery(src,"ANY DoubleArrayProp1 > 0.0 AND" " ANY DoubleArrayProp1 < 9.1", true ); ///////////////////////////////////////////////////////// // DateTime property type tests //////////////////////////////////////////////////////// // Datetime scalar tests testQuery(src, "dateTimeScal1 = \'19991224120000.000000+360\'", true); testQuery(src, "dateTimeScal1 <> \'19991224120000.000000+360\'", false); testQuery(src, "dateTimeScal1 <> \'20131224120000.000000+360\'", true); testQuery(src, "dateTimeScal1 < \'20131224120000.000000+360\'", true); testQuery(src, "dateTimeScal1 > \'19981224120000.000000+360\'", true); // TODO add tests for various timezones, etc. // dateTime Indexed array tests testQuery(src, "dateTimeArray1[0] = \'19991224120000.000000+360\'",true); testQuery(src, "dateTimeArray1[1] = \'20131224120000.000000+360\'",true); testQuery(src, "dateTimeArray1[0] < \'20131224120000.000000+360\'",true); // DateTime array tests testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'}", false); testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20021224120000.000000+360\'}", false); testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20011224120000.000000+360\'}", true); testQuery(src, "dateTimeArray1 <> {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20011224120000.000000+360\'}", false); // Repeat the above for single quote literal testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'}", false); testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20021224120000.000000+360\'}", false); testQuery(src, "dateTimeArray1 = {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20011224120000.000000+360\'}", true); testQuery(src, "dateTimeArray1 <> {\'19991224120000.000000+360\'," "\'20131224120000.000000+360\'," "\'20011224120000.000000+360\'}", false); testQuery(src, "ANY dateTimeArray1 = '20011224120000.000000+360\'", true); testQuery(src,"EVERY dateTimeArray1 = '20011224120000.000000+360\'", false); /////////////////////////////////////////////////////////////////// // Tests where property named does not exist. The spec defines the // results of these tests to be result of treating the non-existent // property as NULL and comparing it with the right side property. // NOTE: There is ambiguity as to what <= >=, like would mean and // we treat these so they fail the tests. /////////////////////////////////////////////////////////////////// testQuery(src, "nosuchproperty1 = 3",false); testQuery(src, "nosuchproperty2 <> 3", true); testQuery(src, "nosuchproperty3 = NULL",true); testQuery(src, "nosuchProperty4 <> NULL", false); testQuery(src, "nosuchProperty4 = \'blah\'", false); testQuery(src, "nosuchProperty4 <= \'blah\'", false); /////////////////////////////////////////////////////////////////// // Embedded Instance tests /////////////////////////////////////////////////////////////////// testQuery(src, "embeddedInstance1.noSuchName = true",false); testQuery(src, "embeddedInstance1.embedBool.noSuchName = true",false); testQuery(src, "embeddedInstance1.embedBool = true",true); testQuery(src, "embeddedInstance1.embedInt = 5",true); ///////////////////////////////////////////////////////// // Reference property type tests //////////////////////////////////////////////////////// // KS_TODO TODO Add more tests. testQuery(src,"referenceScal4 = \'myclassname.p1=1\'", true); testQuery(src, "referenceScal4 <> referenceScal3", true); testQuery(src, "referenceScal4 = referenceScal3", false); // KS_TODO add test to be sure that < > etc. do not work /////////////////////////////////////////////////////////// // AND and OR Tests ////////////////////////////////////////////////////////// testQuery(src,"IntArrayProp1[1] = 5 AND IntArrayProp1[2] = 7", true); testQuery(src, "IntScal1 = 5 OR IntScal1 = 26", true); ////////////////////////////////////////////////////////// // Error tests // ////////////////////////////////////////////////////// // Expect exception from the query, property. // IntArrayNOExist does not exist. testQuery(src, "IntArrayNoExist[1] = IntArrayProp1[1]", false); // test invalid characters on integer literals testQuery(src, "IntScal1 = 0xabcdefg", true, true); testQuery(src, "IntScal1 = 0xabcdefg", true, true); testQuery(src, "IntScal1 = 123x", true, true); //The following is illegal in the FQL spec // array-literal = "{" [scalar-literal *( "." scalar-literal ) ] "}" testQuery(src, "IntArrayProp1 = {}", false, true); // Test invalid datetime literal testQuery(src, "dateTimeScal1 = \'19991224120000.000000+abc\'", true, true); // The following generates an error it mixes types. Note that the // spec does not allow an integer as real. // The throw statement from this causes a secondary exception which // kills off the test (Unexpected Exception: parse error: syntax error // unexpected $end) //testQuery(src,"DoubleArrayProp1 <> {1.00, 123457, 0.1 }", false, true); ////////////////////////////////////////////////////////// // Test of complex queries // ////////////////////////////////////////////////////// // Tests for OR testQuery(src,"IntScal1 = 5 OR intScal2= 26", true); testQuery(src,"IntScal1 = 6 OR intScal2= 25", true); testQuery(src,"IntScal1 = 6 OR intScal2= 26", false); // Tests for AND testQuery(src,"IntScal1 = 5 AND intScal2= 25", true); testQuery(src,"IntScal1 = 6 AND intScal2= 25", false); testQuery(src,"IntScal1 = 5 AND intScal2= 26", false); testQuery(src,"( IntScal1 = 5 AND intScal2 = 25 )", true); // Tests of complex definitions involving parenthesis testQuery(src,"(IntScal1 = 5) AND (intScal2 = 25)", true); testQuery(src,"(( IntScal1 = 5) AND (intScal2 = 25 ))", true); testQuery(src,"IntScal1 = 5 AND intScal2 = 25 AND DoubleScal1 > 1.2 " "AND strScal1 = \'Test\'", true); testQuery(src,"(IntScal1 = 5 AND intScal2= 25) OR (DoubleScal1 < 1.2 " "AND strScal1= \'Test\')", true); }
void testSearch(struct DHTMessage** outMessagePtr, struct RouterModule* routerModule, struct DHTModuleRegistry* registry, struct Allocator* allocator) { *outMessagePtr = NULL; #define REQUEST_HASH "\xfc\x01\x01\x01\x01\x01\x01\x01\x21\x01\x01\x01\x01\x01\x01\x01" struct DHTMessage* callbackMessage = NULL; RouterModule_beginSearch((uint8_t*) REQUEST_HASH, testSearch_callback, &callbackMessage, routerModule); struct DHTMessage* outMessage = *outMessagePtr; assert(outMessage != NULL); // Need to be able to work around the fact that the string contains nulls. #define EXPECTED_OUTPUT(tid) \ "d" \ "1:q" "2:fn" \ "3:tar" "16:" REQUEST_HASH \ "4:txid" "2:" tid \ "e" for (uint32_t i = 0; i < (uint32_t) outMessage->length; i++) { //printf("%.2X", (unsigned int) outMessage->bytes[i] & 0xFF); } //printf("\n%s\n", outMessage->bytes); //printf("\n%s\n", outMessage->peerAddress); assert(outMessage->length == strlen(EXPECTED_OUTPUT("xx"))); assert(memcmp(outMessage->bytes, EXPECTED_OUTPUT("8\x00"), outMessage->length) == 0); //assert(strcmp(outMessage->address->networkAddress, " 00014 ") == 0); // In a normal DHT, 00014 is the closest node, however, 00011 has sent us a message in // testQuery() and thus his reach is 1 and he beats all other nodes which are 0-reach. // Search queries are allowed to select nodes which are further from the target than us. assert(strcmp((char*) &outMessage->address->networkAddress_be, " 00011 ") == 0); #undef EXPECTED_OUTPUT #define CRAFTED_REPLY(tid) \ "d" \ "1:n" "200:" \ "97bkjs8qpd5hc1mubj3qbfyqzmzxp3rg" " 00017 " \ "by1szn122nqk1vncjtm612444rlh6ztr" " 00018 " \ "u42wbyr0wznhkbqr1r7u627dwsvb8853" " 00019 " \ "97bkjs8qpd5hc1mubj3qbfyqzmzxp3rg" " 00020 " \ "2lr8w01hhrxqng8mm8nf3nlwh5nyxzyl" " 00021 " \ "4:txid" "2:" tid \ "e" struct Address address = { .key = "ponmlkjihgzyxwvutsrq \0" }; memcpy(&address.networkAddress_be, " 00011 ", 8); struct DHTMessage message = { .length = strlen(CRAFTED_REPLY("xx")), .allocator = allocator, .address = &address }; memcpy(message.bytes, CRAFTED_REPLY("8\x00"), message.length); // memcpy(message.peerAddress, peerAddress, 18); *outMessagePtr = NULL; DHTModules_handleIncoming(&message, registry); // Make sure the callback was called. assert(callbackMessage != NULL); // Make sure the node was promoted for it's fine service :P struct Address addr; memset(&addr, 0, sizeof(struct Address)); memcpy(&addr.key, "ponmlkjihgzyxwvutsrq \0", 32); struct Node* node1 = NodeStore_getNode(routerModule->nodeStore, &addr); //printf("node reach = %d", node1->reach); assert(node1->reach == 1601894175); /* outMessage = *outMessagePtr; assert(outMessage != NULL); assert(strcmp("000022", outMessage->peerAddress) == 0);*/ } int main() { char buffer[1<<20]; struct Allocator* allocator = BufferAllocator_new(buffer, 1<<20); struct DHTModuleRegistry* registry = DHTModules_new(allocator); ReplyModule_register(registry, allocator); struct RouterModule* routerModule = RouterModule_register(registry, allocator, (uint8_t*) MY_ADDRESS, event_base_new(), NULL); SerializationModule_register(registry, allocator); struct DHTMessage* outMessage; // dummy "network module" which just catches outgoing messages and makes them available. TestFramework_registerOutputCatcher(&outMessage, registry, allocator); struct Address addr; // damn this \0, was a mistake but to fix it would break all of the hashes :( #define ADD_NODE(address, netAddr) \ memset(&addr, 0, sizeof(struct Address)); \ memcpy(&addr.networkAddress_be, netAddr " ", 8); \ memcpy(&addr.key, (uint8_t*) address " \0", 32); \ RouterModule_addNode(&addr, routerModule) // most significant byte --vv ADD_NODE("qponmlkjihgzyxwvutsr", " 00001"); // fce8:573b:d230:ca3b 1c4e:f9d6 0632:9445 ADD_NODE("bcdefghijklmnopqrstu", " 00002"); // fc65:9f4c:c061:84f9 2018:6e31 de3d:3bcf ADD_NODE("onmlkjihgzyxwvutsrqp", " 00003"); // fcbe:26ce:5c7a:9a0f 205b:358c b8f8:08bb // search target --> fc01:0101:0101:0101 2101:0101 0101:0101 ADD_NODE("mlkjihgzyxwvutsrqpon", " 00004"); // fc08:d8e6:e000:c95c 2192:d676 94f9:63a7 ADD_NODE("lkjihgzyxwvutsrqponm", " 00005"); // fc7c:6c8d:e5ee:cf99 2f16:06c7 95ca:0c0b ADD_NODE("fghijklmnopqrstuvwxy", " 00006"); // fcac:3963:cbd1:6390 3e83:be89 a23f:ce66 ADD_NODE("jihgzyxwvutsrqponmlk", " 00007"); // fc2e:3a5e:5e47:9769 4964:8f7f 3894:8c07 ADD_NODE("kjihgzyxwvutsrqponml", " 00008"); // fc37:10aa:39ed:12bf 4a70:1507 dbe9:a054 ADD_NODE("cdefghijklmnopqrstuv", " 00009"); // fcaa:113e:88da:d432 65f0:1c14 38d9:b656 // this node --> fc39:c3ba:c711:00aa 666d:90b0 1ab6:e8c3 ADD_NODE("rqponmlkjihgzyxwvuts", " 00010"); // fc43:41e7:2adc:d13b 78ce:1959 e4cc:c76e ADD_NODE("ponmlkjihgzyxwvutsrq", " 00011"); // fc83:2ab3:b65b:9ad1 7e7b:f61f e0fa:cb40 ADD_NODE("efghijklmnopqrstuvwx", " 00012"); // fc08:0ba6:a8e2:7731 9dae:f9fd e502:767c ADD_NODE("abcdefghijklmnopqrst", " 00013"); // fc81:cab3:eda0:61aa 9fff:bdde 0168:f0dd ADD_NODE("ihgzyxwvutsrqponmlkj", " 00014"); // fc49:8fc7:7e43:981a bac1:0b5d 77fb:8818 ADD_NODE("nmlkjihgzyxwvutsrqpo", " 00015"); // fc69:61a1:2bec:1444 bb9e:47d1 f8b3:a6a0 ADD_NODE("defghijklmnopqrstuvw", " 00016"); // fc40:1d18:89a6:9a7e c8af:20fd 5c9f:8140 ADD_NODE("ghijklmnopqrstuvwxyz", " 00017"); // fc74:0f2e:d77a:e5e7 cf4e:8fe9 7791:98e1 #undef ADD_NODE testQuery(&outMessage, registry, allocator); testSearch(&outMessage, routerModule, registry, allocator); return 0; }