starmath/qa/cppunit/test_nodetotextvisitors.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11 #include <test/bootstrapfixture.hxx>
  12
  13 #include <vcl/virdev.hxx>
  14 #include <sfx2/sfxmodelfactory.hxx>
  15 #include <smdll.hxx>
  16
  17 #include <document.hxx>
  18 #include <node.hxx>
  19 #include <visitors.hxx>
  20 #include <cursor.hxx>
  21
  22 #include "mock-visitor.hxx"
  23 #include <memory>
  24
  25 typedef tools::SvRef<SmDocShell> SmDocShellRef;
  26
  27 using namespace ::com::sun::star;
  28
  29 namespace
  30 {
  31 class Test : public test::BootstrapFixture
  32 {
  33 public:
  34     // init
  35     virtual void setUp() override;
  36     virtual void tearDown() override;
  37
  38     // tests
  39     void SimpleUnaryOp();
  40     void SimpleBinaryOp();
  41     void SimpleRelationalOp();
  42     void SimpleSetOp();
  43     void SimpleFunctions();
  44     void SimpleOperators();
  45     void SimpleAttributes();
  46     void SimpleMisc();
  47     void SimpleBrackets();
  48     void SimpleFormats();
  49     void SimpleGreekChars();
  50     void SimpleSpecialChars();
  51     void testBinomInBinHor();
  52     void testBinVerInUnary();
  53     void testBinHorInSubSup();
  54     void testUnaryInMixedNumberAsNumerator();
  55     void testMiscEquivalent();
  56     void testParser();
  57
  58     CPPUNIT_TEST_SUITE(Test);
  59     CPPUNIT_TEST(SimpleUnaryOp);
  60     CPPUNIT_TEST(SimpleBinaryOp);
  61     CPPUNIT_TEST(SimpleRelationalOp);
  62     CPPUNIT_TEST(SimpleSetOp);
  63     CPPUNIT_TEST(SimpleFunctions);
  64     CPPUNIT_TEST(SimpleOperators);
  65     CPPUNIT_TEST(SimpleAttributes);
  66     CPPUNIT_TEST(SimpleMisc);
  67     CPPUNIT_TEST(SimpleBrackets);
  68     CPPUNIT_TEST(SimpleFormats);
  69     CPPUNIT_TEST(SimpleGreekChars);
  70     CPPUNIT_TEST(SimpleSpecialChars);
  71     CPPUNIT_TEST(testBinomInBinHor);
  72     CPPUNIT_TEST(testBinVerInUnary);
  73     CPPUNIT_TEST(testBinHorInSubSup);
  74     CPPUNIT_TEST(testUnaryInMixedNumberAsNumerator);
  75     CPPUNIT_TEST(testMiscEquivalent);
  76     CPPUNIT_TEST(testParser);
  77     CPPUNIT_TEST_SUITE_END();
  78
  79 private:
  80     SmDocShellRef xDocShRef;
  81     void parseandparseagain(const char* input, const char* test_name);
  82     void ParseAndCheck(const char* input, const char* expected, const char* test_name);
  83     void ParseAndCompare(const char* formula1, const char* formula2, const char* test_name);
  84 };
  85
  86 void Test::setUp()
  87 {
  88     BootstrapFixture::setUp();
  89
  90     SmGlobals::ensure();
  91
  92     xDocShRef = new SmDocShell(SfxModelFlags::EMBEDDED_OBJECT);
  93 }
  94
  95 void Test::tearDown()
  96 {
  97     xDocShRef.clear();
  98     BootstrapFixture::tearDown();
  99 }
 100
 101 /*
 102  * Most of the formula commands in this file came from:
 103  * http://wiki.openoffice.org/wiki/Template:Math_commands_reference
 104  * which was licensed with a
 105  * Creative Common Attribution 3.0 license and written by:
 106  * Jeanweber, Weegreenblobbie, Jdpipe, TJFrazier, Ysangkok, B michaelsen, Spellbreaker
 107  */
 108
 109 void Test::SimpleUnaryOp()
 110 {
 111     parseandparseagain("+1", "Positive (plus)");
 112     parseandparseagain("-2", "Negative (minus)");
 113     parseandparseagain("+-3", "Plus/minus");
 114     parseandparseagain("-+4", "Minus/plus");
 115     parseandparseagain("neg a", "Boolean 'not'");
 116     parseandparseagain("fact a", "Factorial");
 117     parseandparseagain("- { 1 over 2 }", "BinVer in Unary 1");
 118     ParseAndCheck("- { 1 over 2 }", "- { 1 over 2 }", "BinVer in Unary 1");
 119     parseandparseagain("{- { 1 over 2 } }", "BinVer in Unary 2");
 120     parseandparseagain("- 1 over 2", "Unary in BinVer as numerator 1");
 121     parseandparseagain("{ - 1 } over 2", "Unary in BinVer as numerator 2");
 122     parseandparseagain("1 over - 2", "Unary in BinVer as denominator 1");
 123     parseandparseagain("1 over { - 2 }", "Unary in BinVer as denominator 2");
 124     parseandparseagain("2 { - 1 over 2 }", "Mixed number with Unary in denominator 1");
 125     parseandparseagain("2 { - 1 } over 2", "Mixed number with Unary in denominator 2");
 126     parseandparseagain("- 1 + 2", "Unary in BinHor");
 127 }
 128
 129 void Test::SimpleBinaryOp()
 130 {
 131     parseandparseagain("a + b", "Addition");
 132     parseandparseagain("a cdot b", "Dot product");
 133     parseandparseagain("a times b", "Cross product");
 134     parseandparseagain("a * b", "Multiplication (asterisk)");
 135     parseandparseagain("a and b", "Boolean 'and'");
 136     parseandparseagain("a - b", "Subtraction");
 137     parseandparseagain("a over b", "Division (as a fraction)");
 138     parseandparseagain("a div b", "Division (as an operator)");
 139     parseandparseagain("a / b", "Division (with a slash)");
 140     parseandparseagain("a or b", "Boolean 'or'");
 141     parseandparseagain("a circ b", "Concatenation");
 142 }
 143
 144 void Test::SimpleRelationalOp()
 145 {
 146     parseandparseagain("a = b", "Is equal");
 147     parseandparseagain("a <> b", "Is not equal");
 148     parseandparseagain("a approx 2", "Approximately");
 149     parseandparseagain("a divides b", "Divides");
 150     parseandparseagain("a ndivides b", "Does not divide");
 151     parseandparseagain("a < 2", "Less than");
 152     parseandparseagain("a > 2", "Greater than");
 153     parseandparseagain("a simeq b", "Similar to or equal");
 154     parseandparseagain("a parallel b", "Parallel");
 155     parseandparseagain("a ortho b", "Orthogonal to");
 156     parseandparseagain("a leslant b", "Less than or equal to");
 157     parseandparseagain("a geslant b", "Greater than or equal to");
 158     parseandparseagain("a sim b", "Similar to");
 159     parseandparseagain("a equiv b", "Congruent");
 160     parseandparseagain("a <= b", "Less than or equal to");
 161     parseandparseagain("a >= b", "Greater than or equal to");
 162     parseandparseagain("a prop b", "Proportional");
 163     parseandparseagain("a toward b", "Toward");
 164     parseandparseagain("a dlarrow b", "Arrow left");
 165     parseandparseagain("a dlrarrow b", "Double arrow left and right");
 166     parseandparseagain("drarrow b", "Arrow right");
 167 }
 168
 169 void Test::SimpleSetOp()
 170 {
 171     parseandparseagain("a in B", "Is in");
 172     parseandparseagain("a notin B", "Is not in");
 173     parseandparseagain("A owns b", "Owns");
 174     parseandparseagain("emptyset", "Empty set");
 175     parseandparseagain("A intersection B", "Intersection");
 176     parseandparseagain("A union B", "Union");
 177     parseandparseagain("A setminus B", "Difference");
 178     parseandparseagain("A slash B", "Quotient");
 179     parseandparseagain("aleph", "Aleph");
 180     parseandparseagain("A subset B", "Subset");
 181     parseandparseagain("A subseteq B", "Subset or equal to");
 182     parseandparseagain("A supset B", "Superset");
 183     parseandparseagain("A supseteq B", "Superset or equal to");
 184     parseandparseagain("A nsubset B", "Not subset");
 185     parseandparseagain("A nsubseteq B", "Not subset or equal");
 186     parseandparseagain("A nsupset B", "Not superset");
 187     parseandparseagain("A nsupseteq B", "Not superset or equal");
 188     parseandparseagain("setN", "Set of natural numbers");
 189     parseandparseagain("setZ", "Set of integers");
 190     parseandparseagain("setQ", "Set of rational numbers");
 191     parseandparseagain("setR", "Set of real numbers");
 192     parseandparseagain("setC", "Set of complex numbers");
 193 }
 194
 195 void Test::SimpleFunctions()
 196 {
 197     parseandparseagain("func e^{a}", "Exponential");
 198     parseandparseagain("ln(a)", "Natural logarithm");
 199     parseandparseagain("exp(a)", "Exponential function");
 200     parseandparseagain("log(a)", "Logarithm");
 201     parseandparseagain("a^{b}", "Power");
 202     parseandparseagain("sin(a)", "Sine");
 203     parseandparseagain("cos(a)", "Cosine");
 204     parseandparseagain("tan(a)", "Tangent");
 205     parseandparseagain("cot(a)", "Cotangent");
 206     parseandparseagain("sqrt{a}", "Square root");
 207     parseandparseagain("arcsin(a)", "Arcsine");
 208     parseandparseagain("arccos(a)", "Arccosine");
 209     parseandparseagain("arctan(a)", "Arctangent");
 210     parseandparseagain("arccot(a)", "Arc cotangent");
 211     parseandparseagain("nroot{a}{b}", "nth root");
 212     parseandparseagain("sinh(a)", "Hyperbolic sine");
 213     parseandparseagain("cosh(a)", "Hyperbolic cosine");
 214     parseandparseagain("tanh(a)", "Hyperbolic tangent");
 215     parseandparseagain("coth(a)", "Hyperbolic cotangent");
 216     parseandparseagain("abs{a}", "Absolute value");
 217     parseandparseagain("arsinh(a)", "Arc hyperbolic sine");
 218     parseandparseagain("arcosh(a)", "Arc hyperbolic cosine");
 219     parseandparseagain("artanh(a)", "Arc hyperbolic tangent");
 220     parseandparseagain("arcoth(a)", "Arc hyperbolic cotangent");
 221 }
 222
 223 void Test::SimpleOperators()
 224 {
 225     parseandparseagain("lim{a}", "Limit");
 226     parseandparseagain("sum{a}", "Sum");
 227     parseandparseagain("prod{a}", "Product");
 228     parseandparseagain("coprod{a}", "Coproduct");
 229     parseandparseagain("int from {r_0} to {r_t} a",
 230                        "Upper and lower bounds shown with integral (from & to)");
 231     ParseAndCheck("int csup {r_0} csub {r_t} a", "int csup { r _ 0 } csub { r _ t } a",
 232                   "Upper and lower bounds shown with integral (csub & csup)");
 233     ParseAndCheck("sum csup { size 8 { x - 1 } } csub { size 8 a } b",
 234                   "sum csup { size 8 { x - 1 } } csub { size 8 a } b",
 235                   "Sum with sized upper and lower bounds");
 236     parseandparseagain("int{a}", "Integral");
 237     parseandparseagain("intd_{1}^{2}{x dx}", "Dynamically-sized integral");
 238     parseandparseagain("iint{a}", "Double integral");
 239     parseandparseagain("iiint{a}", "Triple integral");
 240     parseandparseagain("sum from{3}b", "Lower bound shown with summation symbol");
 241     parseandparseagain("lint a", "Contour integral");
 242     parseandparseagain("llint a", "Double curved integral");
 243     parseandparseagain("lllint a", "Triple curved integral");
 244     parseandparseagain("prod from {i=1} to {n} {(i+1)}", "Product with range");
 245     ParseAndCheck("%Ux2135", "%Ux2135", "fdo#77831");
 246 }
 247
 248 void Test::SimpleAttributes()
 249 {
 250     parseandparseagain("acute a", "Acute accent");
 251     parseandparseagain("grave a", "Grave accent");
 252     parseandparseagain("check a", "Reverse circumflex");
 253     parseandparseagain("breve a", "Breve");
 254     parseandparseagain("circle a", "Circle");
 255     parseandparseagain("vec a", "Vector arrow");
 256     parseandparseagain("harpoon a", "Harpoon");
 257     parseandparseagain("tilde a", "Tilde");
 258     parseandparseagain("hat a", "Circumflex");
 259     parseandparseagain("bar a", "Line above");
 260     parseandparseagain("dot a", "Dot");
 261     parseandparseagain("widevec abc", "Wide vector arrow");
 262     parseandparseagain("wideharpoon abc", "Wide harpoon");
 263     parseandparseagain("widetilde abc", "Wide tilde");
 264     parseandparseagain("widehat abc", "Wide circumflex");
 265     parseandparseagain("ddot a", "Double dot");
 266     parseandparseagain("overline abc", "Line over");
 267     parseandparseagain("underline abc", "Line under");
 268     parseandparseagain("overstrike abc", "Line through");
 269     parseandparseagain("dddot a", "Triple dot");
 270     parseandparseagain("phantom a", "Transparent (useful to get a placeholder of a given size)");
 271     parseandparseagain("bold a", "Bold font");
 272     parseandparseagain("ital a", "Italic font");
 273     parseandparseagain("nitalic a", "Roman (non-italic) font 1");
 274     parseandparseagain("\"a\"", "Roman (non-italic) font 2");
 275     parseandparseagain("size 16 qv", "Resize font");
 276     parseandparseagain("font sans qv", "Sans serif font");
 277     parseandparseagain("font serif qv", "Serif font");
 278     parseandparseagain("font fixed qv", "Fixed font");
 279     parseandparseagain("color cyan qv", "Cyan color");
 280     parseandparseagain("color yellow qv", "Yellow color");
 281     parseandparseagain("color white qv", "White color");
 282     parseandparseagain("color green qv", "Green color");
 283     parseandparseagain("color blue qv", "Blue color");
 284     parseandparseagain("color red qv", "Red color");
 285     parseandparseagain("color green X qv", "Green color changes back");
 286     parseandparseagain("color green {X qv}", "Green color, more than one item");
 287 }
 288
 289 void Test::SimpleMisc()
 290 {
 291     parseandparseagain("infinity", "Infinity");
 292     parseandparseagain("partial", "Partial");
 293     parseandparseagain("nabla", "Nabla");
 294     parseandparseagain("exists", "There exists");
 295     parseandparseagain("notexists", "There not exists");
 296     parseandparseagain("forall", "For all");
 297     parseandparseagain("hbar", "H bar");
 298     parseandparseagain("lambdabar", "Lambda bar");
 299     parseandparseagain("re", "Real part");
 300     parseandparseagain("im", "Imaginary part");
 301     parseandparseagain("wp", "Weierstrass p");
 302     parseandparseagain("leftarrow", "Left arrow");
 303     parseandparseagain("rightarrow", "Right arrow");
 304     parseandparseagain("uparrow", "Up arrow");
 305     parseandparseagain("downarrow", "Down arrow");
 306     parseandparseagain("dotslow", "Dots at bottom");
 307     parseandparseagain("dotsaxis", "Dots at middle");
 308     parseandparseagain("dotsvert", "Dots vertical");
 309     parseandparseagain("dotsup", "Dots diagonal upward");
 310     parseandparseagain("dotsdown", "Dots diagonal downward");
 311 }
 312
 313 void Test::SimpleBrackets()
 314 {
 315     parseandparseagain("(a)", "Round Brackets");
 316     parseandparseagain("[b]", "Square Brackets");
 317     parseandparseagain("ldbracket c rdbracket", "Double Square Brackets");
 318     parseandparseagain("lline a rline", "Single line or absolute");
 319     parseandparseagain("abs a", "Single line or absolute 2");
 320     parseandparseagain("ldline a rdline", "Double line");
 321     parseandparseagain("lbrace w rbrace", "Braces");
 322     parseandparseagain("left lbrace stack{0, n <> 0 # 1, n = 1} right none", "Single left brace");
 323     parseandparseagain("langle d rangle", "Angle Brackets");
 324     parseandparseagain("langle a mline b rangle", "Operator Brackets");
 325     parseandparseagain("{a}", "Group brackets (used for program control)");
 326     parseandparseagain("left ( stack{a # b # z} right )", "Round brackets scalable");
 327     parseandparseagain("left [ stack{x # y} right ]", "Square brackets scalable");
 328     parseandparseagain("left ldbracket c right rdbracket", "Double square brackets scalable");
 329     parseandparseagain("left lline a right rline", "Line scalable");
 330     parseandparseagain("left ldline d right rdline", "Double line scalable");
 331     parseandparseagain("left lbrace e right rbrace", "Brace scalable");
 332     parseandparseagain("left langle f right rangle", "Angle bracket scalable");
 333     parseandparseagain("left langle g mline h right rangle", "Operator brackets scalable");
 334     parseandparseagain("{a} overbrace b", "Over brace scalable");
 335     parseandparseagain("{b} underbrace a", "Under brace scalable");
 336 }
 337
 338 void Test::SimpleFormats()
 339 {
 340     parseandparseagain("a lsup{b}", "Left superscript");
 341     parseandparseagain("a csup{b}", "Center superscript");
 342     parseandparseagain("a^{b}", "Right superscript");
 343     parseandparseagain("a lsub{b}", "Left subscript");
 344     parseandparseagain("a csub{b}", "Center subscript");
 345     parseandparseagain("a_{b}", "Right subscript");
 346     parseandparseagain("stack { Hello world # alignl (a) }", "Align character to left");
 347     parseandparseagain("stack{Hello world # alignc(a)}", "Align character to center");
 348     parseandparseagain("stack { Hello world # alignr(a)}", "Align character to right");
 349     parseandparseagain("binom{a}{b}", "Vertical stack of 2");
 350     parseandparseagain("stack{a # b # z}", "Vertical stack, more than 2");
 351     parseandparseagain("matrix{a # b ## c # d}", "Matrix");
 352     parseandparseagain("matrix{a # \"=\" # alignl{b} ## {} # \"=\" # alignl{c+1}}",
 353                        "Equations aligned at '=' (using 'matrix') ");
 354     parseandparseagain("stack{alignl{a} = b # alignl{phantom{a} = c+1}}",
 355                        "Equations aligned at '=' (using 'phantom') ");
 356     parseandparseagain("asldkfjo newline sadkfj", "New line");
 357     parseandparseagain("stuff `stuff", "Small gap (grave)");
 358     parseandparseagain("stuff~stuff", "Large gap (tilde)");
 359 }
 360
 361 void Test::SimpleGreekChars()
 362 {
 363     parseandparseagain("%ALPHA", "Capital alpha");
 364     parseandparseagain("%BETA", "Capital beta");
 365     parseandparseagain("%CHI", "Capital chi");
 366     parseandparseagain("%DELTA", "Capital delta");
 367     parseandparseagain("%EPSILON", "Capital epsilon");
 368     parseandparseagain("%ETA", "Capital eta");
 369     parseandparseagain("%GAMMA", "Capital gamma");
 370     parseandparseagain("%IOTA", "Capital iota");
 371     parseandparseagain("%LAMBDA", "Capital lambda");
 372     parseandparseagain("%MU", "Capital mu");
 373     parseandparseagain("%NU", "Capital nu");
 374     parseandparseagain("%OMEGA", "Capital omega");
 375     parseandparseagain("%OMICRON", "Capital omicron");
 376     parseandparseagain("%PHI", "Capital phi");
 377     parseandparseagain("%PI", "Capital pi");
 378     parseandparseagain("%PSI", "Capital psi");
 379     parseandparseagain("%RHO", "Capital rho");
 380     parseandparseagain("%SIGMA", "Capital sigma");
 381     parseandparseagain("%TAU", "Capital tau");
 382     parseandparseagain("%THETA", "Capital theta");
 383     parseandparseagain("%UPSILON", "Capital upsilon");
 384     parseandparseagain("%XI", "Capital xi");
 385     parseandparseagain("%ZETA", "Capital zeta");
 386     parseandparseagain("%alpha", "lowercase alpha");
 387     parseandparseagain("%beta", "lowercase beta");
 388     parseandparseagain("%chi", "lowercase chi");
 389     parseandparseagain("%delta", "lowercase delta");
 390     parseandparseagain("%epsilon", "lowercase epsilon");
 391     parseandparseagain("%eta", "lowercase eta");
 392     parseandparseagain("%gamma", "lowercase gamma");
 393     parseandparseagain("%iota", "lowercase iota");
 394     parseandparseagain("%kappa", "lowercase kappa");
 395     parseandparseagain("%lambda", "lowercase lambda");
 396     parseandparseagain("%mu", "lowercase mu");
 397     parseandparseagain("%nu", "lowercase nu");
 398     parseandparseagain("%omega", "lowercase omega");
 399     parseandparseagain("%omicron", "lowercase omicron");
 400     parseandparseagain("%phi", "lowercase phi");
 401     parseandparseagain("%pi", "lowercase pi");
 402     parseandparseagain("%psi", "lowercase psi");
 403     parseandparseagain("%rho", "lowercase rho");
 404     parseandparseagain("%sigma", "lowercase sigma");
 405     parseandparseagain("%tau", "lowercase tau");
 406     parseandparseagain("%theta", "lowercase theta");
 407     parseandparseagain("%upsilon", "lowercase upsilon");
 408     parseandparseagain("%varepsilon", "Varepsilon");
 409     parseandparseagain("%varphi", "Varphi");
 410     parseandparseagain("%varpi", "Varpi");
 411     parseandparseagain("%varrho", "Varrho");
 412     parseandparseagain("%varsigma", "Varsigma");
 413     parseandparseagain("%vartheta", "Vartheta");
 414     parseandparseagain("%xi", "lowercase xi");
 415     parseandparseagain("%zeta", "lowercase zeta");
 416 }
 417
 418 void Test::SimpleSpecialChars()
 419 {
 420     parseandparseagain("%and", "And");
 421     parseandparseagain("%angle", "Angle");
 422     parseandparseagain("%element", "Element");
 423     parseandparseagain("%identical", "Identical");
 424     parseandparseagain("%infinite", "Infinite");
 425     parseandparseagain("%noelement", "No element");
 426     parseandparseagain("%notequal", "Not equal");
 427     parseandparseagain("%or", "Or");
 428     parseandparseagain("%perthousand", "Per thousand");
 429     parseandparseagain("%strictlygreaterthan", "Strictly greater than");
 430     parseandparseagain("%strictlylessthan", "Strictly less than");
 431     parseandparseagain("%tendto", "Tend to");
 432 }
 433
 434 /* This test takes a formula command, parses it, converts the node to text,
 435  * parses it again, converts it to text again, and compares the values.
 436  * Doing this doesn't prove that it is correct, but it should prove that the
 437  * meaning of the original command is not being changed.
 438  */
 439 void Test::parseandparseagain(const char* formula, const char* test_name)
 440 {
 441     OUString output1, output2;
 442
 443     // parse 1
 444     OUString input = OUString::createFromAscii(formula);
 445     auto pNode1 = SmParser().ParseExpression(input);
 446     pNode1->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 447     SmNodeToTextVisitor(pNode1.get(), output1);
 448
 449     // parse 2
 450     auto pNode2 = SmParser().ParseExpression(output1);
 451     pNode2->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 452     SmNodeToTextVisitor(pNode2.get(), output2);
 453
 454     // compare
 455     CPPUNIT_ASSERT_EQUAL_MESSAGE(test_name, output1, output2);
 456
 457     // auxiliary test for Accept()
 458     std::unique_ptr<MockVisitor> mv(new MockVisitor);
 459     pNode1->Accept(mv.get());
 460     pNode2->Accept(mv.get());
 461 }
 462
 463 void Test::ParseAndCheck(const char* formula, const char* expected, const char* test_name)
 464 {
 465     OUString sOutput;
 466
 467     // parse
 468     OUString sInput = OUString::createFromAscii(formula);
 469     auto pNode = SmParser().ParseExpression(sInput);
 470     pNode->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 471     SmNodeToTextVisitor(pNode.get(), sOutput);
 472
 473     // compare
 474     OUString sExpected = OUString::createFromAscii(expected);
 475     CPPUNIT_ASSERT_EQUAL_MESSAGE(test_name, sExpected, sOutput);
 476
 477     // auxiliary test for Accept()
 478     std::unique_ptr<MockVisitor> mv(new MockVisitor);
 479     pNode->Accept(mv.get());
 480 }
 481
 482 // Parse two formula commands and verify that they give the same output
 483 void Test::ParseAndCompare(const char* formula1, const char* formula2, const char* test_name)
 484 {
 485     OUString sOutput1, sOutput2;
 486
 487     // parse formula1
 488     OUString sInput1(formula1, strlen(formula1), RTL_TEXTENCODING_UTF8);
 489     auto pNode1 = SmParser().ParseExpression(sInput1);
 490     pNode1->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 491     SmNodeToTextVisitor(pNode1.get(), sOutput1);
 492
 493     // parse formula2
 494     OUString sInput2(formula2, strlen(formula2), RTL_TEXTENCODING_UTF8);
 495     auto pNode2 = SmParser().ParseExpression(sInput2);
 496     pNode2->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 497     SmNodeToTextVisitor(pNode2.get(), sOutput2);
 498
 499     CPPUNIT_ASSERT_EQUAL_MESSAGE(test_name, sOutput1, sOutput2);
 500
 501     // auxiliary test for Accept()
 502     std::unique_ptr<MockVisitor> mv(new MockVisitor);
 503     pNode1->Accept(mv.get());
 504     pNode2->Accept(mv.get());
 505 }
 506
 507 void Test::testBinomInBinHor()
 508 {
 509     OUString sInput, sExpected;
 510
 511     // set up a binom (table) node
 512     sInput += "binom a b + c";
 513     auto pTree = SmParser().Parse(sInput);
 514     pTree->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 515
 516     SmCursor aCursor(pTree.get(), xDocShRef.get());
 517     ScopedVclPtrInstance<VirtualDevice> pOutputDevice;
 518
 519     // move forward (more than) enough places to be at the end
 520     int i;
 521     for (i = 0; i < 8; ++i)
 522         aCursor.Move(pOutputDevice, MoveRight);
 523
 524     // tack +d on the end, which will put the binom into an SmBinHorNode
 525     aCursor.InsertElement(PlusElement);
 526     aCursor.InsertText("d");
 527
 528     sExpected += "{ { binom a b + c } + d }";
 529     CPPUNIT_ASSERT_EQUAL_MESSAGE("Binom Node in BinHor Node", sExpected, xDocShRef->GetText());
 530 }
 531
 532 void Test::testBinVerInUnary()
 533 {
 534     OUString sInput, sExpected;
 535
 536     // set up a unary operator with operand
 537     sInput += "- 1";
 538     auto pTree = SmParser().Parse(sInput);
 539     pTree->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 540
 541     SmCursor aCursor(pTree.get(), xDocShRef.get());
 542     ScopedVclPtrInstance<VirtualDevice> pOutputDevice;
 543
 544     // move forward (more than) enough places to be at the end
 545     int i;
 546     for (i = 0; i < 3; ++i)
 547         aCursor.Move(pOutputDevice, MoveRight);
 548
 549     // select the operand
 550     aCursor.Move(pOutputDevice, MoveLeft, false);
 551     // set up a fraction
 552     aCursor.InsertFraction();
 553     aCursor.Move(pOutputDevice, MoveDown);
 554     aCursor.InsertText("2");
 555
 556     sExpected += "- { 1 over 2 }";
 557     CPPUNIT_ASSERT_EQUAL_MESSAGE("Binary Vertical in Unary Operator", sExpected,
 558                                  xDocShRef->GetText());
 559 }
 560
 561 void Test::testBinHorInSubSup()
 562 {
 563     // set up a blank formula
 564     auto pTree = SmParser().Parse(OUString());
 565     pTree->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 566
 567     SmCursor aCursor(pTree.get(), xDocShRef.get());
 568     ScopedVclPtrInstance<VirtualDevice> pOutputDevice;
 569
 570     // Insert an RSup expression with a BinHor for the exponent
 571     aCursor.InsertText("a");
 572     aCursor.InsertSubSup(RSUP);
 573     aCursor.InsertText("b");
 574     aCursor.InsertElement(PlusElement);
 575     aCursor.InsertText("c");
 576
 577     // Move to the end and add d to the expression
 578     aCursor.Move(pOutputDevice, MoveRight);
 579     aCursor.InsertElement(PlusElement);
 580     aCursor.InsertText("d");
 581
 582     CPPUNIT_ASSERT_EQUAL_MESSAGE("BinHor in SubSup", OUString("{ a ^ { b + c } + d }"),
 583                                  xDocShRef->GetText());
 584 }
 585
 586 void Test::testUnaryInMixedNumberAsNumerator()
 587 {
 588     // set up a unary operator
 589     auto pTree = SmParser().Parse("- 1");
 590     pTree->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 591
 592     SmCursor aCursor(pTree.get(), xDocShRef.get());
 593     ScopedVclPtrInstance<VirtualDevice> pOutputDevice;
 594
 595     // move forward (more than) enough places to be at the end
 596     for (size_t i = 0; i < 3; ++i)
 597         aCursor.Move(pOutputDevice, MoveRight);
 598
 599     // Select the whole Unary Horizontal Node
 600     aCursor.Move(pOutputDevice, MoveLeft, false);
 601     aCursor.Move(pOutputDevice, MoveLeft, false);
 602
 603     // Set up a fraction
 604     aCursor.InsertFraction();
 605     aCursor.Move(pOutputDevice, MoveDown);
 606     aCursor.InsertText("2");
 607
 608     // Move left and turn this into a mixed number
 609     // (bad form, but this could happen right?)
 610     aCursor.Move(pOutputDevice, MoveLeft);
 611     aCursor.Move(pOutputDevice, MoveLeft);
 612     aCursor.InsertText("2");
 613
 614     // move forward (more than) enough places to be at the end
 615     for (size_t i = 0; i < 8; ++i)
 616         aCursor.Move(pOutputDevice, MoveRight);
 617
 618     // add 4 to the end
 619     aCursor.InsertElement(PlusElement);
 620     aCursor.InsertText("4");
 621
 622     CPPUNIT_ASSERT_EQUAL_MESSAGE("Unary in mixed number as Numerator",
 623                                  OUString("{ 2 { - 1 over 2 } + 4 }"), xDocShRef->GetText());
 624 }
 625
 626 void Test::testMiscEquivalent()
 627 {
 628     // fdo#55853
 629     ParseAndCompare("2x", "2 x", "Number times variable");
 630     ParseAndCompare("3x^2", "3 x^2", "Number times power");
 631
 632     // i#11752 and fdo#55853
 633     ParseAndCompare("x_2n", "x_{2 n}", "Number times variable in subscript");
 634     ParseAndCompare("x^2n", "x^{2 n}", "Number times variable in supscript");
 635
 636     // fdo#66081
 637     ParseAndCompare("{x}", "x", "Variable in brace");
 638     ParseAndCompare("{{x+{{y}}}}", "x+y", "Nested braces");
 639
 640     // check non-BMP Unicode char
 641     ParseAndCompare("{\xf0\x9d\x91\x8e}", "\xf0\x9d\x91\x8e", "non-BMP variable in brace");
 642     ParseAndCompare("{ \xf0\x9d\x91\x8e }", "\xf0\x9d\x91\x8e", "non-BMP variable in brace");
 643
 644     // tdf#88320
 645     ParseAndCompare("A_1,B_2", "A_{1},B_2",
 646                     "Comma between a digit and non-digit delimits subscript");
 647
 648     //tdf#97164
 649     ParseAndCompare("100 %", "100\"%\"", "Percent symbol at the end");
 650 }
 651
 652 void Test::testParser()
 653 {
 654     OUString sOutput;
 655     auto pNode = SmParser().ParseExpression(u"{ \U0001D44E }"); // non-BMP Unicode
 656     pNode->Prepare(xDocShRef->GetFormat(), *xDocShRef, 0);
 657     SmNodeToTextVisitor(pNode.get(), sOutput);
 658     CPPUNIT_ASSERT_EQUAL(OUString(u"\U0001D44E"), sOutput);
 659 }
 660
 661 CPPUNIT_TEST_SUITE_REGISTRATION(Test);
 662 }
 663
 664 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */