virtual int Run() { LogText("LocklessTest::Producer::Run started.\n"); for (int testVal = 0; testVal < TestIterations; testVal++) { TestData d; d.Set(testVal); { //Lock::Locker scope(&TestLock); TestDataUpdater.SetState(d); } FirstItemWritten = true; // Spin a bit for(int j = 0; j < 1000; j++) { Dummy2 = j; } if (testVal % (TestIterations/30) == 0) { LogText("LocklessTest::Producer - %5.2f%% done\n", 100.0f * (float)testVal/(float)TestIterations); } } LogText("LocklessTest::Producer::Run exiting.\n"); return 0; }
// Test GJRGARCH model calibration using DAX volatility data. bool AdjointGjrgarchModelTest::testGJRGARCHmodel() { BOOST_TEST_MESSAGE("Testing adjoint differentiation for GJRGARCH model calibration using DAX volatility data..."); TestData testData; size_t n = 2; GJRGARCHmodelTest test(n, &testData); // Tape recording. cl::Independent(test.volatility_); test.calculateTotalError(); cl::tape_function<double> f(test.volatility_, test.totalCalibrationErrorValue_); // Forward mode derivatives calculation. test.forwardResults_.resize(n); std::vector<double> dX(n, 0); for (size_t i = 0; i < n; i++) { dX[i] = 1; test.forwardResults_[i] = f.Forward(1, dX)[0]; dX[i] = 0; } // Reverse mode derivatives calulation. test.reverseResults_ = f.Reverse(1, std::vector<double>(1, 1)); test.calcAnalytical(); return test.check() && testData.makeOutput(); }
void DataDrivenCalendarTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par */) { if (driver != NULL) { if (exec) { // logln("Begin "); } const DataMap *info= NULL; UErrorCode status= U_ZERO_ERROR; TestData *testData = driver->createTestData(index, status); if (U_SUCCESS(status)) { name = testData->getName(); if (testData->getInfo(info, status)) { log(info->getString("Description", status)); } if (exec) { log(name); logln("---"); logln(""); processTest(testData); } delete testData; } else { name = ""; } } else { dataerrln("format/DataDriven*Test data (calendar.res) not initialized!"); name = ""; } }
void FakeVimPlugin::test_vim_marks() { TestData data; setup(&data); data.setText(" abc" N " def" N " ghi"); data.doKeys("ma"); data.doKeys("ma"); data.doKeys("jmb"); data.doKeys("j^mc"); KEYS("'a", " " X "abc" N " " "def" N " " "ghi"); KEYS("`a", X " " "abc" N " " "def" N " " "ghi"); KEYS("`b", " " "abc" N X " " "def" N " " "ghi"); KEYS("'b", " " "abc" N " " X "def" N " " "ghi"); KEYS("`c", " " "abc" N " " "def" N " " X "ghi"); KEYS("'c", " " "abc" N " " "def" N " " X "ghi"); KEYS("`b", " " "abc" N X " " "def" N " " "ghi"); KEYS("'c", " " "abc" N " " "def" N " " X "ghi"); KEYS("`'", " " "abc" N X " " "def" N " " "ghi"); KEYS("`a", X " " "abc" N " " "def" N " " "ghi"); KEYS("''", " " "abc" N " " X "def" N " " "ghi"); KEYS("`'", X " " "abc" N " " "def" N " " "ghi"); KEYS("`'", " " "abc" N " " X "def" N " " "ghi"); }
/** * @brief Self [co]variance matrix between the test data, Kss(Z, Z) * @param [in] logHyp The log hyperparameters * - logHyp(0) = \f$\log(l)\f$ * - logHyp(1) = \f$\log(\sigma_f)\f$ * @param [in] testData The test data * @param [in] fVarianceVector Flag for the return value * - fVarianceVector = true : return \f$\mathbf{k}_{**} \in \mathbb{R}^{M \times 1}, \mathbf{k}_{**}^i = k(\mathbf{Z}_i, \mathbf{Z}_i)\f$ (default) * - fVarianceVector = false: return \f$\mathbf{K}_{**} = \mathbf{K}(\mathbf{Z}, \mathbf{Z}) \in \mathbb{R}^{M \times M}\f$,\n * which can be used for Bayesian Committee Machines. * @return A matrix pointer\n * - Mx1 (fVarianceVector == true) * - MxM (fVarianceVector == false)\n * M: The number of test data */ static MatrixPtr Kss(const Hyp &logHyp, const TestData<Scalar> &testData, const bool fVarianceVector = true) { // The number of test data const int M = testData.M(); // Some constant values const Scalar sigma_f2 = exp(static_cast<Scalar>(2.0) * logHyp(1)); // sigma_f^2 // Output MatrixPtr pKss; // K: self-variance vector (Mx1) if(fVarianceVector) { // k(z, z) = sigma_f^2 pKss.reset(new Matrix(M, 1)); pKss->fill(sigma_f2); } // K: self-covariance matrix (MxM) else { // K(r) MatrixPtr pAbsDistXsXs = PairwiseOp<Scalar>::sqDist(testData.pXs()); // MxM pAbsDistXsXs->noalias() = pAbsDistXsXs->cwiseSqrt(); pKss = K(logHyp, pAbsDistXsXs); } return pKss; }
static void OutputTestData(const TestData &v) { for (TestData::const_iterator i = v.begin(); i != v.end(); ++i) { cerr << i->first << ": " << i->second << endl; } }
virtual void onRead(TestData &datum) { if (count==nframes) return; double now=Time::now(); double origT=datum.get(); unsigned int pl=datum.getPayloadSize(); #ifdef USE_PARALLEL_PORT static ppEventDebugger pp(0x378); pp.set(); pp.reset(); #endif TestData &nd=outPort.prepare(); nd.set(origT); nd.resize(pl); outPort.write(true); if (wait<=0) { double dT=(now-origT)*1000; delay+=dT; delaySq+=(dT*dT); count++; latencies.push_back(Report(dT, pl)); } else wait--; }
void FakeVimPlugin::test_vim_delete() { TestData data; setup(&data); data.setText("123" N "456"); KEYS("x", "23" N "456"); KEYS("dd", "456"); KEYS("2x", "6"); KEYS("dd", ""); data.setText("void main()"); KEYS("dt(", "()"); data.setText("void main()"); KEYS("df(", ")"); data.setText("void main()"); KEYS("wD", "void "); KEYS("ggd$", ""); data.setText("abc def ghi"); KEYS("2dw", X "ghi"); data.setText("abc def ghi"); KEYS("d2w", X "ghi"); data.setText("abc " N " def" N " ghi" N "jkl"); KEYS("3dw", X "jkl"); data.setText("abc " N " def" N " ghi" N "jkl"); KEYS("d3w", X "jkl"); }
virtual threadReturn_t Run() { LogText("LocklessTest::Consumer::Run started.\n"); while (!FirstItemWritten) { // spin until producer wrote first value... } TestData d; int oldValue = 0; int newValue; do { { //Lock::Locker scope(&TestLock); d = TestDataUpdater.GetState(); } newValue = d.ReadAndCheckConsistency(oldValue); // Values should increase or stay the same! if (newValue < oldValue) { LogText("LocklessTest Fail - %d after %d; delta = %d\n", newValue, oldValue, newValue - oldValue); // OVR_ASSERT(0); } if (oldValue != newValue) { oldValue = newValue; if (oldValue % (TestIterations/30) == 0) { LogText("LocklessTest::Consumer - %5.2f%% done\n", 100.0f * (float)oldValue/(float)TestIterations); } } // Spin a while for (int j = 0; j< 300; j++) { Dummy3 = j; } } while (oldValue < (TestIterations * 99 / 100)); LogText("LocklessTest::Consumer::Run exiting.\n"); return NULL; }
void FakeVimPlugin::test_vim_copy_paste() { TestData data; setup(&data); data.setText("123" N "456"); KEYS("llyy2P", X "123" N "123" N "123" N "456"); data.setText("123" N "456"); KEYS("yyp", "123" N X "123" N "456"); KEYS("2p", "123" N "123" N X "123" N "123" N "456"); data.setText("123 456"); KEYS("yw2P", "123 123" X " 123 456"); KEYS("2p", "123 123 123 123" X " 123 456"); data.setText("123" N "456"); KEYS("2yyp", "123" N X "123" N "456" N "456"); data.setText("123" N "456"); KEYS("2yyP", X "123" N "456" N "123" N "456"); data.setText("123" N "456" N "789"); KEYS("ddp", "456" N X "123" N "789"); // block-select middle column, copy and paste twice data.setText("123" N "456"); KEYS("l<C-v>j\"xy2\"xp", "12" X "223" N "45556"); data.setText("123" N "456" N "789"); KEYS("wyiw" "wviwp", "123" N "456" N "45" X "6"); }
// copy constructor for batch processing TestData(const TestData &other, const int startRow, const int n) { assert(other.M() > 0); assert(startRow <= other.M()); assert(n > 0); if(other.M() > 0 && startRow <= other.M() && n > 0) { //m_pXs.reset(new Matrix(n, other.D())); //m_pXs->noalias() = other.m_pXs->middleRows(startRow, n); m_pXs.reset(new Matrix(other.m_pXs->middleRows(startRow, n))); } }
void Runner::start() { char date[5] = "date"; curSampleSize = minSampleSize; std::vector <Coordinate> coords; TestData data; BruteForce bruteforce; QuickHull quickhull; Jarvis jarvis; std::cout << "\n==========================================\n"; std::cout << "\n Convex Hull Analyzer \n"; std::cout << "\n====== " << exec(date) << " ======\n\n"; while (curSampleSize <= maxSampleSize) { std::vector <Coordinate> random, homogeneous, sorted, reverse, circular; random = data.generateRandom(curSampleSize, bounds); sorted = data.generateSorted(curSampleSize, bounds); reverse = data.generateReverseSorted(curSampleSize, bounds); circular = data.generateCircle(curSampleSize); for (int i = 0; i < 5; ++i) { // Quick Hull Algorithm save(test(quickhull, random, "random")); save(test(quickhull, sorted, "sorted")); save(test(quickhull, reverse, "reverse")); save(test(quickhull, circular, "circular")); // Jarvis March Algorithm save(test(jarvis, random, "random")); save(test(jarvis, sorted, "sorted")); save(test(jarvis, reverse, "reverse")); if (curSampleSize <= 100000) { // takes too long after 100k points save(test(jarvis, circular, "circular")); } // Brute Force Algorithm if (curSampleSize <= 100000) { // takes too long after 100k points save(test(bruteforce, random, "random")); save(test(bruteforce, sorted, "sorted")); save(test(bruteforce, reverse, "reverse")); save(test(bruteforce, circular, "circular")); } } curSampleSize = increaseSampleSize(curSampleSize); } }
TestData readXMLDoc() { XMLDocument doc; #ifdef WIN32 XMLCheckResult(doc.LoadFile("../../test/mpw_tests.xml")); #else XMLCheckResult(doc.LoadFile("mpw_tests.xml")); #endif TestData data; XMLNode * pRoot = doc.FirstChild(); if (pRoot == 0) return data; XMLElement * pListElement = pRoot->FirstChildElement("case"); TestData testData; while (pListElement != 0) { //We have a test case. Allocate memory for it. TestCase testCase; //Get the ID of this case std::string id = pListElement->Attribute("id"); std::cout << "ID: " << id << std::endl; //Now check if we have a parent. const char* pParent = pListElement->Attribute("parent"); if (pParent) { testCase = testData.at(pParent); } //Now fill in the data from this node. XMLElement * pNodeListElement = pListElement->FirstChildElement(); while (pNodeListElement != 0) { const char* name = pNodeListElement->Name(); const char* value = pNodeListElement->GetText(); if (value != 0) { testCase[name] = value; std::cout << name << ": " << testCase[name] << std::endl; } else { testCase[name] = ""; std::cout << name << ": " << "null" << std::endl; } pNodeListElement = pNodeListElement->NextSiblingElement(); } testData[id] = testCase; pListElement = pListElement->NextSiblingElement("case"); } return testData; }
int main() { ifstream fin; HashTable< TestData, string> accountTable( 8 ); string firstName, passw; TestData accountInfo; fin.clear(); fin.open( "password.dat" ); while( fin.good() ) { fin >> firstName; fin >> passw; if( fin.good() ) { accountInfo.setKey( firstName ); accountInfo.setPassword( passw ); accountTable.insert( accountInfo ); } } accountTable.showStructure(); cout << "Login: "******"Password: "******"Authentication successful" << endl; } else { cout << "Authentication failure" << endl; } } else { cout << "Authentication failure" << endl; } cout << "Login: "; } return 0; }
void FakeVimPlugin::test_vim_block_selection() { TestData data; setup(&data); data.setText("int main(int /* (unused) */, char *argv[]);"); KEYS("f(", "int main" X "(int /* (unused) */, char *argv[]);"); KEYS("da(", "int main" X ";") data.setText("int main(int /* (unused) */, char *argv[]);"); KEYS("f(", "int main" X "(int /* (unused) */, char *argv[]);"); KEYS("di(", "int main(" X ");") data.setText("int main(int /* (unused) */, char *argv[]);"); KEYS("2f)", "int main(int /* (unused) */, char *argv[]" X ");"); KEYS("da(", "int main" X ";") data.setText("int main(int /* (unused) */, char *argv[]);"); KEYS("2f)", "int main(int /* (unused) */, char *argv[]" X ");"); KEYS("di(", "int main(" X ");") data.setText("{ { { } } }"); KEYS("2f{l", "{ { {" X " } } }") KEYS("da{", "{ { " X " } }") KEYS("da{", "{ " X " }") data.setText("{ { { } } }"); KEYS("2f{l", "{ { {" X " } } }") KEYS("2da{", "{ " X " }") data.setText("{" N " { " N " } " N "}"); KEYS("di{", "{" N "}") }
void FakeVimPlugin::test_advanced_commands() { TestData data; setup(&data); // subcommands data.setText("abc" N " xxx" N " xxx" N "def"); COMMAND("%s/xxx/ZZZ/g|%s/ZZZ/OOO/g", "abc" N " OOO" N " " X "OOO" N "def"); // undo/redo all subcommands COMMAND(":undo", "abc" N X " xxx" N " xxx" N "def"); COMMAND(":redo", "abc" N X " OOO" N " OOO" N "def"); // redundant characters COMMAND("::: %s/\\S\\S\\S/ZZZ/g | :::: %s/ZZZ/XXX/g ", "XXX" N " XXX" N " XXX" N X "XXX"); }
void FakeVimPlugin::test_vim_transform_numbers() { TestData data; setup(&data); data.setText("8"); KEYS("<c-a>", X "9"); KEYS("<c-x>", X "8"); KEYS("<c-a>", X "9"); KEYS("<c-a>", "1" X "0"); KEYS("<c-a>", "1" X "1"); KEYS("5<c-a>", "1" X "6"); KEYS("10<c-a>", "2" X "6"); KEYS("h100<c-a>", "12" X "6"); KEYS("100<c-x>", "2" X "6"); KEYS("10<c-x>", "1" X "6"); KEYS("5<c-x>", "1" X "1"); KEYS("5<c-x>", X "6"); KEYS("6<c-x>", X "0"); KEYS("<c-x>", "-" X "1"); KEYS("h10<c-x>", "-1" X "1"); KEYS("h100<c-x>", "-11" X "1"); KEYS("h889<c-x>", "-100" X "0"); // increase nearest number data.setText("x-x+x: 1 2 3 -4 5"); KEYS("8<c-a>", "x-x+x: " X "9 2 3 -4 5"); KEYS("l8<c-a>", "x-x+x: 9 1" X "0 3 -4 5"); KEYS("l8<c-a>", "x-x+x: 9 10 1" X "1 -4 5"); KEYS("l16<c-a>", "x-x+x: 9 10 11 1" X "2 5"); KEYS("w18<c-x>", "x-x+x: 9 10 11 12 -1" X "3"); KEYS("hh13<c-a>", "x-x+x: 9 10 11 12 " X "0"); KEYS("B12<c-x>", "x-x+x: 9 10 11 " X "0 0"); KEYS("B11<c-x>", "x-x+x: 9 10 " X "0 0 0"); KEYS("B10<c-x>", "x-x+x: 9 " X "0 0 0 0"); KEYS("B9<c-x>", "x-x+x: " X "0 0 0 0 0"); KEYS("B9<c-x>", "x-x+x: -" X "9 0 0 0 0"); data.setText("-- 1 --"); KEYS("<c-x>", "-- " X "0 --"); KEYS("<c-x><c-x>", "-- -" X "2 --"); KEYS("2<c-a><c-a>", "-- " X "1 --"); KEYS("<c-a>2<c-a>", "-- " X "4 --"); KEYS(".", "-- " X "6 --"); }
void FakeVimPlugin::test_vim_repeat() { TestData data; setup(&data); // delete line data.setText("abc" N "def" N "ghi"); KEYS("dd", X "def" N "ghi"); KEYS(".", X "ghi"); // delete to next word data.setText("abc def ghi jkl"); KEYS("dw", X "def ghi jkl"); KEYS("w.", "def " X "jkl"); KEYS("gg.", X "jkl"); // change in word data.setText("WORD text"); KEYS("ciwWORD<esc>", "WOR" X "D text"); KEYS("w.", "WORD WOR" X "D"); /* QTCREATORBUG-7248 */ data.setText("test tex" X "t"); KEYS("vbcWORD<esc>", "test " "WOR" X "D"); KEYS("bb.", "WOR" X "D WORD"); // delete selected range data.setText("abc def ghi jkl"); KEYS("viwd", X " def ghi jkl"); KEYS(".", X "f ghi jkl"); KEYS(".", X "hi jkl"); // delete two lines data.setText("abc" N "def" N "ghi" N "jkl" N "mno"); KEYS("Vjx", X "ghi" N "jkl" N "mno"); KEYS(".", X "mno"); // delete three lines data.setText("abc" N "def" N "ghi" N "jkl" N "mno" N "pqr" N "stu"); KEYS("d2j", X "jkl" N "mno" N "pqr" N "stu"); KEYS(".", X "stu"); // replace block selection data.setText("abcd" N "d" X "efg" N "ghij" N "jklm"); KEYS("<c-v>jlrX", "abcd" N "d" X "XXg" N "gXXj" N "jklm"); KEYS("gg.", "XXcd" N "XXXg" N "gXXj" N "jklm"); }
TEST(FivePointsNullspaceBasis, SatisfyEpipolarConstraint) { TestData d = SomeTestData(); Mat E_basis = FivePointsNullspaceBasis(d.x1, d.x2); for (int s = 0; s < 4; ++s) { Mat3 E; for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { E(i, j) = E_basis(3 * i + j, s); } } for (int i = 0; i < d.x1.cols(); ++i) { Vec3 x1(d.x1(0,i), d.x1(1,i), 1); Vec3 x2(d.x2(0,i), d.x2(1,i), 1); EXPECT_NEAR(0, x2.dot(E * x1), 1e-6); } } }
void FakeVimPlugin::test_vim_fFtT() { TestData data; setup(&data); data.setText("123()456" N "a(b(c)d)e"); KEYS("t(", "12" X "3()456" N "a(b(c)d)e"); KEYS("lt(", "123" X "()456" N "a(b(c)d)e"); KEYS("0j2t(", "123()456" N "a(" X "b(c)d)e"); KEYS("l2T(", "123()456" N "a(b" X "(c)d)e"); KEYS("l2T(", "123()456" N "a(" X "b(c)d)e"); KEYS("T(", "123()456" N "a(" X "b(c)d)e"); KEYS("ggf(", "123" X "()456" N "a(b(c)d)e"); KEYS("lf(", "123(" X ")456" N "a(b(c)d)e"); KEYS("0j2f(", "123()456" N "a(b" X "(c)d)e"); KEYS("2F(", "123()456" N "a(b" X "(c)d)e"); KEYS("l2F(", "123()456" N "a" X "(b(c)d)e"); KEYS("F(", "123()456" N "a" X "(b(c)d)e"); }
bool AdjointMarketModelCalibrationTest::testCapletVolatilities() { BOOST_MESSAGE("Testing dependency of caplet volatilities from CTSMMCapletAlphaFormCalibration on input caplet volatilities..."); Size n = 12; TestData testData; MarketModelTest test(n, &testData); // Start tape recording. cl::Independent(test.capletVols_); test.calibrate(); // End tape recording. cl::tape_function<double> f(test.capletVols_, test.volsAndErrs_); // Calculating derivatives with adjoint. test.adjointResults_ = f.Jacobian(test.doubleCapletVols_); // Calculating derivatives using finite difference. test.calcAnalytical(); return test.checkAdjoint() && testData.makeOutput(); }
int ParseThread::parseAction ( const QString& _filepath ) { ex::XmlSerializeNode loadNode; loadNode.loadFromFile ( qPrintable(_filepath) ); TestData* testData = ex_new TestData(); EX_SERIALIZE( &loadNode, testData->getClassName(), *testData ); // if this is a valid action element if ( testData->ID() != -1 && testData->tag() != ex::string_t::null ) { ElementItem* item = new ElementItem(); item->setText ( 0, QString::number(testData->ID()) ); item->setCheckState ( 0, Qt::Unchecked ); item->setFlags ( item->flags() & ~Qt::ItemIsUserCheckable ); item->setText ( 1, QString::fromUtf8(testData->tag().c_str()) ); item->setPropObj ( ex::SmartPtr<ex::PropertyObject>(testData) ); // it is possible we abort the programme with thread still running. if ( m_treeWidget ) { m_treeWidget->addTopLevelItem (item); return 0; } else { return 1; // need break the thread } } return -1; }
void FakeVimPlugin::test_vim_movement() { TestData data; setup(&data); // vertical movement data.setText("123" N "456" N "789" N "abc"); KEYS("", X "123" N "456" N "789" N "abc"); KEYS("j", "123" N X "456" N "789" N "abc"); KEYS("G", "123" N "456" N "789" N X "abc"); KEYS("k", "123" N "456" N X "789" N "abc"); KEYS("2k", X "123" N "456" N "789" N "abc"); KEYS("k", X "123" N "456" N "789" N "abc"); KEYS("jj", "123" N "456" N X "789" N "abc"); KEYS("gg", X "123" N "456" N "789" N "abc"); // horizontal movement data.setText(" " X "x" "x" "x" "x"); KEYS("", " " X "x" "x" "x" "x"); KEYS("h", X " " "x" "x" "x" "x"); KEYS("l", " " X "x" "x" "x" "x"); KEYS("3l", " " "x" "x" "x" X "x"); KEYS("2h", " " "x" X "x" "x" "x"); KEYS("$", " " "x" "x" "x" X "x"); KEYS("^", " " X "x" "x" "x" "x"); KEYS("0", X " " "x" "x" "x" "x"); // skip words data.setText("123 " "456" "." "789 " "abc"); KEYS("b", X "123 " "456" "." "789 " "abc"); KEYS("w", "123 " X "456" "." "789 " "abc"); KEYS("2w", "123 " "456" "." X "789 " "abc"); KEYS("3w", "123 " "456" "." "789 " "ab" X "c"); KEYS("3b", "123 " "456" X "." "789 " "abc"); data.setText("123 " "456.789 " "abc " "def"); KEYS("B", X "123 " "456.789 " "abc " "def"); KEYS("W", "123 " X "456.789 " "abc " "def"); KEYS("2W", "123 " "456.789 " "abc " X "def"); KEYS("B", "123 " "456.789 " X "abc " "def"); KEYS("2B", X "123 " "456.789 " "abc " "def"); KEYS("4W", "123 " "456.789 " "abc " "de" X "f"); data.setText("123" N "45." "6" N "" N " " N "789"); KEYS("3w", "123" N "45." X "6" N "" N " " N "789"); // From Vim help (motion.txt): An empty line is also considered to be a word. KEYS("w", "123" N "45." "6" N X "" N " " N "789"); KEYS("w", "123" N "45." "6" N "" N " " N X "789"); KEYS("b", "123" N "45." "6" N X "" N " " N "789"); KEYS("4b", X "123" N "45." "6" N "" N " " N "789"); KEYS("3e", "123" N "45" X "." "6" N "" N " " N "789"); KEYS("e", "123" N "45" "." X "6" N "" N " " N "789"); // Command "e" does not stop on empty lines ("ge" does). KEYS("e", "123" N "45" "." "6" N "" N " " N "78" X "9"); KEYS("ge", "123" N "45" "." "6" N X "" N " " N "789"); KEYS("2ge", "123" N "45" X "." "6" N "" N " " N "789"); }
int main() { // // DataRes dr; kinvrf_ml::TrainData* trainData = new kinvrf_ml::TrainData(); Mat temp_pos = trainData->train_data_pos(); cout << temp_pos.cols << endl; Mat temp_neg = trainData->train_data_neg(); cout << temp_neg.cols << endl; // // string path0 = "../../py/static/upload/person/41644d01/0.jpg"; string path1 = "../../py/static/upload/person/41644d01/1.jpg"; TestData* testData = new TestData(path0, path1); // imshow("test", testData->test_data_one()); // waitKey(); cout << testData->test_data_one().cols << endl; // imshow("test", testData->test_data_two()); // waitKey(); cout << testData->test_data_two().cols << endl; // test DataRes // string path = "../../res/img/KinFace_V2/02_part/"; // DataRes* dr = new DataRes(path); // dr->gen_eigen_vectors(); return 0; }
void FakeVimPlugin::test_vim_change_a_word() { TestData data; setup(&data); data.setText("abc " X "def ghi"); KEYS("caw#", "abc #" X "ghi"); data.setText("abc d" X "ef ghi"); KEYS("caw#", "abc #" X "ghi"); data.setText("abc de" X "f ghi"); KEYS("caw#", "abc #" X "ghi"); data.setText("abc de" X "f ghi jkl"); KEYS("2caw#", "abc #" X "jkl"); data.setText("abc" X " def ghi jkl"); KEYS("2caw#", "abc#" X " jkl"); data.setText("abc " X " def ghi jkl"); KEYS("2caw#", "abc#" X " jkl"); data.setText(" abc " N " def" N " ghi" N " jkl"); KEYS("3caw#", "#" X N " jkl"); }
bool DataExists(const TestData &data, const char *name) { TestData::const_iterator i = data.find(name); return (i != data.end()); }
void TestDataFile(const std::string &filename, unsigned int &totalTests, unsigned int &failedTests) { std::ifstream file(filename.c_str()); if (!file.good()) throw Exception(Exception::OTHER_ERROR, "Can not open file " + filename + " for reading"); TestData v; s_currentTestData = &v; std::string name, value, lastAlgName; while (file) { while (file.peek() == '#') file.ignore(INT_MAX, '\n'); if (file.peek() == '\n') v.clear(); if (!GetField(file, name, value)) break; v[name] = value; if (name == "Test") { bool failed = true; std::string algType = GetRequiredDatum(v, "AlgorithmType"); if (lastAlgName != GetRequiredDatum(v, "Name")) { lastAlgName = GetRequiredDatum(v, "Name"); cout << "\nTesting " << algType.c_str() << " algorithm " << lastAlgName.c_str() << ".\n"; } try { if (algType == "Signature") TestSignatureScheme(v); else if (algType == "SymmetricCipher") TestSymmetricCipher(v); else if (algType == "AsymmetricCipher") TestAsymmetricCipher(v); else if (algType == "MessageDigest") TestDigestOrMAC(v, true); else if (algType == "MAC") TestDigestOrMAC(v, false); else if (algType == "FileList") TestDataFile(GetRequiredDatum(v, "Test"), totalTests, failedTests); else SignalTestError(); failed = false; } catch (TestFailure &) { cout << "\nTest failed.\n"; } catch (CryptoPP::Exception &e) { cout << "\nCryptoPP::Exception caught: " << e.what() << endl; } catch (std::exception &e) { cout << "\nstd::exception caught: " << e.what() << endl; } if (failed) { cout << "Skipping to next test.\n"; failedTests++; } else cout << "." << flush; totalTests++; } } }
void StringCaseTest::TestCasing() { UErrorCode status = U_ZERO_ERROR; void *iter; char cLocaleID[100]; UnicodeString locale, input, output, optionsString, result; uint32_t options; int32_t whichCase, type; TestDataModule *driver = TestDataModule::getTestDataModule("casing", *this, status); if(U_SUCCESS(status)) { for(whichCase=0; whichCase<TEST_COUNT; ++whichCase) { #if UCONFIG_NO_BREAK_ITERATION if(whichCase==TEST_TITLE) { continue; } #endif TestData *casingTest = driver->createTestData(dataNames[whichCase], status); if(U_FAILURE(status)) { errln("TestCasing failed to createTestData(%s) - %s", dataNames[whichCase], u_errorName(status)); break; } const DataMap *myCase = NULL; while(casingTest->nextCase(myCase, status)) { input = myCase->getString("Input", status); output = myCase->getString("Output", status); if(whichCase!=TEST_FOLD) { locale = myCase->getString("Locale", status); } locale.extract(0, 0x7fffffff, cLocaleID, sizeof(cLocaleID), ""); iter=NULL; #if !UCONFIG_NO_BREAK_ITERATION if(whichCase==TEST_TITLE) { type = myCase->getInt("Type", status); if(type>=0) { iter=ubrk_open((UBreakIteratorType)type, cLocaleID, NULL, 0, &status); } else if(type==-2) { // Open a trivial break iterator that only delivers { 0, length } // or even just { 0 } as boundaries. static const UChar rules[] = { 0x2e, 0x2a, 0x3b }; // ".*;" UParseError parseError; iter=ubrk_openRules(rules, LENGTHOF(rules), NULL, 0, &parseError, &status); } } #endif options = 0; if(whichCase==TEST_TITLE || whichCase==TEST_FOLD) { optionsString = myCase->getString("Options", status); if(optionsString.indexOf((UChar)0x54)>=0) { // T options|=U_FOLD_CASE_EXCLUDE_SPECIAL_I; } if(optionsString.indexOf((UChar)0x4c)>=0) { // L options|=U_TITLECASE_NO_LOWERCASE; } if(optionsString.indexOf((UChar)0x41)>=0) { // A options|=U_TITLECASE_NO_BREAK_ADJUSTMENT; } } if(U_FAILURE(status)) { errln("error: TestCasing() setup failed for %s test case from casing.res: %s", dataNames[whichCase], u_errorName(status)); status = U_ZERO_ERROR; } else { TestCasingImpl(input, output, whichCase, iter, cLocaleID, options); } #if !UCONFIG_NO_BREAK_ITERATION if(iter!=NULL) { ubrk_close(iter); } #endif } delete casingTest; } } delete driver; #if !UCONFIG_NO_BREAK_ITERATION // more tests for API coverage status=U_ZERO_ERROR; input=UNICODE_STRING_SIMPLE("sTrA\\u00dfE").unescape(); (result=input).toTitle(NULL); if(result!=UNICODE_STRING_SIMPLE("Stra\\u00dfe").unescape()) { errln("UnicodeString::toTitle(NULL) failed"); } #endif }
/** * @brief Gets the cross differences between the training and test inputs. * @param [in] pXs The M test inputs * @param [in] coord Corresponding coordinate * @return An matrix pointer * \f[ * \mathbf{D} \in \mathbb{R}^{N \times M}, \quad * \mathbf{D}_{ij} = \mathbf{x}_i^c - \mathbf{z}_j^c * \f] * @todo Include this matrix as a member variable like m_pDeltaXXList */ MatrixPtr pDeltaXXs(const TestData<Scalar> &testData, const int coord) const { assert(m_pX && testData.M() > 0); assert(D() == testData.D()); return PairwiseOp<Scalar>::delta(m_pX, testData.pXs(), coord); // NxM }
/** * @brief Gets the cross squared distances between the training and test inputs * @param [in] pXs The M test inputs * @return An matrix pointer * \f[ * \mathbf{R^2} \in \mathbb{R}^{N \times M}, \quad * \mathbf{R^2}_{ij} = (\mathbf{x}_i - \mathbf{z}_j)^\text{T}(\mathbf{x}_i - \mathbf{z}_j) * \f] * @todo Include this matrix as a member variable like m_pSqDistXX */ MatrixPtr pSqDistXXs(const TestData<Scalar> &testData) const { assert(m_pX && testData.M() > 0); assert(D() == testData.D()); return PairwiseOp<Scalar>::sqDist(m_pX, testData.pXs()); // NxM }