void IntlCalendarTest::TestBuddhistFormat() {
UErrorCode status = U_ZERO_ERROR;
// Test simple parse/format with adopt
// First, a contrived english test..
UDate aDate = 999932400000.0;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=buddhist"), status);
CHECK(status, "creating date format instance");
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating gregorian date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Buddhist Calendar: " + escape(str));
UnicodeString expected("September 8, 2544 BE");
if(str != expected) {
errln("Expected " + escape(expected) + " but got " + escape(str));
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
fmt->format(otherDate, str3);
errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " + otherDate + ", " + escape(str3));
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete fmt2;
CHECK(status, "Error occured testing Buddhist Calendar in English ");
status = U_ZERO_ERROR;
// Now, try in Thai
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
UDate expectDate = 999932400000.0;
Locale loc("th_TH_TRADITIONAL"); // legacy
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
UDate expectDate = 999932400000.0;
Locale loc("th_TH@calendar=buddhist");
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
UDate expectDate = 999932400000.0;
Locale loc("th_TH@calendar=gregorian");
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
UDate expectDate = 999932400000.0;
Locale loc("th_TH_TRADITIONAL@calendar=gregorian");
simpleTest(loc, expect, expectDate, status);
}
}
//
// Recursive descent parser, old-school style.
//
void getfactor(void) {
numvar thesymval = symval;
byte thesym = sym;
getsym(); // eat the sym we just saved
switch (thesym) {
case s_nval:
vpush(thesymval);
break;
case s_nvar:
if (sym == s_equals) { // assignment, push is after the break;
getsym();
assignVar(thesymval, getnum());
}
else if (sym == s_incr) { // postincrement nvar++
vpush(getVar(thesymval));
assignVar(thesymval, getVar(thesymval) + 1);
getsym();
break;
}
else if (sym == s_decr) { // postdecrement nvar--
vpush(getVar(thesymval));
assignVar(thesymval, getVar(thesymval) - 1);
getsym();
break;
}
vpush(getVar(thesymval)); // both assignment and reference get pushed here
break;
case s_nfunct:
dofunctioncall(thesymval); // get its value onto the stack
break;
// Script-function-returning-value used as a factor
case s_script_eeprom: // macro returning value
callscriptfunction(SCRIPT_EEPROM, findend(thesymval));
break;
case s_script_progmem:
callscriptfunction(SCRIPT_PROGMEM, thesymval);
break;
case s_script_file:
callscriptfunction(SCRIPT_FILE, (numvar) 0); // name implicitly in idbuf!
break;
case s_apin: // analog pin reference like a0
if (sym == s_equals) { // digitalWrite or analogWrite
getsym();
analogWrite(thesymval, getnum());
vpush(expval);
}
else vpush(analogRead(thesymval));
break;
case s_dpin: // digital pin reference like d1
if (sym == s_equals) { // digitalWrite or analogWrite
getsym();
digitalWrite(thesymval, getnum());
vpush(expval);
}
else vpush(digitalRead(thesymval));
break;
case s_incr:
if (sym != s_nvar) expected(M_var);
assignVar(symval, getVar(symval) + 1);
vpush(getVar(symval));
getsym();
break;
case s_decr: // pre decrement
if (sym != s_nvar) expected(M_var);
assignVar(symval, getVar(symval) - 1);
vpush(getVar(symval));
getsym();
break;
case s_arg: // arg(n) - argument value
if (sym != s_lparen) expectedchar(s_lparen);
getsym(); // eat '('
vpush(getarg(getnum()));
if (sym != s_rparen) expectedchar(s_rparen);
getsym(); // eat ')'
break;
case s_lparen: // expression in parens
getexpression();
if (exptype != s_nval) expected(M_number);
if (sym != s_rparen) missing(M_rparen);
vpush(expval);
getsym(); // eat the )
break;
//
// The Family of Unary Operators, which Bind Most Closely to their Factor
//
case s_add: // unary plus (like +3) is kind of a no-op
getfactor(); // scan a factor and leave its result on the stack
break; // done
case s_sub: // unary minus (like -3)
getfactor();
vpush(-vpop()); // similar to above but we adjust the stack value
break;
case s_bitnot:
getfactor();
vpush(~vpop());
break;
case s_logicalnot:
getfactor();
vpush(!vpop());
break;
case s_bitand: // &var gives address-of-var; ¯o gives eeprom address of macro
if (sym == s_nvar) vpush((numvar) &vars[symval]);
else if (sym == s_script_eeprom) vpush(symval);
else expected(M_var);
getsym(); // eat the var reference
break;
case s_mul: // *foo is contents-of-address-foo; *foo=bar is byte poke assignment
/*****
// what is really acceptable for an lvalue here? ;)
// *y = 5 is failing now by assigning 5 to y before the * is dereferenced
// due to calling getfactor
// everything else works :(
*****/
getfactor();
#if 0
if (sym == s_equals) {
getsym(); // eat '='
getexpression();
* (volatile byte *) vpop() = (byte) expval;
vpush((numvar) (byte) expval);
}
else
#endif
vpush((numvar) (* (volatile byte *) vpop()));
break;
default:
unexpected(M_number);
}
}
/* verifica se entrada combina com o esperado */
void match(char c)
{
if (look != c)
expected("'%c'", c);
nextChar();
}
static void test_CPoint()
{
CPoint empty;
ok(empty.x == 0, "Expected x to be 0, was %ld\n", empty.x);
ok(empty.y == 0, "Expected y to be 0, was %ld\n", empty.y);
CPoint ptTopLeft(0, 0);
POINT ptHere;
ptHere.x = 35;
ptHere.y = 95;
CPoint ptMFCHere(ptHere);
SIZE sHowBig;
sHowBig.cx = 300;
sHowBig.cy = 10;
CPoint ptMFCBig(sHowBig);
DWORD dwSize;
dwSize = MAKELONG(35, 95);
CPoint ptFromDouble(dwSize);
ok_point(ptFromDouble, ptMFCHere);
CPoint ptStart(100, 100);
ptStart.Offset(35, 35);
CPoint ptResult(135, 135);
ok_point(ptStart, ptResult);
ptStart = CPoint(100, 100);
POINT pt;
pt.x = 35;
pt.y = 35;
ptStart.Offset(pt);
ok_point(ptStart, ptResult);
ptStart = CPoint(100, 100);
SIZE size;
size.cx = 35;
size.cy = 35;
ptStart.Offset(size);
ok_point(ptStart, ptResult);
CPoint ptFirst(256, 128);
CPoint ptTest(256, 128);
ok_point(ptFirst, ptTest);
pt.x = 256;
pt.y = 128;
ok_point(ptTest, pt);
ptTest = CPoint(111, 333);
nok_point(ptFirst, ptTest);
pt.x = 333;
pt.y = 111;
nok_point(ptTest, pt);
ptStart = CPoint(100, 100);
CSize szOffset(35, 35);
ptStart += szOffset;
ok_point(ptResult, ptStart);
ptStart = CPoint(100, 100);
ptStart += size;
ok_point(ptResult, ptStart);
ptStart = CPoint(100, 100);
ptStart -= szOffset;
ptResult = CPoint(65, 65);
ok_point(ptResult, ptStart);
ptStart = CPoint(100, 100);
ptStart -= size;
ok_point(ptResult, ptStart);
ptStart = CPoint(100, 100);
CPoint ptEnd;
ptEnd = ptStart + szOffset;
ptResult = CPoint(135, 135);
ok_point(ptResult, ptEnd);
ptEnd = ptStart + size;
ok_point(ptResult, ptEnd);
ptEnd = ptStart + pt;
ptResult = CPoint(433, 211);
ok_point(ptResult, ptEnd);
ptEnd = ptStart - szOffset;
ptResult = CPoint(65, 65);
ok_point(ptResult, ptEnd);
ptEnd = ptStart - size;
ok_point(ptResult, ptEnd);
szOffset = ptStart - pt;
CSize expected(-233, -11);
ok_size(szOffset, expected);
ptStart += pt;
ptResult = CPoint(433, 211);
ok_point(ptResult, ptStart);
ptStart -= pt;
ptResult = CPoint(100, 100);
ok_point(ptResult, ptStart);
ptTest = CPoint(35, 35);
ptTest = -ptTest;
CPoint ptNeg(-35, -35);
ok_point(ptTest, ptNeg);
RECT rc = { 1, 2, 3, 4 };
CRect rcres = ptStart + &rc;
CRect rcexp(101, 102, 103, 104);
ok_rect(rcexp, rcres);
rcres = ptStart - &rc;
rcexp = CRect(-99, -98, -97, -96);
ok_rect(rcexp, rcres);
}
int main( int argc, char** argv ) {
QApplication app( argc, argv );
KDReports::Report report;
report.setHeaderBodySpacing( 10 ); // mm
report.setFooterBodySpacing( 10 ); // mm
// report.setWatermarkPixmap( QPixmap( ":/kdab.jpg" ) );
// report.setWatermarkText( QString::null );
KDReports::Header& header = report.header( KDReports::OddPages );
QPixmap kdab( ":/kdab_small.jpg" );
// add a border around the pixmap, mostly for debugging
//QPainter painter( &kdab );
//painter.drawRect( 0, 0, kdab.width() - 1, kdab.height() - 1 );
KDReports::ImageElement imageElement( kdab );
// The image size can be set in mm or in percent of the page width (without margins)
// imageElement.setWidth( 50 ); // mm
imageElement.setWidth( 40, KDReports::Percent );
header.addElement( imageElement );
header.addVariable( KDReports::PageNumber );
header.addInlineElement( KDReports::TextElement( " / " ) );
header.addVariable( KDReports::PageCount );
header.addInlineElement( KDReports::TextElement( ", Date: " ) );
header.addVariable( KDReports::TextDate );
header.addInlineElement( KDReports::TextElement( ", Time: " ) );
header.addVariable( KDReports::TextTime );
KDReports::Header& evenPagesHeader = report.header( KDReports::EvenPages );
evenPagesHeader.addElement( imageElement );
evenPagesHeader.addInlineElement( KDReports::TextElement( "Even pages header: " ) );
evenPagesHeader.addVariable( KDReports::PageNumber );
evenPagesHeader.addInlineElement( KDReports::TextElement( " / " ) );
evenPagesHeader.addVariable( KDReports::PageCount );
KDReports::Footer& footer = report.footer();
KDReports::TextElement companyAddressElement( QString::fromUtf8( "Klarälvdalens Datakonsult AB\nRysktorp\nSE-68392 Hagfors\nSweden" ) );
footer.addElement( companyAddressElement, Qt::AlignRight );
KDReports::TextElement titleElement;
titleElement << "Price list example";
titleElement.setPointSize( 18 );
report.addElement( titleElement, Qt::AlignHCenter );
report.addVerticalSpacing( 10 ); // 1 cm
const QColor titleElementColor( 204, 204, 255 );
// A text element with the title above a table
// Note that the background color is not just behind the text (as setBackground() would do),
// but behind the whole paragraph, up until the right margin of the page.
KDReports::TextElement tableTitleElement( "Network Peripherals" );
tableTitleElement.setBold( true );
report.addElement( tableTitleElement, Qt::AlignLeft, titleElementColor );
TableModel table1;
table1.setDataHasVerticalHeaders( false );
table1.loadFromCSV( ":/table1" );
// Q_ASSERT( table1.headerData( 0, Qt::Vertical ).toString() == "10/100 Mbps switch" );
//Q_ASSERT( table1.data( table1.index( 0, 0 ) ).toString() == "Product" );
KDReports::AutoTableElement autoTableElement1( &table1 );
autoTableElement1.setWidth( 100, KDReports::Percent );
report.addElement( autoTableElement1 );
report.addVerticalSpacing( 5 );
// Notice how elements can be copied and modified
// This way, we use the same font attributes for all title elements
KDReports::TextElement tableTitleElement2 = tableTitleElement;
tableTitleElement2.setText( "Printer Cartridges" );
report.addElement( tableTitleElement2, Qt::AlignLeft, titleElementColor );
TableModel table2;
table2.setDataHasVerticalHeaders( false );
table2.loadFromCSV( ":/table2" );
KDReports::AutoTableElement autoTableElement2( &table2 );
autoTableElement2.setWidth( 100, KDReports::Percent );
report.addElement( autoTableElement2 );
// and again, on the second page
report.addPageBreak();
report.addElement( tableTitleElement, Qt::AlignLeft, titleElementColor );
report.addElement( autoTableElement1 );
report.addVerticalSpacing( 5 );
report.addElement( tableTitleElement2, Qt::AlignLeft, titleElementColor );
report.addElement( autoTableElement2 );
report.addVerticalSpacing( 5 );
// ===========================================================================
// Another kind of table, where the data comes from code and not from a model:
// ===========================================================================
KDReports::TableElement tableElement;
tableElement.setHeaderRowCount( 2 );
tableElement.setPadding( 3 );
QColor headerColor( "#DADADA" );
// Merged header in row 0
KDReports::Cell& topHeader = tableElement.cell( 0, 0 );
topHeader.setColumnSpan( 2 );
topHeader.setBackground( headerColor );
topHeader.addElement( KDReports::TextElement( "TableElement example" ), Qt::AlignHCenter );
// Normal header in row 1
KDReports::Cell& headerCell1 = tableElement.cell( 1, 0 );
headerCell1.setBackground( headerColor );
// This would look better if centered vertically. This feature is only available since
// Qt-4.3 though (QTextCharFormat::AlignMiddle)
QPixmap systemPixmap( ":/system.png" );
headerCell1.addElement( KDReports::ImageElement( systemPixmap ) );
headerCell1.addInlineElement( KDReports::TextElement( " Item" ) );
KDReports::Cell& headerCell2 = tableElement.cell( 1, 1 );
headerCell2.setBackground( headerColor );
KDReports::TextElement expected( "Expected" );
expected.setItalic( true );
expected.setBackground( QColor("#999999") ); // note that this background only applies to this element
headerCell2.addElement( expected );
headerCell2.addInlineElement( KDReports::TextElement( " shipping time" ) );
// Data in rows 2 and 3
tableElement.cell( 2, 0 ).addElement( KDReports::TextElement( "Network Peripherals" ) );
tableElement.cell( 2, 1 ).addElement( KDReports::TextElement( "4 days" ) );
tableElement.cell( 3, 0 ).addElement( KDReports::TextElement( "Printer Cartridges" ) );
tableElement.cell( 3, 1 ).addElement( KDReports::TextElement( "3 days" ) );
report.addElement( tableElement );
KDReports::PreviewDialog preview( &report );
return preview.exec();
}
static void test_invert(skiatest::Reporter* reporter) {
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
double inverseData[16];
SkMatrix44 identity(SkMatrix44::kIdentity_Constructor);
identity.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
SkMatrix44 translation(SkMatrix44::kUninitialized_Constructor);
translation.setTranslate(2, 3, 4);
translation.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
1, 0, 0, -2,
0, 1, 0, -3,
0, 0, 1, -4,
0, 0, 0, 1);
SkMatrix44 scale(SkMatrix44::kUninitialized_Constructor);
scale.setScale(2, 4, 8);
scale.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
0.5, 0, 0, 0,
0, 0.25, 0, 0,
0, 0, 0.125, 0,
0, 0, 0, 1);
SkMatrix44 scaleTranslation(SkMatrix44::kUninitialized_Constructor);
scaleTranslation.setScale(32, 128, 1024);
scaleTranslation.preTranslate(2, 3, 4);
scaleTranslation.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
0.03125, 0, 0, -2,
0, 0.0078125, 0, -3,
0, 0, 0.0009765625, -4,
0, 0, 0, 1);
SkMatrix44 rotation(SkMatrix44::kUninitialized_Constructor);
rotation.setRotateDegreesAbout(0, 0, 1, 90);
rotation.invert(&inverse);
SkMatrix44 expected(SkMatrix44::kUninitialized_Constructor);
double expectedInverseRotation[16] =
{ 0, 1, 0, 0,
-1, 0, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
expected.setRowMajord(expectedInverseRotation);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 affine(SkMatrix44::kUninitialized_Constructor);
affine.setRotateDegreesAbout(0, 0, 1, 90);
affine.preScale(10, 20, 100);
affine.preTranslate(2, 3, 4);
affine.invert(&inverse);
double expectedInverseAffine[16] =
{ 0, 0.1, 0, -2,
-0.05, 0, 0, -3,
0, 0, 0.01, -4,
0, 0, 0, 1
};
expected.setRowMajord(expectedInverseAffine);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 perspective(SkMatrix44::kIdentity_Constructor);
perspective.setDouble(3, 2, 1.0);
perspective.invert(&inverse);
double expectedInversePerspective[16] =
{ 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, -1, 1
};
expected.setRowMajord(expectedInversePerspective);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 affineAndPerspective(SkMatrix44::kIdentity_Constructor);
affineAndPerspective.setDouble(3, 2, 1.0);
affineAndPerspective.preScale(10, 20, 100);
affineAndPerspective.preTranslate(2, 3, 4);
affineAndPerspective.invert(&inverse);
double expectedInverseAffineAndPerspective[16] =
{ 0.1, 0, 2, -2,
0, 0.05, 3, -3,
0, 0, 4.01, -4,
0, 0, -1, 1
};
expected.setRowMajord(expectedInverseAffineAndPerspective);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 tinyScale(SkMatrix44::kIdentity_Constructor);
tinyScale.setDouble(0, 0, 1e-39);
REPORTER_ASSERT(reporter, tinyScale.getType() == SkMatrix44::kScale_Mask);
REPORTER_ASSERT(reporter, !tinyScale.invert(nullptr));
REPORTER_ASSERT(reporter, !tinyScale.invert(&inverse));
SkMatrix44 tinyScaleTranslate(SkMatrix44::kIdentity_Constructor);
tinyScaleTranslate.setDouble(0, 0, 1e-38);
REPORTER_ASSERT(reporter, tinyScaleTranslate.invert(nullptr));
tinyScaleTranslate.setDouble(0, 3, 10);
REPORTER_ASSERT(
reporter, tinyScaleTranslate.getType() ==
(SkMatrix44::kScale_Mask | SkMatrix44::kTranslate_Mask));
REPORTER_ASSERT(reporter, !tinyScaleTranslate.invert(nullptr));
REPORTER_ASSERT(reporter, !tinyScaleTranslate.invert(&inverse));
SkMatrix44 tinyScalePerspective(SkMatrix44::kIdentity_Constructor);
tinyScalePerspective.setDouble(0, 0, 1e-39);
tinyScalePerspective.setDouble(3, 2, -1);
REPORTER_ASSERT(reporter, (tinyScalePerspective.getType() &
SkMatrix44::kPerspective_Mask) ==
SkMatrix44::kPerspective_Mask);
REPORTER_ASSERT(reporter, !tinyScalePerspective.invert(nullptr));
REPORTER_ASSERT(reporter, !tinyScalePerspective.invert(&inverse));
}
void RunTests()
{
std::string output;
CoreParameter coreParam;
coreParam.cpuCore = g_Config.bJit ? CPU_JIT : CPU_INTERPRETER;
coreParam.gpuCore = GPU_GLES;
coreParam.enableSound = g_Config.bEnableSound;
coreParam.mountIso = "";
coreParam.startPaused = false;
coreParam.enableDebugging = false;
coreParam.printfEmuLog = false;
coreParam.headLess = false;
coreParam.renderWidth = 480;
coreParam.renderHeight = 272;
coreParam.pixelWidth = 480;
coreParam.pixelHeight = 272;
coreParam.collectEmuLog = &output;
coreParam.unthrottle = true;
coreParam.updateRecent = false;
#ifdef IOS
std::string baseDirectory = g_Config.flashDirectory + "../";
#else
std::string baseDirectory = g_Config.memCardDirectory;
#endif
// Never report from tests.
std::string savedReportHost = g_Config.sReportHost;
g_Config.sReportHost = "";
for (size_t i = 0; i < ARRAY_SIZE(testsToRun); i++) {
const char *testName = testsToRun[i];
coreParam.fileToStart = baseDirectory + "pspautotests/tests/" + testName + ".prx";
std::string expectedFile = baseDirectory + "pspautotests/tests/" + testName + ".expected";
ILOG("Preparing to execute %s", testName)
std::string error_string;
output = "";
if (!PSP_Init(coreParam, &error_string)) {
ELOG("Failed to init unittest %s : %s", testsToRun[i], error_string.c_str());
return;
}
// Run the emu until the test exits
while (true) {
int blockTicks = usToCycles(1000000 / 10);
while (coreState == CORE_RUNNING) {
u64 nowTicks = CoreTiming::GetTicks();
mipsr4k.RunLoopUntil(nowTicks + blockTicks);
}
// Hopefully coreState is now CORE_NEXTFRAME
if (coreState == CORE_NEXTFRAME) {
// set back to running for the next frame
coreState = CORE_RUNNING;
} else if (coreState == CORE_POWERDOWN) {
ILOG("Finished running test %s", testName);
break;
}
}
std::ifstream expected(expectedFile.c_str(), std::ios_base::in);
if (!expected) {
ELOG("Error opening expectedFile %s", expectedFile.c_str());
return;
}
std::istringstream logoutput(output);
int line = 0;
while (true) {
++line;
std::string e, o;
std::getline(expected, e);
std::getline(logoutput, o);
// Remove stray returns
while (e[e.size()-1] == 10 || e[e.size()-1] == 13)
e = e.substr(0, e.size() - 1); // For some reason we get some extra character
while (o[o.size()-1] == 10 || o[o.size()-1] == 13)
o = o.substr(0, o.size() - 1); // For some reason we get some extra character
if (e != o) {
ELOG("DIFF on line %i!", line);
ILOG("O: %s", o.c_str());
ILOG("E: %s", e.c_str());
}
if (expected.eof()) {
break;
}
if (logoutput.eof()) {
break;
}
}
PSP_Shutdown();
}
glstate.Restore();
glstate.viewport.set(0,0,pixel_xres,pixel_yres);
g_Config.sReportHost = savedReportHost;
}
int main(){
expected("", HEARTBEAT_CONTROLLER);
expected("/", HEARTBEAT_CONTROLLER);
expected("/api", HEARTBEAT_CONTROLLER);
expected("/api/", HEARTBEAT_CONTROLLER);
expected("/api/comments", COMMENTS_CONTROLLER);
expected("/api/comments/", COMMENTS_CONTROLLER);
expected("/api/comments?type=needs", COMMENTS_CONTROLLER);
expected("/api/heatmap", HEATMAP_CONTROLLER);
expected("/api/heatmap/", HEATMAP_CONTROLLER);
expected("/api/heatmap?latDegrees=23.45&latOffset=2.0&lonDegrees=40.3&lonOffset=5.12", HEATMAP_CONTROLLER);
expected("/api/pins", MARKER_CONTROLLER);
expected("/api/pins/", MARKER_CONTROLLER);
expected("/api/pins?id=32424j23k4j2kldsafasdf", MARKER_CONTROLLER);
expected("/api/debug", REPORT_CONTROLLER);
expected("/api/debug/", REPORT_CONTROLLER);
expected("/api/debug/?origin=6f3d78c8ca1d63645015d6fa2d975902348d585f954efd0e8ecca4f362c697d9&hash=aed60d05a1bd", REPORT_CONTROLLER);
expected("/api/de", INVALID_CONTROLLER);
expected("/api/asadssd",INVALID_CONTROLLER);
expected("/ap", INVALID_CONTROLLER);
expected("/aasspi/asd", INVALID_CONTROLLER);
/* Be sure to flush before closing the lid on the i/o */
fflush(stdout);
fflush(stderr);
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
return 0;
}
void testImplementationReal()
{
typedef short_vec<CARGO, ARITY> ShortVec;
int numElements = ShortVec::ARITY * 10;
std::vector<CARGO> vec1(numElements);
std::vector<CARGO> vec2(numElements, 4711);
// init vec1:
for (int i = 0; i < numElements; ++i) {
vec1[i] = i + 0.1;
}
// test default c-tor:
for (int i = 0; i < numElements; ++i) {
BOOST_TEST(4711 == vec2[i]);
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST(0 == vec2[i]);
}
// tests vector load/store:
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((i + 0.1), vec2[i]);
}
// tests scalar load, vector add:
ShortVec w = vec1[0];
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << (v + w);
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((i + 0.2), vec2[i]);
}
// tests +=
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v += w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((2 * i + 0.3), vec2[i]);
}
// test -
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v - w);
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((-i - 0.2), vec2[i]);
}
// test -=
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v -= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((2 * i + 0.3), vec2[i]);
}
// test *
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v * w);
}
for (int i = 0; i < numElements; ++i) {
double reference = ((i + 0.1) * (2 * i + 0.3));
TEST_REAL(reference, vec2[i]);
}
// test *=
for (int i = 0; i < numElements; ++i) {
vec2[i] = i + 0.2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v *= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
TEST_REAL((i + 0.1) * (i + 0.2), vec2[i]);
}
// test /
for (int i = 0; i < numElements; ++i) {
vec2[i] = i + 0.2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v / w);
}
for (int i = 0; i < numElements; ++i) {
// accept lower accuracy for estimated division, really low
// accuracy accepted because of results from ARM NEON:
TEST_REAL_ACCURACY((i + 0.1) / (i + 0.2), vec2[i], 0.0025);
}
// test /=
for (int i = 0; i < numElements; ++i) {
vec2[i] = i + 0.2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v /= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
// here, too, lower accuracy is acceptable. As with divisions,
// ARM NEON costs us an order of magnitude here compared to X86.
TEST_REAL_ACCURACY((i + 0.1) / (i + 0.2), vec2[i], 0.0025);
}
// test sqrt()
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << sqrt(v);
}
for (int i = 0; i < numElements; ++i) {
// lower accuracy, mainly for ARM NEON
TEST_REAL_ACCURACY(std::sqrt(double(i + 0.1)), vec2[i], 0.0025);
}
// test "/ sqrt()"
for (int i = 0; i < numElements; ++i) {
vec2[i] = i + 0.2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << w / sqrt(v);
}
for (int i = 0; i < numElements; ++i) {
// the expression "foo / sqrt(bar)" will again result in an
// estimated result for single precision floats, so lower accuracy is acceptable:
TEST_REAL_ACCURACY((i + 0.2) / std::sqrt(double(i + 0.1)), vec2[i], 0.0035);
}
// test string conversion
for (int i = 0; i < ShortVec::ARITY; ++i) {
vec1[i] = i + 0.1;
}
ShortVec v(&vec1[0]);
std::ostringstream buf1;
buf1 << v;
std::ostringstream buf2;
buf2 << "[";
for (int i = 0; i < (ShortVec::ARITY - 1); ++i) {
buf2 << (i + 0.1) << ", ";
}
buf2 << (ShortVec::ARITY - 1 + 0.1) << "]";
BOOST_TEST(buf1.str() == buf2.str());
// test gather
{
CARGO array[ARITY * 10];
std::vector<int, aligned_allocator<int, 64> > indices(ARITY);
CARGO actual[ARITY];
CARGO expected[ARITY];
std::memset(array, '\0', sizeof(CARGO) * ARITY * 10);
for (int i = 0; i < ARITY * 10; ++i) {
if (i % 10 == 0) {
array[i] = i * 0.75;
}
}
for (int i = 0; i < ARITY; ++i) {
indices[i] = i * 10;
expected[i] = (i * 10) * 0.75;
}
ShortVec vec;
vec.gather(array, &indices[0]);
actual << vec;
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(actual[i], expected[i], 0.001);
}
}
#ifdef LIBFLATARRAY_WITH_CPP14
// test gather via initializer_list
{
CARGO actual1[ARITY];
CARGO actual2[ARITY];
CARGO expected[ARITY];
for (int i = 0; i < ARITY; ++i) {
expected[i] = (i * 10) * 0.75;
}
// max: 32
ShortVec vec1 = { 0.0, 7.5, 15.0, 22.50, 30.0, 37.5, 45.0, 52.5,
60.0, 67.5, 75.0, 82.5, 90.0, 97.5, 105.0, 112.5,
120.0, 127.5, 135.0, 142.5, 150.0, 157.5, 165.0, 172.5,
180.0, 187.5, 195.0, 202.5, 210.0, 217.5, 225.0, 232.5 };
ShortVec vec2;
vec2 = { 0.0, 7.5, 15.0, 22.50, 30.0, 37.5, 45.0, 52.5,
60.0, 67.5, 75.0, 82.5, 90.0, 97.5, 105.0, 112.5,
120.0, 127.5, 135.0, 142.5, 150.0, 157.5, 165.0, 172.5,
180.0, 187.5, 195.0, 202.5, 210.0, 217.5, 225.0, 232.5 };
actual1 << vec1;
actual2 << vec2;
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(actual1[i], expected[i], 0.001);
TEST_REAL_ACCURACY(actual2[i], expected[i], 0.001);
}
}
#endif
// test scatter
{
ShortVec vec;
CARGO array[ARITY * 10];
CARGO expected[ARITY * 10];
std::vector<int, aligned_allocator<int, 64> > indices(ARITY);
std::memset(array, '\0', sizeof(CARGO) * ARITY * 10);
std::memset(expected, '\0', sizeof(CARGO) * ARITY * 10);
for (int i = 0; i < ARITY * 10; ++i) {
if (i % 10 == 0) {
expected[i] = i * 0.75;
}
}
for (int i = 0; i < ARITY; ++i) {
indices[i] = i * 10;
}
vec.gather(expected, &indices[0]);
vec.scatter(array, &indices[0]);
for (int i = 0; i < ARITY * 10; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
}
// test non temporal stores
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
expected[i] = 5.0;
}
ShortVec v1 = 5.0;
v1.store_nt(&array[0]);
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
for (int i = 0; i < ARITY; ++i) {
expected[i] = i + 0.1;
}
ShortVec v2 = &expected[0];
v2.store_nt(&array[0]);
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
}
// test aligned stores
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
expected[i] = 5.0;
}
ShortVec v1 = 5.0;
v1.store_aligned(&array[0]);
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
for (int i = 0; i < ARITY; ++i) {
expected[i] = i + 0.1;
}
ShortVec v2 = &expected[0];
v2.store_aligned(&array[0]);
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
}
// test aligned loads
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
array[i] = i + 0.1;
expected[i] = 0;
}
ShortVec v1;
v1.load_aligned(&array[0]);
v1.store(&expected[0]);
for (int i = 0; i < ARITY; ++i) {
TEST_REAL_ACCURACY(array[i], expected[i], 0.001);
}
}
}
void Win32DateTimeTest::testLocales(TestLog *log)
{
SYSTEMTIME winNow;
UDate icuNow = 0;
SYSTEMTIME st;
FILETIME ft;
UnicodeString zoneID;
const TimeZone *tz = TimeZone::createDefault();
TIME_ZONE_INFORMATION tzi;
tz->getID(zoneID);
if (! uprv_getWindowsTimeZoneInfo(&tzi, zoneID.getBuffer(), zoneID.length())) {
UBool found = FALSE;
int32_t ec = TimeZone::countEquivalentIDs(zoneID);
for (int z = 0; z < ec; z += 1) {
UnicodeString equiv = TimeZone::getEquivalentID(zoneID, z);
if (found = uprv_getWindowsTimeZoneInfo(&tzi, equiv.getBuffer(), equiv.length())) {
break;
}
}
if (! found) {
GetTimeZoneInformation(&tzi);
}
}
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
SystemTimeToTzSpecificLocalTime(&tzi, &st, &winNow);
int64_t wftNow = ((int64_t) ft.dwHighDateTime << 32) + ft.dwLowDateTime;
UErrorCode status = U_ZERO_ERROR;
int64_t udtsNow = utmscale_fromInt64(wftNow, UDTS_WINDOWS_FILE_TIME, &status);
icuNow = (UDate) utmscale_toInt64(udtsNow, UDTS_ICU4C_TIME, &status);
int32_t lcidCount = 0;
Win32Utilities::LCIDRecord *lcidRecords = Win32Utilities::getLocales(lcidCount);
for(int i = 0; i < lcidCount; i += 1) {
UErrorCode status = U_ZERO_ERROR;
WCHAR longDateFormat[81], longTimeFormat[81], wdBuffer[256], wtBuffer[256];
int32_t calType = 0;
// NULL localeID means ICU didn't recognize this locale
if (lcidRecords[i].localeID == NULL) {
continue;
}
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_SLONGDATE, longDateFormat, 81);
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_STIMEFORMAT, longTimeFormat, 81);
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_RETURN_NUMBER|LOCALE_ICALENDARTYPE, (LPWSTR) calType, sizeof(int32_t));
char localeID[64];
uprv_strcpy(localeID, lcidRecords[i].localeID);
uprv_strcat(localeID, getCalendarType(calType));
UnicodeString ubBuffer, udBuffer, utBuffer;
Locale ulocale(localeID);
int32_t wdLength, wtLength;
wdLength = GetDateFormatW(lcidRecords[i].lcid, DATE_LONGDATE, &winNow, NULL, wdBuffer, UPRV_LENGTHOF(wdBuffer));
wtLength = GetTimeFormatW(lcidRecords[i].lcid, 0, &winNow, NULL, wtBuffer, UPRV_LENGTHOF(wtBuffer));
if (uprv_strchr(localeID, '@') > 0) {
uprv_strcat(localeID, ";");
} else {
uprv_strcat(localeID, "@");
}
uprv_strcat(localeID, "compat=host");
Locale wlocale(localeID);
DateFormat *wbf = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, wlocale);
DateFormat *wdf = DateFormat::createDateInstance(DateFormat::kFull, wlocale);
DateFormat *wtf = DateFormat::createTimeInstance(DateFormat::kFull, wlocale);
wbf->format(icuNow, ubBuffer);
wdf->format(icuNow, udBuffer);
wtf->format(icuNow, utBuffer);
if (ubBuffer.indexOf(wdBuffer, wdLength - 1, 0) < 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wdBuffer);
log->errln("DateTime format error for locale " + baseName + ": expected date \"" + expected +
"\" got \"" + ubBuffer + "\"");
}
if (ubBuffer.indexOf(wtBuffer, wtLength - 1, 0) < 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wtBuffer);
log->errln("DateTime format error for locale " + baseName + ": expected time \"" + expected +
"\" got \"" + ubBuffer + "\"");
}
if (udBuffer.compare(wdBuffer) != 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wdBuffer);
log->errln("Date format error for locale " + baseName + ": expected \"" + expected +
"\" got \"" + udBuffer + "\"");
}
if (utBuffer.compare(wtBuffer) != 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wtBuffer);
log->errln("Time format error for locale " + baseName + ": expected \"" + expected +
"\" got \"" + utBuffer + "\"");
}
delete wbf;
delete wdf;
delete wtf;
}
Win32Utilities::freeLocales(lcidRecords);
delete tz;
}
int main(int argc, char* argv[])
{
if (argc != 3) {
std::cout << "usage: " << argv[0] << " hash file " << std::endl;
std::cout << " check the MD5 hash of a file" << std::endl;
std::cout << " Adobe Source Libraries v" << ADOBE_VERSION_MAJOR
<< "." << ADOBE_VERSION_MINOR << "." << ADOBE_VERSION_SUBMINOR << std::endl;
std::cout << " Boost v" << BOOST_VERSION / 100000 << "." << BOOST_VERSION / 100 % 1000
<< "." << BOOST_VERSION % 100 << std::endl;
return 1;
}
bool success = false;
try
{
adobe::md5_t m;
boost::filesystem::path file_path(argv[2], boost::filesystem::native);
boost::filesystem::ifstream stream(file_path, std::ios::binary | std::ios::in);
while (stream.good())
{
boost::array<std::ifstream::char_type, 256*1024> buffer;
stream.read(&buffer[0], static_cast<std::streamsize>(buffer.size()));
std::streamsize gcount(stream.gcount());
if (gcount > 0) m.update(&buffer[0], static_cast<std::size_t>(gcount));
}
adobe::md5_t::digest_t hash(m.final());
adobe::md5_t::digest_t::iterator first(hash.begin());
adobe::md5_t::digest_t::iterator last(hash.end());
std::string actual;
std::ostringstream oss(actual);
for(; first != last; ++first){
oss.width(2);
oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(*first);
}
std::string expected(argv[1]);
std::string::iterator e(expected.begin());
success = oss.str() == expected;
if(!success)
std::cout << "Expected: " << expected
<< " actual: " << oss.str() << std::endl;
}
catch( const std::exception& error )
{
std::cerr << "Exception: " << error.what() << std::endl;
}
catch( ... )
{
std::cerr << "Unknown exception" << std::endl;
}
return success ? 0 : 1;
}
/*==============================================================================
* FUNCTION: LoaderTest::testWinLoad
* OVERVIEW: Test loading Windows programs
*============================================================================*/
void LoaderTest::testWinLoad ()
{
std::ostringstream ost;
#if 0 /* FIXME: these tests should use non-proprietary programs */
// Load Windows program calc.exe
BinaryFileFactory bff;
BinaryFile* pBF = bff.Load(CALC_WINDOWS);
CPPUNIT_ASSERT(pBF != NULL);
int n;
SectionInfo* si;
n = pBF->GetNumSections();
ost << "Number of sections = " << std::dec << n << "\r\n";
for (int i=0; i < n; i++)
{
si = pBF->GetSectionInfo(i);
ost << si->pSectionName << "\t";
}
// Note: the string below needs to have embedded tabs. Edit with caution!
std::string expected("Number of sections = 5\r\n"
".text .rdata .data .rsrc .reloc ");
std::string actual(ost.str());
CPPUNIT_ASSERT_EQUAL(expected, actual);
ADDRESS addr = pBF->GetMainEntryPoint();
CPPUNIT_ASSERT(addr != NO_ADDRESS);
// Test symbol table (imports)
const char* s = pBF->SymbolByAddress(0x1292060U);
if (s == 0)
actual = "<not found>";
else
actual = std::string(s);
expected = std::string("SetEvent");
CPPUNIT_ASSERT_EQUAL(expected, actual);
ADDRESS a = pBF->GetAddressByName("SetEvent");
ADDRESS expectedAddr = 0x1292060;
CPPUNIT_ASSERT_EQUAL(expectedAddr, a);
pBF->UnLoad();
bff.UnLoad();
// Test loading the "new style" exes, as found in winXP etc
pBF = bff.Load(CALC_WINXP);
CPPUNIT_ASSERT(pBF != NULL);
addr = pBF->GetMainEntryPoint();
std::ostringstream ost1;
ost1 << std::hex << addr;
actual = ost1.str();
expected = "1001f51";
CPPUNIT_ASSERT_EQUAL(expected, actual);
pBF->UnLoad();
bff.UnLoad();
// Test loading the calc.exe found in Windows 2000 (more NT based)
pBF = bff.Load(CALC_WIN2000);
CPPUNIT_ASSERT(pBF != NULL);
expected = "1001680";
addr = pBF->GetMainEntryPoint();
std::ostringstream ost2;
ost2 << std::hex << addr;
actual = ost2.str();
CPPUNIT_ASSERT_EQUAL(expected, actual);
pBF->UnLoad();
bff.UnLoad();
// Test loading the lpq.exe program - console mode PE file
pBF = bff.Load(LPQ_WINDOWS);
CPPUNIT_ASSERT(pBF != NULL);
addr = pBF->GetMainEntryPoint();
std::ostringstream ost3;
ost3 << std::hex << addr;
actual = ost3.str();
expected = "18c1000";
CPPUNIT_ASSERT_EQUAL(expected, actual);
pBF->UnLoad();
bff.UnLoad();
#endif
// Borland
BinaryFileFactory bff;
BinaryFile* pBF = bff.Load(SWITCH_BORLAND);
CPPUNIT_ASSERT(pBF != NULL);
ADDRESS addr = pBF->GetMainEntryPoint();
std::ostringstream ost4;
ost4 << std::hex << addr;
std::string actual(ost4.str());
std::string expected("401150");
CPPUNIT_ASSERT_EQUAL(expected, actual);
pBF->UnLoad();
bff.UnLoad();
}
void a(std::initializer_list<int> list) {
std::vector<int> expected(list);
// EXPECT_TRUE(ArraysMatch(expected, vec));
EXPECT_THAT(vec, ::testing::ContainerEq(expected));
}
void IntlCalendarTest::TestJapaneseFormat() {
Calendar *cal;
UErrorCode status = U_ZERO_ERROR;
cal = Calendar::createInstance("ja_JP_TRADITIONAL", status);
CHECK(status, UnicodeString("Creating ja_JP_TRADITIONAL calendar"));
Calendar *cal2 = cal->clone();
delete cal;
cal = NULL;
// Test simple parse/format with adopt
UDate aDate = 999932400000.0;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yy G"), Locale("en_US@calendar=japanese"), status);
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("September 8, 13 Heisei");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " + otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
// Test parse with incomplete information
fmt = new SimpleDateFormat(UnicodeString("G y"), Locale("en_US@calendar=japanese"), status);
/* The test data below should points to 1868-09-08T00:00:00 in America/Los_Angeles.
* The time calculated by original test code uses -7:00 UTC offset, because it assumes
* DST is observed (because of a timezone bug, DST is observed for early 20th century
* day to infinite past time). The bug was fixed and DST is no longer used for time before
* 1900 for any zones. However, ICU timezone transition data is represented by 32-bit integer
* (sec) and cannot represent transitions before 1901 defined in Olson tzdata. For example,
* based on Olson definition, offset -7:52:58 should be used for Nov 18, 1883 or older dates.
* If ICU properly capture entire Olson zone definition, the start time of "Meiji 1" is
* -3197117222000. -Yoshito
*/
/* TODO: When ICU support the Olson LMT offset for America/Los_Angeles, we need to update
* the reference data.
*/
//aDate = -3197120400000.;
aDate = -3197116800000.;
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("Meiji 1");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " +
otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete cal2;
delete fmt2;
CHECK(status, "Error occured");
// Now, try in Japanese
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP_TRADITIONAL"); // legacy
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5b89\\u6c385\\u5e747\\u67084\\u65e5\\u6728\\u66dc\\u65e5");
//UDate expectDate = -6106035600000.0;
UDate expectDate = -6106032000000.0; // 1776-07-04T00:00:00Z-0800
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // Jitterbug 1869 - this is an ambiguous era. (Showa 64 = Jan 6 1989, but Showa could be 2 other eras) )
UnicodeString expect = CharsToUnicodeString("\\u662d\\u548c64\\u5e741\\u67086\\u65e5\\u91d1\\u66dc\\u65e5");
UDate expectDate = 600076800000.0;
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // This Feb 29th falls on a leap year by gregorian year, but not by Japanese year.
UnicodeString expect = CharsToUnicodeString("\\u5EB7\\u6B632\\u5e742\\u670829\\u65e5\\u65e5\\u66dc\\u65e5");
// Add -1:00 to the following for historical TZ - aliu
//UDate expectDate = -16214403600000.0; // courtesy of date format round trip test
UDate expectDate = -16214400000000.0; // 1456-03-09T00:00:00Z-0800
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
}
void
PluralFormatTest::pluralFormatExtendedTest(void) {
const char *targets[] = {
"There are no widgets.",
"There is one widget.",
"There is a bling widget and one other widget.",
"There is a bling widget and 2 other widgets.",
"There is a bling widget and 3 other widgets.",
"Widgets, five (5-1=4) there be.",
"There is a bling widget and 5 other widgets.",
"There is a bling widget and 6 other widgets.",
};
const char* fmt =
"offset:1.0 "
"=0 {There are no widgets.} "
"=1.0 {There is one widget.} "
"=5 {Widgets, five (5-1=#) there be.} "
"one {There is a bling widget and one other widget.} "
"other {There is a bling widget and # other widgets.}";
UErrorCode status = U_ZERO_ERROR;
UnicodeString fmtString(fmt, -1, US_INV);
PluralFormat pf(Locale::getEnglish(), fmtString, status);
MessageFormat mf(UNICODE_STRING_SIMPLE("{0,plural,").append(fmtString).append((UChar)0x7d /* '}' */),
Locale::getEnglish(), status);
Formattable args;
FieldPosition ignore;
if (U_FAILURE(status)) {
dataerrln("Failed to apply pattern - %s", u_errorName(status));
return;
}
for (int32_t i = 0; i < 7; ++i) {
UnicodeString result = pf.format(i, status);
if (U_FAILURE(status)) {
errln("PluralFormat.format(value %d) failed - %s", i, u_errorName(status));
return;
}
UnicodeString expected(targets[i], -1, US_INV);
if (expected != result) {
UnicodeString message("PluralFormat.format(): Expected '", -1, US_INV);
message.append(expected);
message.append(UnicodeString("' but got '", -1, US_INV));
message.append(result);
message.append("'", -1, US_INV);
errln(message);
}
args.setLong(i);
mf.format(&args, 1, result.remove(), ignore, status);
if (U_FAILURE(status)) {
errln("MessageFormat.format(value %d) failed - %s", i, u_errorName(status));
return;
}
if (expected != result) {
UnicodeString message("MessageFormat.format(): Expected '", -1, US_INV);
message.append(expected);
message.append(UnicodeString("' but got '", -1, US_INV));
message.append(result);
message.append("'", -1, US_INV);
errln(message);
}
}
}
void testImplementationInt()
{
typedef short_vec<CARGO, ARITY> ShortVec;
const int numElements = ShortVec::ARITY * 10;
std::vector<CARGO> vec1(numElements);
std::vector<CARGO> vec2(numElements, 4711);
// init vec1:
for (int i = 0; i < numElements; ++i) {
vec1[i] = i;
}
// test default c-tor:
for (int i = 0; i < numElements; ++i) {
BOOST_TEST(4711 == vec2[i]);
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST(0 == vec2[i]);
}
// tests vector load/store:
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(i, vec2[i]);
}
// tests scalar load, vector add:
ShortVec w = vec1[1];
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << (v + w);
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ((i + 1), vec2[i]);
}
// tests +=
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v += w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ((2 * i + 1), vec2[i]);
}
// test -
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v - w);
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ((-i - 1), vec2[i]);
}
// test -=
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v -= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ((2 * i + 1), vec2[i]);
}
// test *
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v * w);
}
for (int i = 0; i < numElements; ++i) {
int reference = (i * (2 * i + 1));
BOOST_TEST_EQ(reference, vec2[i]);
}
// test *=
for (int i = 0; i < numElements; ++i) {
vec2[i] = i + 2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v *= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(i * (i + 2), vec2[i]);
}
// test /
for (int i = 0; i < numElements; ++i) {
vec1[i] = 4 * (i + 1);
vec2[i] = (i + 1);
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << (v / w);
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(4, vec2[i]);
}
// test /=
for (int i = 0; i < numElements; ++i) {
vec1[i] = 4 * (i + 1);
vec2[i] = (i + 1);
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
v /= w;
&vec2[i] << v;
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(4, vec2[i]);
}
// test sqrt()
for (int i = 0; i < numElements; ++i) {
vec1[i] = i * i;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
&vec2[i] << sqrt(v);
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(i, vec2[i]);
}
// test "/ sqrt()"
for (int i = 0; i < numElements; ++i) {
vec1[i] = (i + 1) * (i + 1);
vec2[i] = (i + 1) * 2;
}
for (int i = 0; i < (numElements - ShortVec::ARITY + 1); i += ShortVec::ARITY) {
ShortVec v = &vec1[i];
ShortVec w = &vec2[i];
&vec2[i] << w / sqrt(v);
}
for (int i = 0; i < numElements; ++i) {
BOOST_TEST_EQ(2, vec2[i]);
}
// test string conversion
for (int i = 0; i < ShortVec::ARITY; ++i) {
vec1[i] = i + 5;
}
ShortVec v(&vec1[0]);
std::ostringstream buf1;
buf1 << v;
std::ostringstream buf2;
buf2 << "[";
for (int i = 0; i < (ShortVec::ARITY - 1); ++i) {
buf2 << (i + 5) << ", ";
}
buf2 << (ShortVec::ARITY - 1 + 5) << "]";
BOOST_TEST(buf1.str() == buf2.str());
// test gather
{
CARGO array[ARITY * 10];
std::vector<int, aligned_allocator<int, 64> > indices(ARITY);
CARGO actual[ARITY];
CARGO expected[ARITY];
std::memset(array, '\0', sizeof(CARGO) * ARITY * 10);
for (int i = 0; i < ARITY * 10; ++i) {
if (i % 10 == 0) {
array[i] = i + 5;
}
}
for (int i = 0; i < ARITY; ++i) {
indices[i] = i * 10;
expected[i] = (i * 10) + 5;
}
ShortVec vec;
vec.gather(array, &indices[0]);
actual << vec;
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(actual[i], expected[i]);
}
}
#ifdef LIBFLATARRAY_WITH_CPP14
// test gather via initializer_list
{
CARGO actual1[ARITY];
CARGO actual2[ARITY];
CARGO expected[ARITY];
for (int i = 0; i < ARITY; ++i) {
expected[i] = (i * 10) + 5;
}
// max: 32
ShortVec vec1 = { 5, 15, 25, 35, 45, 55, 65, 75,
85, 95, 105, 115, 125, 135, 145, 155,
165, 175, 185, 195, 205, 215, 225, 235,
245, 255, 265, 275, 285, 295, 305, 315 };
ShortVec vec2;
vec2 = { 5, 15, 25, 35, 45, 55, 65, 75,
85, 95, 105, 115, 125, 135, 145, 155,
165, 175, 185, 195, 205, 215, 225, 235,
245, 255, 265, 275, 285, 295, 305, 315 };
actual1 << vec1;
actual2 << vec2;
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(actual1[i], expected[i]);
BOOST_TEST_EQ(actual2[i], expected[i]);
}
}
#endif
// test scatter
{
ShortVec vec;
CARGO array[ARITY * 10];
CARGO expected[ARITY * 10];
std::vector<int, aligned_allocator<int, 64> > indices(ARITY);
std::memset(array, '\0', sizeof(CARGO) * ARITY * 10);
std::memset(expected, '\0', sizeof(CARGO) * ARITY * 10);
for (int i = 0; i < ARITY * 10; ++i) {
if (i % 10 == 0) {
expected[i] = i + 5;
}
}
for (int i = 0; i < ARITY; ++i) {
indices[i] = i * 10;
}
vec.gather(expected, &indices[0]);
vec.scatter(array, &indices[0]);
for (int i = 0; i < ARITY * 10; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
}
// test non temporal stores
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
expected[i] = 5;
}
ShortVec v1 = 5;
v1.store_nt(&array[0]);
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
for (int i = 0; i < ARITY; ++i) {
expected[i] = i;
}
ShortVec v2 = &expected[0];
v2.store_nt(&array[0]);
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
}
// test aligned stores
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
expected[i] = 5;
}
ShortVec v1 = 5;
v1.store_aligned(&array[0]);
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
for (int i = 0; i < ARITY; ++i) {
expected[i] = i;
}
ShortVec v2 = &expected[0];
v2.store_aligned(&array[0]);
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
}
// test aligned loads
{
std::vector<CARGO, aligned_allocator<CARGO, 64> > array(ARITY);
std::vector<CARGO, aligned_allocator<CARGO, 64> > expected(ARITY);
for (int i = 0; i < ARITY; ++i) {
array[i] = i;
expected[i] = 0;
}
ShortVec v1;
v1.load_aligned(&array[0]);
v1.store(&expected[0]);
for (int i = 0; i < ARITY; ++i) {
BOOST_TEST_EQ(array[i], expected[i]);
}
}
}
// Get a statement
numvar getstatement(void) {
numvar retval = 0;
#if !defined(TINY_BUILD) && !defined(UNIX_BUILD)
chkbreak();
#endif
if (sym == s_while) {
// at this point sym is pointing at s_while, before the conditional expression
// save fetchptr so we can restart parsing from here as the while iterates
parsepoint fetchmark;
markparsepoint(&fetchmark);
for (;;) {
returntoparsepoint(&fetchmark, 0);
getsym(); // fetch the start of the conditional
if (getnum()) {
retval = getstatement();
if (sym == s_returning) break; // exit if we caught a return
}
else {
skipstatement();
break;
}
}
}
else if (sym == s_if) {
getsym(); // eat "if"
if (getnum()) {
retval = getstatement();
if (sym == s_else) {
getsym(); // eat "else"
skipstatement();
}
} else {
skipstatement();
if (sym == s_else) {
getsym(); // eat "else"
retval = getstatement();
}
}
}
else if (sym == s_lcurly) {
getsym(); // eat "{"
while ((sym != s_eof) && (sym != s_returning) && (sym != s_rcurly)) retval = getstatement();
if (sym == s_rcurly) getsym(); // eat "}"
}
else if (sym == s_return) {
getsym(); // eat "return"
if ((sym != s_eof) && (sym != s_semi)) retval = getnum();
sym = s_returning; // signal we're returning up the line
}
#if !defined(TINY_BUILD)
else if (sym == s_switch) retval = getswitchstatement();
#endif
else if (sym == s_function) cmd_function();
else if (sym == s_run) { // run macroname
getsym();
if ((sym != s_script_eeprom) && (sym != s_script_progmem) &&
(sym != s_script_file)) unexpected(M_id);
// address of macroid is in symval via parseid
// check for [,snoozeintervalms]
getsym(); // eat macroid to check for comma; symval untouched
if (sym == s_comma) {
vpush(symval);
getsym(); // eat the comma
getnum(); // get a number or else
startTask(vpop(), expval);
}
else startTask(symval, 0);
}
else if (sym == s_stop) {
getsym();
#if !defined(TINY_BUILD)
if (sym == s_mul) { // stop * stops all tasks
initTaskList();
getsym();
}
else if ((sym == s_semi) || (sym == s_eof)) {
if (background) stopTask(curtask); // stop with no args stops the current task IF we're in back
else initTaskList(); // in foreground, stop all
}
else
#endif
stopTask(getnum());
}
else if (sym == s_rm) { // rm "sym" or rm *
getsym();
if (sym == s_script_eeprom) {
eraseentry(idbuf);
}
#if !defined(TINY_BUILD)
else if (sym == s_mul) nukeeeprom();
#endif
else if (sym != s_undef) expected(M_id);
getsym();
}
else if (sym == s_ls) { getsym(); cmd_ls(); }
#if !defined(TINY_BUILD)
else if (sym == s_boot) cmd_boot();
else if (sym == s_ps) { getsym(); showTaskList(); }
else if (sym == s_peep) { getsym(); cmd_peep(); }
else if (sym == s_help) { getsym(); cmd_help(); }
#endif
else if (sym == s_print) { getsym(); cmd_print(); }
else if (sym == s_semi) { ; } // ;)
#ifdef HEX_UPLOAD
// a line beginning with a colon is treated as a hex record
// containing data to upload to eeprom
//
// TODO: verify checksum
//
else if (sym == s_colon) {
// fetchptr points at the byte count
byte byteCount = gethex(2); // 2 bytes byte count
int addr = gethex(4); // 4 bytes address
byte recordType = gethex(2); // 2 bytes record type; now fetchptr -> data
if (recordType == 1) reboot(); // reboot on EOF record (01)
if (recordType != 0) return; // we only handle the data record (00)
if (addr == 0) nukeeeprom(); // auto-clear eeprom on write to 0000
while (byteCount--) eewrite(addr++, gethex(2)); // update the eeprom
gethex(2); // discard the checksum
getsym(); // and re-prime the parser
}
#endif
else {
getexpression();
retval = expval;
}
if (sym == s_semi) getsym(); // eat trailing ';'
return retval;
}
static void extractItem(char *buffer, SEXP ans, int i, LocalData *d)
{
char *endp;
switch(TYPEOF(ans)) {
case NILSXP:
break;
case LGLSXP:
if (isNAstring(buffer, 0, d))
LOGICAL(ans)[i] = NA_INTEGER;
else {
int tr = StringTrue(buffer), fa = StringFalse(buffer);
if(tr || fa) LOGICAL(ans)[i] = tr;
else expected("a logical", buffer, d);
}
break;
case INTSXP:
if (isNAstring(buffer, 0, d))
INTEGER(ans)[i] = NA_INTEGER;
else {
INTEGER(ans)[i] = Strtoi(buffer, 10);
if (INTEGER(ans)[i] == NA_INTEGER)
expected("an integer", buffer, d);
}
break;
case REALSXP:
if (isNAstring(buffer, 0, d))
REAL(ans)[i] = NA_REAL;
else {
REAL(ans)[i] = Strtod(buffer, &endp, TRUE, d);
if (!isBlankString(endp))
expected("a real", buffer, d);
}
break;
case CPLXSXP:
if (isNAstring(buffer, 0, d))
COMPLEX(ans)[i].r = COMPLEX(ans)[i].i = NA_REAL;
else {
COMPLEX(ans)[i] = strtoc(buffer, &endp, TRUE, d);
if (!isBlankString(endp))
expected("a complex", buffer, d);
}
break;
case STRSXP:
if (isNAstring(buffer, 1, d))
SET_STRING_ELT(ans, i, NA_STRING);
else
SET_STRING_ELT(ans, i, insertString(buffer, d));
break;
case RAWSXP:
if (isNAstring(buffer, 0, d))
RAW(ans)[i] = 0;
else {
RAW(ans)[i] = strtoraw(buffer, &endp);
if (!isBlankString(endp))
expected("a raw", buffer, d);
}
break;
default:
UNIMPLEMENTED_TYPE("extractItem", ans);
}
}
void simplePlot2D(){
///gROOT->ProcessLine(".x paperStyle.C");
gStyle->SetCanvasDefH(600); //Height of canvas
gStyle->SetCanvasDefW(640); //Width of canvas
gStyle->SetCanvasDefX(0); //POsition on screen
gStyle->SetCanvasDefY(0);
gStyle->SetPadLeftMargin(0.125);//0.16);
gStyle->SetPadRightMargin(0.165);//0.02);
gStyle->SetPadTopMargin(0.085);//0.02);
gStyle->SetPadBottomMargin(0.12);//0.02);
// For g axis titles:
gStyle->SetTitleColor(1, "XYZ");
gStyle->SetTitleFont(42, "XYZ");
gStyle->SetTitleSize(0.045, "Z");
gStyle->SetTitleSize(0.055, "XY");
gStyle->SetTitleXOffset(1.0);//0.9);
gStyle->SetTitleYOffset(1.12); // => 1.15 if exponents
// For g axis labels:
gStyle->SetLabelColor(1, "XYZ");
gStyle->SetLabelFont(42, "XYZ");
gStyle->SetLabelOffset(0.007, "XYZ");
gStyle->SetLabelSize(0.04, "XYZ");
// Legends
gStyle->SetLegendBorderSize(0);
gStyle->SetLegendFillColor(kWhite);
gStyle->SetLegendFont(42);
gStyle->SetOptStat(0);
//gStyle->SetPalette(51);
/*
// Fewer colors, one band per 0.1
// *************************************************************
int ncontours = 10;
double stops[6] = {0.0 , .2, .4, .6, .8, 1};
double blue[6] = {1.0 , 1, 1, 1, 1, 1};
double green[6] = {0.1, 0.3, 0.5, 0.72, 0.82, 1};
double red [6] = {0.1, 0.2, 0.24, 0.45, 0.7, 1};
int npoints = 6;
TColor::CreateGradientColorTable(npoints, stops, red, green, blue, ncontours);
gStyle->SetNumberContours(ncontours);
//gStyle->SetPalette(kCherry);
// *************************************************************
*/
// *************************************************************
int ncontours = 15;
double stops[5] = {0.0 , .1, .25 , .5 , 1 };
double blue[5] = {1.0 , 1. , 1 , 1 , 1.00 };
double green[5] = {0.25 , 0.3 , 0.5 , 0.75 , 1.00 };
double red [5] = {0.1, 0.15 , 0.4 , 0.6 , 1.00 };
int npoints = 5;
TColor::CreateGradientColorTable(npoints, stops, red, green, blue, ncontours);
gStyle->SetNumberContours(ncontours);
// *************************************************************
TFile *fi = TFile::Open("allpoints.root");
TTree *tree = (TTree*)fi->Get("limit");
TH2D expected(grKappa(tree,-1));
TH2D dummyK("dummyK","dummy",1,KVMIN,KVMAX,1,KFMIN,KFMAX);
dummyK.SetTitle("");
dummyK.GetZaxis()->SetTitleOffset(1.2);
dummyK.GetYaxis()->SetTitle("#it{#kappa}_{F}");
dummyK.GetXaxis()->SetTitle("#it{#kappa}_{V}");
//dummyK.GetXaxis()->SetRangeUser(KVMIN,KVMAX);
//dummyK.GetYaxis()->SetRangeUser(KFMIN,KFMAX);
dummyK.GetZaxis()->SetTitle("B(H #rightarrow inv.) - 95% CL upper limit");
//dummyK.GetXaxis()->SetLimits(KVMIN,KVMAX);
//dummyK.GetYaxis()->SetLimits(KFMIN,KFMAX);
//dummyK.SetMaximum(0.8);
//dummyK.SetMinimum(0.1);
TCanvas *can = new TCanvas("cc","c",800,720);
can->cd();
//expected.GetXaxis()->SetRangeUser(KVMIN,KVMAX);
//expected.GetYaxis()->SetRangeUser(KFMIN,KFMAX);
TFile *flhc = TFile::Open("scan2d_kappa_V_kappa_F_exp.root");
TGraph *grlhc_68 = (TGraph*) flhc->Get("graph68_comb_0");
TGraph *grlhc_95 = (TGraph*) flhc->Get("graph95_comb_0");
TGraph *grlhc_bf = (TGraph*) flhc->Get("comb_best");
grlhc_68->SetLineColor(kWhite);
grlhc_95->SetLineColor(kWhite);
grlhc_bf->SetMarkerStyle(34);
grlhc_bf->SetMarkerSize(1.8);
grlhc_bf->SetMarkerColor(kWhite);
grlhc_68->SetLineWidth(2);
grlhc_95->SetLineWidth(2);
grlhc_95->SetLineStyle(2);
TH2D *histocomb = (TH2D*)flhc->Get("comb_hist_processed");
double xmin =expected.GetXaxis()->GetXmin();
double xmax =expected.GetXaxis()->GetXmax();
double ymin =expected.GetYaxis()->GetXmin();
double ymax =expected.GetYaxis()->GetXmax();
TLine SMH(KVMIN,1,KVMAX,1);
TLine SMV(1,KFMIN,1,KFMAX);
// TLine SMH(xmin,1,xmax,1);
// TLine SMV(1,ymin,1,ymax);
SMH.SetLineColor(2);
SMH.SetLineStyle(2);
SMV.SetLineColor(2);
SMV.SetLineStyle(2);
//dummyK.Draw("AXIS");
expected.Draw("colz");
grlhc_68->Draw("Lsame");
grlhc_95->Draw("Lsame");
grlhc_bf->Draw("Psame");
SMH.Draw("L");
SMV.Draw("L");
decorate(can,expected);
printRanges(&expected,histocomb);
can->SaveAs("couplings_limits.pdf");
TFile *fiMU = TFile::Open("allpoints_mu.root");
TTree *treeMU = (TTree*)fiMU->Get("limit");
TH2D expectedmu(grMu(treeMU,-1));
TH2D dummyMu("dummyMu","dummy",1,MUVMIN,MUVMAX,1,MUFMIN,MUFMAX);
dummyMu.SetTitle("");
dummyMu.GetZaxis()->SetTitleOffset(1.2);
dummyMu.GetYaxis()->SetTitle("#it{#mu}_{ggH}");
dummyMu.GetXaxis()->SetTitle("#it{#mu}_{qqH,VH}");
dummyMu.GetZaxis()->SetTitle("B(H #rightarrow inv.) - 95% CL upper limit");
//dummyMu.GetXaxis()->SetRangeUser(MUVMIN,MUVMAX);
//dummyMu.GetYaxis()->SetRangeUser(MUFMIN,MUFMAX);
//dummyMu.GetXaxis()->SetLimits(MUVMIN,MUVMAX);
//dummyMu.GetYaxis()->SetLimits(MUFMIN,MUFMAX);
//dummyMu.SetMaximum(0.8);
//dummyMu.SetMinimum(0.1);
//expectedmu.GetXaxis()->SetRangeUser(KVMIN,KVMAX);
//expectedmu.GetYaxis()->SetRangeUser(KFMIN,KFMAX);
xmin =expectedmu.GetXaxis()->GetXmin();
xmax =expectedmu.GetXaxis()->GetXmax();
ymin =expectedmu.GetYaxis()->GetXmin();
ymax =expectedmu.GetYaxis()->GetXmax();
TLine SM2H(MUVMIN,1,MUVMAX,1);
TLine SM2V(1,MUFMIN,1,MUFMAX);
//TLine SM2H(xmin,1,xmax,1);
//TLine SM2V(1,ymin,1,ymax);
SM2H.SetLineColor(2);
SM2H.SetLineStyle(2);
SM2V.SetLineColor(2);
SM2V.SetLineStyle(2);
//dummyMu.Draw("axis");
expectedmu.Draw("colz");
TH2D *expectedmuCont = (TH2D*)expectedmu.Clone();
//expectedmuCont->SetName("contours");
//expectedmuCont->SetContour(15);
//expectedmuCont->Draw("cont2 same");
SM2H.Draw("L");
SM2V.Draw("L");
decorate(can,expectedmu,false);
can->SaveAs("mu_limits.pdf");
}
void Parser::parse(double &real)
{
if (!lex.getNextToken()) throw expected("real", "end of stream", lex);
if (lex.tokenType() != Lexer::Real) throw expected("real", lex);
real = lex.getReal();
}
TEST(TermTableBuilder, GeneralCases)
{
// Construct a test environment that provides the ITermTreatment
// and DocumentFrequencyTable to be used by the TermTableBuilder.
// The test environment also provides a hand-constructed expected
// TermTable for verification purposes.
TestEnvironment environment;
// Run the TermTableBuilder to configure a TermTable.
ITermTreatment const & treatment = environment.GetTermTreatment();
DocumentFrequencyTable const & terms =
environment.GetDocFrequencyTable();
IFactSet const & facts = environment.GetFactSet();
TermTable termTable;
double density = 0.1;
double adhocFrequency = 0.0001;
unsigned c_randomSkipDistance = 0;
TermTableBuilder builder(density,
adhocFrequency,
treatment,
terms,
facts,
termTable,
c_randomSkipDistance);
// builder.Print(std::cout);
//
// Verify that configured TermTable is the same as the expected
// TermTable provided by the environment.
//
// Ensure that all known terms have the same RowIdSequences.
// NOTE: This test relies on the existence of a separate unit test
// for TermTable that ensures that RowIds and Terms are added
// correctly. Without such a test, a bogus TermTable that ignores
// all RowId additions would allow TermTableBuilderTest to pass
// (because they will both return the empty set of rows).
for (auto term : terms)
{
RowIdSequence expected(term.GetTerm(),
environment.GetTermTable());
RowIdSequence observed(term.GetTerm(), termTable);
EXPECT_TRUE(std::equal(observed.begin(),
observed.end(),
expected.begin()));
EXPECT_TRUE(std::equal(expected.begin(),
expected.end(),
observed.begin()));
}
// NOTE: This test relies on the existence of a separate unit test
// for TermTable that ensures that row counts are recorded
// correctly. Without such a test, a bogus TermTable that ignores
// all SetRowCounts would allow TermTableBuilderTest to pass.
for (Rank rank = 0; rank <= c_maxRankValue; ++rank)
{
EXPECT_EQ(environment.GetTermTable().GetTotalRowCount(rank),
termTable.GetTotalRowCount(rank));
}
// TODO: Verify adhoc
// TODO: Verify facts
// TODO: Verify row counts.
}
void Parser::parse(int &i)
{
if (!lex.getNextToken()) throw expected("integer", "end of stream", lex);
if (lex.tokenType() != Lexer::Integer) throw expected("integer", lex);
i = lex.getInteger();
}
/*==============================================================================
* FUNCTION: DfaTest::testMeetInt
* OVERVIEW: Test meeting IntegerTypes with various other types
*============================================================================*/
void DfaTest::testMeetInt()
{
IntegerType i32(32, 1);
IntegerType j32(32, 0);
IntegerType u32(32, -1);
IntegerType xint(0);
IntegerType j16(16, 0);
SizeType s32(32);
SizeType s64(64);
FloatType flt(32);
PointerType pt(&flt);
VoidType v;
bool ch = false;
i32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost1;
ost1 << &i32;
std::string actual(ost1.str());
std::string expected("i32");
CPPUNIT_ASSERT_EQUAL(expected, actual);
i32.meetWith(&j32, ch, false);
CPPUNIT_ASSERT(ch == false);
j32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost2;
ost2 << &i32;
actual = ost2.str();
expected = "i32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.setSigned(0);
j32.meetWith(&v, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost2a;
ost2a << &j32;
actual = ost2a.str();
expected = "j32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.meetWith(&u32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost3;
ost3 << &j32;
actual = ost3.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
u32.meetWith(&s32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost4;
ost4 << &u32;
actual = ost4.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
u32.meetWith(&s64, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost5;
ost5 << &u32;
actual = ost5.str();
expected = "u64";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
Type *res = i32.meetWith(&flt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost6;
ost6 << res;
actual = ost6.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
res = i32.meetWith(&pt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost7;
ost7 << res;
actual = ost7.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
}
void Parser::parse(char &ch)
{
if (!lex.getNextToken()) throw expected("character", "end of stream", lex);
lex.ungetToken();
if (!test(ch)) throw expected("character", lex);
}
char get_num()
{
if(isdigit(look)==0) expected("Integer");
get_char();
return look;
}
void Parser::parse(Identifier &identifier)
{
if (!lex.getNextToken()) throw expected("identifier", "end of stream", lex);
if (lex.tokenType() != Lexer::Identifier) throw expected("identifier", lex);
identifier.str = lex.getIdentifier();
}
// Get a number from the input stream. Result to expval.
numvar getnum(void) {
getexpression();
if (exptype != s_nval) expected(M_number);
return expval;
}
void Parser::parse(string &str)
{
if (!lex.getNextToken()) throw expected("string", "end of stream", lex);
if (lex.tokenType() != Lexer::String) throw expected("string", lex);
str = lex.getString();
}
size_t Approximator::test_function (
const std::string & name,
const Function & fun)
{
POMAGMA_INFO("Testing " << name << " approximation");
size_t ob_fail_count = 0;
size_t upper_fail_count = 0;
size_t upper_extra_count = 0;
size_t upper_missing_count = 0;
size_t lower_fail_count = 0;
size_t lower_extra_count = 0;
size_t lower_missing_count = 0;
const size_t item_dim = m_item_dim;
#pragma omp parallel
{
DenseSet temp_set(item_dim);
#pragma omp for schedule(dynamic, 1)
for (Ob x = 1; x <= item_dim; ++x) {
Approximation approx_x(x, m_less);
approx_x.ob = 0;
for (auto iter = fun.iter_lhs(x); iter.ok(); iter.next()) {
Ob y = * iter;
Approximation approx_y(y, m_less);
approx_y.ob = 0;
Ob xy = fun.find(x, y);
Approximation expected(xy, m_less);
Approximation actual = find(fun, approx_x, approx_y);
if (actual.ob != expected.ob) {
#pragma omp atomic
ob_fail_count += 1;
}
if (actual.upper != expected.upper) {
#pragma omp atomic
upper_fail_count += 1;
temp_set.set_diff(actual.upper, expected.upper);
if (size_t count = temp_set.count_items()) {
#pragma omp atomic
upper_extra_count += count;
}
temp_set.set_diff(expected.upper, actual.upper);
if (size_t count = temp_set.count_items()) {
#pragma omp atomic
upper_missing_count += count;
}
}
if (actual.lower != expected.lower) {
#pragma omp atomic
lower_fail_count += 1;
temp_set.set_diff(actual.lower, expected.lower);
if (size_t count = temp_set.count_items()) {
#pragma omp atomic
lower_extra_count += count;
}
temp_set.set_diff(expected.lower, actual.lower);
if (size_t count = temp_set.count_items()) {
#pragma omp atomic
lower_missing_count += count;
}
}
}
}
}
if (ob_fail_count) {
POMAGMA_WARN(name << " ob failed " << ob_fail_count << " cases");
}
if (upper_missing_count or upper_extra_count) {
POMAGMA_WARN(name << " upper has "
<< upper_missing_count << " missing and "
<< upper_extra_count << " extra obs in "
<< upper_fail_count << " cases");
}
if (lower_missing_count or lower_extra_count) {
POMAGMA_WARN(name << " lower has "
<< lower_missing_count << " missing and "
<< lower_extra_count << " extra obs in "
<< lower_fail_count << " cases");
}
return ob_fail_count + upper_fail_count + lower_fail_count;
}
TEST(Basic, FAIL04){
vector<pair<int, int>> input({});
vector<int> expected({ 0 });
Solution sol;
ASSERT_EQ(sol.findOrder(1, input), expected);
}