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;
}
}
