static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult) { TestSet oldSet (set); ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); ConstTestNodeIterator end = ConstTestNodeIterator::end(root); int numRemoved = 0; for (; iter != end; ++iter) { const TestNode* node = *iter; if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node)) { const TestCase* testCase = static_cast<const TestCase*>(node); if (isExecutedInBatch(batchResult, testCase)) { set.removeCase(testCase); numRemoved += 1; } } } return numRemoved; }
static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet) { DE_ASSERT(testSet.hasNode(node)); TestNodeType nodeType = node->getNodeType(); if (nodeType != TESTNODETYPE_ROOT) str << node->getName(); if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP) { const TestGroup* group = static_cast<const TestGroup*>(node); bool isFirst = true; str << "{"; for (int ndx = 0; ndx < group->getNumChildren(); ndx++) { const TestNode* child = group->getChild(ndx); if (testSet.hasNode(child)) { if (!isFirst) str << ","; writeCaseListNode(str, child, testSet); isFirst = false; } } str << "}"; } }
void runAll(TestSet& tests) { vector<double> times; times.reserve(repeatCount); vector<unsigned char> v; while(tests.next(v)) { // give a particular alignment only if necessary unique_ptr<aligned_alloc> aa; memory<unsigned char> m(v); if(testAlignment) { bool alignEnd = tests.alignEnd(); int alignOfs = tests.alignment(); if(forceAlignment) { alignEnd = forceAlignmentFromEnd; alignOfs = forceAlignmentOfs; } // aligned_alloc doesn't do empty allocations, so // put those on the zero page if(!m.size()) { int ptr = alignEnd ? (64 - alignOfs) : alignOfs; m = memory<unsigned char>((unsigned char*) ptr, (unsigned char*) ptr); } else { aa = unique_ptr<aligned_alloc>(new aligned_alloc( v, alignEnd ? aligned_alloc::END_OF_PAGE : aligned_alloc::START_OF_PAGE, alignOfs)); m = memory<unsigned char>(aa.get()->begin(), aa.get()->end()); } } if(RESULT_GOOD != run(tests.description(), m) && dieOnFirstFailure) { printf("\n\nStopping early due to error\n"); break; } } printf("\n\n"); printf("Good: %0d (%0d good utf8, %0d bad utf8), confused: %0d, failed: %0d\n", totals[RESULT_GOOD], goodAccept, goodReject, totals[RESULT_CONFUSION], totals[RESULT_FAILURE]); if(printTimings) { for(TimingResult& r: timingResults) { printf("%s,\"%s\",%lld", r.validator->name().c_str(), r.itemName.c_str(), (long long) r.itemLength); for(double d : r.timings) printf(",%g", d); printf("\n"); } } }
static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet) { ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); ConstTestNodeIterator end = ConstTestNodeIterator::end(root); int numCases = 0; for (; (iter != end) && (numCases < maxCasesInSet); ++iter) { const TestNode* node = *iter; if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node)) { const TestCase* testCase = static_cast<const TestCase*>(node); requestSet.addCase(testCase); numCases += 1; } } }
static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult) { ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); ConstTestNodeIterator end = ConstTestNodeIterator::end(root); for (; iter != end; ++iter) { const TestNode* node = *iter; if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node)) { const TestCase* testCase = static_cast<const TestCase*>(node); if (!isExecutedInBatch(batchResult, testCase)) executeSet.addCase(testCase); } } }
void BatchExecutor::launchTestSet (const TestSet& testSet) { std::ostringstream caseList; XE_CHECK(testSet.hasNode(m_root)); XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT); writeCaseListNode(caseList, m_root, testSet); m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str()); }
bool tStrSet( LibTest & tester ) { { TestSet t; const char * string[] = {"one","two","three","four", 0}; for( size_t f = 0; string[f]; f++ ) { cout << f << endl; t.insert( string[f] ); } for( TestSet::iterator them = t.begin(); them != t.end(); them++ ) { cout << (*them) << endl; } } return( true ); }
bool TestOptimizations::doTest() { typedef std::deque<unsigned int> TestSet; StringVector testVector = enumerateTests(getPTXFiles(path), getOptimizations(optimizations)); status << " Enumerated " << testVector.size() << " tests\n"; TestSet tests; for(auto test = testVector.begin(); test != testVector.end(); ++test) { tests.push_back(std::distance(testVector.begin(), test)); } hydrazine::Timer timer; timer.start(); unsigned int count = 0; for(unsigned int i = 0, e = tests.size(); i != e; ++i) { if(timer.seconds() > timeLimit) break; unsigned int index = random() % tests.size(); TestSet::iterator testPosition = tests.begin() + index; std::string test = testVector[*testPosition]; status << " Running test '" << test << "'\n"; if(!runTest(test)) return false; tests.erase(testPosition); ++count; } status << "Finished running " << count << " tests...\n"; return true; }
void randomizedTest() { const int cycles = 10000; const int valueRange = 1000; const int removeProbability = 40; //Percent TestSet set; srand(time(nullptr)); for(int a = 0; a < cycles; ++a) { if(a % (cycles / 10) == 0) { qDebug() << "cycle" << a; } bool remove = (rand() % 100) < removeProbability; if(remove && set.size()) { set.remove(set.getItem(rand() % set.size())); }else{ int value = (rand() % valueRange) + 1; set.add(value); } set.verify(); } qDebug() << "Performance embedded list: insertion:" << toSeconds(emb_insertion) << "removal:" << toSeconds(emb_removal) << "contains:" << toSeconds(emb_contains) << "iteration:" << toSeconds(emb_iteration); qDebug() << "Performance std::set: insertion:" << toSeconds(std_insertion) << "removal:" << toSeconds(std_removal) << "contains:" << toSeconds(std_contains) << "iteration:" << toSeconds(std_iteration); }
void sequentialTest() { TestSet set; set.add(5); set.verify(); set.remove(5); set.verify(); set.add(3); set.verify(); set.add(4); set.verify(); set.add(7); set.verify(); set.remove(3); set.verify(); set.remove(7); set.verify(); set.add(6); set.verify(); set.add(1); set.verify(); set.add(9); set.verify(); set.remove(4); set.verify(); set.remove(9); set.verify(); set.add(1); set.verify(); set.add(2); set.verify(); set.add(3); set.verify(); set.add(4); set.verify(); set.add(5); set.verify(); set.remove(1); set.verify(); set.remove(3); set.verify(); set.add(15); set.verify(); set.add(16); set.verify(); set.add(17); set.verify(); set.add(18); set.verify(); set.remove(18); set.verify(); set.remove(17); set.verify(); set.add(9); set.verify(); }
int main(int argc, char *argv[]) { double genStart = 0; double genEnd = 0; double verStart = 0; double verEnd = 0; // Sample crypto parameters ZZ publicKey; ZZ secretKey; Paillier::keyGen(publicKey, secretKey, KEY_SIZE); ZZ modulus = publicKey * publicKey; ZZ helpRecovery = InvMod(publicKey % secretKey, secretKey); srand ( unsigned ( time(0) ) ); int numTestSets = 25; // Should be 2500, but that will take forever vector<int> permutation; for (int i = 0; i < numTestSets; i++) { permutation.push_back(i); } random_shuffle(permutation.begin(), permutation.end()); // Generate test sets int t = NumBits(PRICE_LIMIT) + 1; vector<TestSet*> testSets; vector<OpenedTestSet*> openedTestSets; genStart += clock(); for (int i = 0; i < numTestSets; i++) { OpenedTestSet* nextOpenedTestSet = new OpenedTestSet(); // Add t encryptions of 0 for (int i = 0; i < t; i++) { ZZ ciphertext, randomness, randomnessPow; Paillier::encAux(publicKey, ZZ(0), ciphertext, randomness, randomnessPow); OpenedTest nextOpenedTest(ciphertext, ZZ(0), randomness, randomnessPow); nextOpenedTestSet->push_back(nextOpenedTest); } // Add encryptions of 2^0, ..., 2^{t-1} for (int i = 0; i < t; i++) { ZZ plaintext = power2_ZZ(i); ZZ ciphertext, randomness, randomnessPow; Paillier::encAux(publicKey, plaintext, ciphertext, randomness, randomnessPow); OpenedTest nextOpenedTest(ciphertext, plaintext, randomness, randomnessPow); nextOpenedTestSet->push_back(nextOpenedTest); } random_shuffle(nextOpenedTestSet->begin(), nextOpenedTestSet->end()); TestSet* nextTestSet = new TestSet(); for (OpenedTestSet::iterator it = nextOpenedTestSet->begin() ; it != nextOpenedTestSet->end(); ++it) { nextTestSet->push_back(it->ciphertext); } testSets.push_back(nextTestSet); openedTestSets.push_back(nextOpenedTestSet); } genEnd += clock(); // Reveal and verify test sets verStart += clock(); int revealed = 5; // Should be 500 int testSetIndex = 0; for (; testSetIndex < revealed; testSetIndex++) { int nextIndex = permutation[testSetIndex]; if (!verifyTestSet(testSets[nextIndex], openedTestSets[nextIndex])) { cerr << "TEST SET " << testSetIndex << " FAILED TO VERIFY!!!" << endl; } } verEnd += clock(); // Sample and publish bids vector<int> bids; int winner = 0; int winningBid = 0; for(int i = 0; i < N_BUYERS; i++) { int nextBid = RandomBnd(PRICE_LIMIT); if (nextBid > winningBid) { winner = i; winningBid = nextBid; } bids.push_back(nextBid); } vector<ZZ> commitments; vector<ZZ> openings; for(int i = 0; i < N_BUYERS; i++) { ZZ ciphertext; ZZ randomness; Paillier::enc(publicKey, ZZ(bids[i]), ciphertext, randomness); commitments.push_back(ciphertext); openings.push_back(randomness); } // Check encryptions for(int i = 0; i < N_BUYERS; i++) { if (Paillier::com(publicKey, ZZ(bids[i]), openings[i]) != commitments[i]) { cerr << "BID " << i << " FAILED TO VERIFY!!!" << endl; } } cout << "WINNER IS BIDDER #" << winner << " WITH BID " << winningBid << endl; for(int i = 0; i < N_BUYERS; i++) { // Generate and check proof that bids[i] < 2^t genStart += clock(); RangeProof nextProof = prove(publicKey, ZZ(bids[i]), commitments[i], openings[i], openedTestSets[permutation[testSetIndex]]); genEnd += clock(); verStart += clock(); if (!verifyProof(publicKey, nextProof, commitments[i], testSets[permutation[testSetIndex]])) { cerr << "PROOF THAT BID " << i << " IN RANGE FAILED TO VERIFY!!!" << endl; } else { cout << "VERIFIED BID " << i << " IN RANGE" << endl; } verEnd += clock(); testSetIndex++; if (i != winner) { // Generate and check proof that bids[i] <= winningBid ZZ ciphertext = MulMod(commitments[winner], InvMod(commitments[i], modulus), modulus); ZZ help = PowerMod(ciphertext % publicKey, helpRecovery, publicKey); genStart += clock(); RangeProof nextProof = prove( publicKey, ZZ(winningBid - bids[i]), ciphertext, help, openedTestSets[permutation[testSetIndex]]); genEnd += clock(); verStart += clock(); if (!verifyProof(publicKey, nextProof, ciphertext, testSets[permutation[testSetIndex]])) { cerr << "PROOF THAT BID " << i << " LOSES FAILED TO VERIFY!!!" << endl; } else { cout << "VERIFIED BID " << i << " LOSES" << endl; } verEnd+= clock(); testSetIndex++; } cout << "Proof preparation time: " << 1.0 * (genEnd-genStart) / CLOCKS_PER_SEC << endl; cout << "Proof verification time: " << 1.0 * (verEnd-verStart) / CLOCKS_PER_SEC << endl; } }