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