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
}
