spec/regressions_spec.rb

   1 #!/usr/bin/env ruby
   2 # encoding: utf-8
   3 # Copyright 2008-2009 Wincent Colaiuta. All rights reserved.
   4 #
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions are met:
   7 #
   8 # 1. Redistributions of source code must retain the above copyright notice,
   9 #    this list of conditions and the following disclaimer.
  10 # 2. Redistributions in binary form must reproduce the above copyright notice,
  11 #    this list of conditions and the following disclaimer in the documentation
  12 #    and/or other materials provided with the distribution.
  13
  14 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  18 # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20 # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22 # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24 # POSSIBILITY OF SUCH DAMAGE.
  25
  26 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
  27 require 'wikitext'
  28
  29 # this is a general-purpose file in which I'll add specs for former bugs to make sure that they don't regress
  30 describe Wikitext::Parser, 'regressions' do
  31   before do
  32     @parser = Wikitext::Parser.new
  33   end
  34
  35   # turns out that this was never a bug in wikitext -- it was a bug in the host application -- but keeping the test does no harm
  36   it 'should correctly transform example #1' do
  37     input = dedent <<-END
  38       = Leopard =
  39
  40       * punto 1
  41       * punto 2
  42
  43       Y [[otro articulo]].
  44     END
  45     expected = dedent <<-END
  46       <h1>Leopard</h1>
  47       <ul>
  48         <li>punto 1</li>
  49         <li>punto 2</li>
  50       </ul>
  51       <p>Y <a href="/wiki/otro_articulo">otro articulo</a>.</p>
  52     END
  53     @parser.parse(input).should == expected
  54   end
  55
  56   # discovered at: http://rails.wincent.com/wiki/nginx_log_rotation
  57   # fixed by 0a328f1
  58   it 'should allow empty lines in PRE blocks marked up with a leading space' do
  59     input = dedent <<-END
  60        # -d turns on debug mode: output is verbose, no actual changes are made to the log files
  61        sudo logrotate -d /etc/logrotate.d/nginx
  62
  63        # if the debug output looks good, proceed with a real rotation (-v turns on verbose output)
  64        sudo logrotate -v /etc/logrotate.d/nginx
  65     END
  66     expected = dedent <<-END
  67       <pre># -d turns on debug mode: output is verbose, no actual changes are made to the log files
  68       sudo logrotate -d /etc/logrotate.d/nginx
  69
  70       # if the debug output looks good, proceed with a real rotation (-v turns on verbose output)
  71       sudo logrotate -v /etc/logrotate.d/nginx</pre>
  72     END
  73     @parser.parse(input).should == expected
  74   end
  75
  76   # discovered at: http://rails.wincent.com/wiki/Installing_Ragel_5.2.0_on_Mac_OS_X_Tiger
  77   # fixed by a616841
  78   it 'should handle PRE_START blocks which follow unordered lists' do
  79     input = dedent <<-END
  80       * Get link to latest source code from: http://www.cs.queensu.ca/~thurston/ragel/
  81
  82       <pre>wget http://www.cs.queensu.ca/~thurston/ragel/ragel-5.20.tar.gz
  83       tar xzvf ragel-5.20.tar.gz
  84       cd ragel-5.20</pre>
  85     END
  86     expected = dedent <<-END
  87       <ul>
  88         <li>Get link to latest source code from: <a href="http://www.cs.queensu.ca/~thurston/ragel/" class="external">http://www.cs.queensu.ca/~thurston/ragel/</a></li>
  89       </ul>
  90       <pre>wget <a href="http://www.cs.queensu.ca/~thurston/ragel/ragel-5.20.tar.gz" class="external">http://www.cs.queensu.ca/~thurston/ragel/ragel-5.20.tar.gz</a>
  91       tar xzvf ragel-5.20.tar.gz
  92       cd ragel-5.20</pre>
  93     END
  94     @parser.parse(input).should == expected
  95   end
  96
  97   # discovered at: http://rails.wincent.com/wiki/Movable_Type_security_notes
  98   # fixed by a616841
  99   it 'should handle PRE_START blocks which follow ordered lists' do
 100     input = dedent <<-END
 101       # Turn off the [[Movable Type]] search function; use Google instead (it's better anyway) with a form something like this:
 102
 103       <pre><form method="get"...></pre>
 104     END
 105     expected = dedent <<-END
 106       <ol>
 107         <li>Turn off the <a href="/wiki/Movable_Type">Movable Type</a> search function; use Google instead (it's better anyway) with a form something like this:</li>
 108       </ol>
 109       <pre>&lt;form method=&quot;get&quot;...&gt;</pre>
 110     END
 111     @parser.parse(input).should == expected
 112   end
 113
 114   # discovered at: http://rails.wincent.com/wiki/Movable_Type_security_notes
 115   # fixed by 191b75d
 116   it 'should respect additional indentation found inside PRE blocks' do
 117     # note the two extra spaces on each line
 118     input = dedent <<-END
 119          <input type="text" name="q" size="20" maxlength="255" value="" />
 120          <input type="hidden" name="hl" value="en" />
 121     END
 122
 123     # problem is the spaces were being emitted _before_ the CRLF
 124     expected = dedent <<-END
 125       <pre>  &lt;input type=&quot;text&quot; name=&quot;q&quot; size=&quot;20&quot; maxlength=&quot;255&quot; value=&quot;&quot; /&gt;
 126         &lt;input type=&quot;hidden&quot; name=&quot;hl&quot; value=&quot;en&quot; /&gt;</pre>
 127     END
 128     @parser.parse(input).should == expected
 129   end
 130
 131   # this is the general case of the bug covered in the previous spec
 132   # any token that appears as the first token after a PRE token can manifest this bug
 133   # PRINTABLE didn't only because it called _Wikitext_start_para_if_necessary(), which handled the pending CRLF
 134   it 'should emit pending newlines for all token types found inside PRE and PRE_START blocks' do
 135     # PRE_START
 136     input = dedent <<-END
 137        foo
 138        <pre>bar
 139     END
 140     expected = dedent <<-END
 141       <pre>foo
 142       &lt;pre&gt;bar</pre>
 143     END
 144     @parser.parse(input).should == expected
 145
 146     # PRE_END
 147     input = dedent <<-END
 148        foo
 149        </pre>bar
 150     END
 151     expected = dedent <<-END
 152       <pre>foo
 153       &lt;/pre&gt;bar</pre>
 154     END
 155     @parser.parse(input).should == expected
 156
 157     # BLOCKQUOTE_START
 158     input = dedent <<-END
 159        foo
 160        <blockquote>bar
 161     END
 162     expected = dedent <<-END
 163       <pre>foo
 164       &lt;blockquote&gt;bar</pre>
 165     END
 166     @parser.parse(input).should == expected
 167
 168     # BLOCKQUOTE_END
 169     input = dedent <<-END
 170        foo
 171        </blockquote>bar
 172     END
 173     expected = dedent <<-END
 174       <pre>foo
 175       &lt;/blockquote&gt;bar</pre>
 176     END
 177     @parser.parse(input).should == expected
 178
 179     # NO_WIKI_START
 180     input = dedent <<-END
 181        foo
 182        <nowiki>bar
 183     END
 184     expected = dedent <<-END
 185       <pre>foo
 186       &lt;nowiki&gt;bar</pre>
 187     END
 188     @parser.parse(input).should == expected
 189
 190     # STRONG_EM
 191     input = dedent <<-END
 192        foo
 193        '''''bar
 194     END
 195     expected = dedent <<-END
 196       <pre>foo
 197       '''''bar</pre>
 198     END
 199     @parser.parse(input).should == expected
 200
 201     # STRONG
 202     input = dedent <<-END
 203        foo
 204        '''bar
 205     END
 206     expected = dedent <<-END
 207       <pre>foo
 208       '''bar</pre>
 209     END
 210     @parser.parse(input).should == expected
 211
 212     # STRONG_START
 213     input = dedent <<-END
 214        foo
 215        <strong>bar
 216     END
 217     expected = dedent <<-END
 218       <pre>foo
 219       &lt;strong&gt;bar</pre>
 220     END
 221     @parser.parse(input).should == expected
 222
 223     # STRONG_END
 224     input = dedent <<-END
 225        foo
 226        </strong>bar
 227     END
 228     expected = dedent <<-END
 229       <pre>foo
 230       &lt;/strong&gt;bar</pre>
 231     END
 232     @parser.parse(input).should == expected
 233
 234     # EM
 235     input = dedent <<-END
 236        foo
 237        ''bar
 238     END
 239     expected = dedent <<-END
 240       <pre>foo
 241       ''bar</pre>
 242     END
 243     @parser.parse(input).should == expected
 244
 245     # EM_START
 246     input = dedent <<-END
 247        foo
 248        <em>bar
 249     END
 250     expected = dedent <<-END
 251       <pre>foo
 252       &lt;em&gt;bar</pre>
 253     END
 254     @parser.parse(input).should == expected
 255
 256     # EM_END
 257     input = dedent <<-END
 258        foo
 259        </em>bar
 260     END
 261     expected = dedent <<-END
 262       <pre>foo
 263       &lt;/em&gt;bar</pre>
 264     END
 265     @parser.parse(input).should == expected
 266
 267     # TT
 268     input = dedent <<-END
 269        foo
 270        `bar
 271     END
 272     expected = dedent <<-END
 273       <pre>foo
 274       `bar</pre>
 275     END
 276     @parser.parse(input).should == expected
 277
 278     # TT_START
 279     input = dedent <<-END
 280        foo
 281        <tt>bar
 282     END
 283     expected = dedent <<-END
 284       <pre>foo
 285       &lt;tt&gt;bar</pre>
 286     END
 287     @parser.parse(input).should == expected
 288
 289     # TT_END
 290     input = dedent <<-END
 291        foo
 292        </tt>bar
 293     END
 294     expected = dedent <<-END
 295       <pre>foo
 296       &lt;/tt&gt;bar</pre>
 297     END
 298     @parser.parse(input).should == expected
 299
 300     # H6_END
 301     input = dedent <<-END
 302        foo
 303        ======
 304        bar
 305     END
 306     expected = dedent <<-END
 307       <pre>foo
 308       ======
 309       bar</pre>
 310     END
 311     @parser.parse(input).should == expected
 312
 313     # H5_END
 314     input = dedent <<-END
 315        foo
 316        =====
 317        bar
 318     END
 319     expected = dedent <<-END
 320       <pre>foo
 321       =====
 322       bar</pre>
 323     END
 324     @parser.parse(input).should == expected
 325
 326     # H4_END
 327     input = dedent <<-END
 328        foo
 329        ====
 330        bar
 331     END
 332     expected = dedent <<-END
 333       <pre>foo
 334       ====
 335       bar</pre>
 336     END
 337     @parser.parse(input).should == expected
 338
 339     # H3_END
 340     input = dedent <<-END
 341        foo
 342        ===
 343        bar
 344     END
 345     expected = dedent <<-END
 346       <pre>foo
 347       ===
 348       bar</pre>
 349     END
 350     @parser.parse(input).should == expected
 351
 352     # H2_END
 353     input = dedent <<-END
 354        foo
 355        ==
 356        bar
 357     END
 358     expected = dedent <<-END
 359       <pre>foo
 360       ==
 361       bar</pre>
 362     END
 363     @parser.parse(input).should == expected
 364
 365     # H1_END
 366     input = dedent <<-END
 367        foo
 368        =
 369        bar
 370     END
 371     expected = dedent <<-END
 372       <pre>foo
 373       =
 374       bar</pre>
 375     END
 376     @parser.parse(input).should == expected
 377
 378     # MAIL
 379     input = dedent <<-END
 380        foo
 381        bar@baz.com
 382     END
 383     expected = dedent <<-END
 384       <pre>foo
 385       bar@baz.com</pre>
 386     END
 387     @parser.parse(input).should == expected
 388
 389     # LINK_START
 390     input = dedent <<-END
 391        foo
 392        [[bar
 393     END
 394     expected = dedent <<-END
 395       <pre>foo
 396       [[bar</pre>
 397     END
 398     @parser.parse(input).should == expected
 399
 400     # LINK_END
 401     input = dedent <<-END
 402        foo
 403        ]]bar
 404     END
 405     expected = dedent <<-END
 406       <pre>foo
 407       ]]bar</pre>
 408     END
 409     @parser.parse(input).should == expected
 410
 411     # EXT_LINK_START
 412     input = dedent <<-END
 413        foo
 414        [bar
 415     END
 416     expected = dedent <<-END
 417       <pre>foo
 418       [bar</pre>
 419     END
 420     @parser.parse(input).should == expected
 421
 422     # EXT_LINK_END
 423     input = dedent <<-END
 424        foo
 425        ]bar
 426     END
 427     expected = dedent <<-END
 428       <pre>foo
 429       ]bar</pre>
 430     END
 431     @parser.parse(input).should == expected
 432
 433     # IMG_START
 434     input = dedent <<-END
 435        foo
 436        {{bar
 437     END
 438     expected = dedent <<-END
 439       <pre>foo
 440       {{bar</pre>
 441     END
 442     @parser.parse(input).should == expected
 443
 444     # these tokens weren't affected by the bug, seeing as they either call _Wikitext_start_para_if_necessary()
 445     # or they can only appear in PRE_START (not PRE) thanks to the tokenizer
 446     # but we add specs for them to make sure that the issue never crops up for them in the future
 447
 448     # PRE (in PRE_START)
 449     input = dedent <<-END
 450       <pre>foo
 451        bar</pre>
 452     END
 453     expected = dedent <<-END
 454       <pre>foo
 455        bar</pre>
 456     END
 457     @parser.parse(input).should == expected
 458
 459     # BLOCKQUOTE (in PRE_START)
 460     input = dedent <<-END
 461       <pre>foo
 462       > bar</pre>
 463     END
 464     expected = dedent <<-END
 465       <pre>foo
 466       &gt; bar</pre>
 467     END
 468     @parser.parse(input).should == expected
 469
 470     # OL (in PRE_START)
 471     input = dedent <<-END
 472       <pre># foo
 473       # bar</pre>
 474     END
 475     expected = dedent <<-END
 476       <pre># foo
 477       # bar</pre>
 478     END
 479     @parser.parse(input).should == expected
 480
 481     # UL (in PRE_START)
 482     input = dedent <<-END
 483       <pre>* foo
 484       * bar</pre>
 485     END
 486     expected = dedent <<-END
 487       <pre>* foo
 488       * bar</pre>
 489     END
 490     @parser.parse(input).should == expected
 491
 492     # H6_START (in PRE_START)
 493     input = dedent <<-END
 494       <pre>foo
 495       ====== bar
 496       baz</pre>
 497     END
 498     expected = dedent <<-END
 499       <pre>foo
 500       ====== bar
 501       baz</pre>
 502     END
 503     @parser.parse(input).should == expected
 504
 505     # H5_START (in PRE_START)
 506     input = dedent <<-END
 507       <pre>foo
 508       ===== bar
 509       baz</pre>
 510     END
 511     expected = dedent <<-END
 512       <pre>foo
 513       ===== bar
 514       baz</pre>
 515     END
 516     @parser.parse(input).should == expected
 517
 518     # H4_START (in PRE_START)
 519     input = dedent <<-END
 520       <pre>foo
 521       ==== bar
 522       baz</pre>
 523     END
 524     expected = dedent <<-END
 525       <pre>foo
 526       ==== bar
 527       baz</pre>
 528     END
 529     @parser.parse(input).should == expected
 530
 531     # H3_START (in PRE_START)
 532     input = dedent <<-END
 533       <pre>foo
 534       === bar
 535       baz</pre>
 536     END
 537     expected = dedent <<-END
 538       <pre>foo
 539       === bar
 540       baz</pre>
 541     END
 542     @parser.parse(input).should == expected
 543
 544     # H2_START (in PRE_START)
 545     input = dedent <<-END
 546       <pre>foo
 547       == bar
 548       baz</pre>
 549     END
 550     expected = dedent <<-END
 551       <pre>foo
 552       == bar
 553       baz</pre>
 554     END
 555     @parser.parse(input).should == expected
 556
 557     # H1_START (in PRE_START)
 558     input = dedent <<-END
 559       <pre>foo
 560       = bar
 561       baz</pre>
 562     END
 563     expected = dedent <<-END
 564       <pre>foo
 565       = bar
 566       baz</pre>
 567     END
 568     @parser.parse(input).should == expected
 569
 570     # NO_WIKI_END
 571     input = dedent <<-END
 572        foo
 573        </nowiki>bar
 574     END
 575     expected = dedent <<-END
 576       <pre>foo
 577       &lt;/nowiki&gt;bar</pre>
 578     END
 579     @parser.parse(input).should == expected
 580
 581     # SEPARATOR
 582     input = dedent <<-END
 583        foo
 584        |bar
 585     END
 586     expected = dedent <<-END
 587       <pre>foo
 588       |bar</pre>
 589     END
 590     @parser.parse(input).should == expected
 591
 592     # QUOT_ENTITY
 593     input = dedent <<-END
 594        foo
 595        &quot;bar
 596     END
 597     expected = dedent <<-END
 598       <pre>foo
 599       &quot;bar</pre>
 600     END
 601     @parser.parse(input).should == expected
 602
 603     # AMP_ENTITY
 604     input = dedent <<-END
 605        foo
 606        &amp;bar
 607     END
 608     expected = dedent <<-END
 609       <pre>foo
 610       &amp;bar</pre>
 611     END
 612     @parser.parse(input).should == expected
 613
 614     # NAMED_ENTITY
 615     input = dedent <<-END
 616        foo
 617        &raquo;bar
 618     END
 619     expected = dedent <<-END
 620       <pre>foo
 621       &raquo;bar</pre>
 622     END
 623     @parser.parse(input).should == expected
 624
 625     # DECIMAL_ENTITY
 626     input = dedent <<-END
 627        foo
 628        &#1234;bar
 629     END
 630     expected = dedent <<-END
 631       <pre>foo
 632       &#1234;bar</pre>
 633     END
 634     @parser.parse(input).should == expected
 635
 636     # HEX_ENTITY
 637     input = dedent <<-END
 638        foo
 639        &#x2022;bar
 640     END
 641     expected = dedent <<-END
 642       <pre>foo
 643       &#x2022;bar</pre>
 644     END
 645     @parser.parse(input).should == expected
 646
 647     # QUOT
 648     input = dedent <<-END
 649        foo
 650        "bar
 651     END
 652     expected = dedent <<-END
 653       <pre>foo
 654       &quot;bar</pre>
 655     END
 656     @parser.parse(input).should == expected
 657
 658     # AMP
 659     input = dedent <<-END
 660        foo
 661        &bar
 662     END
 663     expected = dedent <<-END
 664       <pre>foo
 665       &amp;bar</pre>
 666     END
 667     @parser.parse(input).should == expected
 668
 669     # LESS
 670     input = dedent <<-END
 671        foo
 672        <bar
 673     END
 674     expected = dedent <<-END
 675       <pre>foo
 676       &lt;bar</pre>
 677     END
 678     @parser.parse(input).should == expected
 679
 680     # GREATER
 681     input = dedent <<-END
 682        foo
 683        >bar
 684     END
 685     expected = dedent <<-END
 686       <pre>foo
 687       &gt;bar</pre>
 688     END
 689     @parser.parse(input).should == expected
 690
 691     # URI
 692     input = dedent <<-END
 693        foo
 694        http://example.com/
 695     END
 696     expected = dedent <<-END
 697       <pre>foo
 698       <a href="http://example.com/" class="external">http://example.com/</a></pre>
 699     END
 700     @parser.parse(input).should == expected
 701
 702     # PRINTABLE
 703     input = dedent <<-END
 704        foo
 705        bar
 706     END
 707     expected = dedent <<-END
 708       <pre>foo
 709       bar</pre>
 710     END
 711     @parser.parse(input).should == expected
 712
 713     # IMG_END
 714     input = dedent <<-END
 715        foo
 716        }}bar
 717     END
 718     expected = dedent <<-END
 719       <pre>foo
 720       }}bar</pre>
 721     END
 722     @parser.parse(input).should == expected
 723
 724     # LEFT_CURLY
 725     input = dedent <<-END
 726        foo
 727        {bar
 728     END
 729     expected = dedent <<-END
 730       <pre>foo
 731       {bar</pre>
 732     END
 733     @parser.parse(input).should == expected
 734
 735     # RIGHT_CURLY
 736     input = dedent <<-END
 737        foo
 738        }bar
 739     END
 740     expected = dedent <<-END
 741       <pre>foo
 742       }bar</pre>
 743     END
 744     @parser.parse(input).should == expected
 745
 746     # DEFAULT
 747     input = dedent <<-END
 748        foo
 749        €bar
 750     END
 751     expected = dedent <<-END
 752       <pre>foo
 753       &#x20ac;bar</pre>
 754     END
 755     @parser.parse(input).should == expected
 756   end
 757
 758   # discovered at: http://rails.wincent.com/wiki/Testing_cookies_in_Rails
 759   it 'should handle BLOCKQUOTE_START blocks which follow lists' do
 760     # example text taken from wiki article and edited for brevity
 761     input = dedent <<-END
 762       * This article
 763       <blockquote>The cookies</blockquote>
 764     END
 765     expected = dedent <<-END
 766       <ul>
 767         <li>This article</li>
 768       </ul>
 769       <blockquote>
 770         <p>The cookies</p>
 771       </blockquote>
 772     END
 773     @parser.parse(input).should == expected
 774   end
 775
 776   # https://wincent.com/issues/818
 777   it 'should handle BLOCKQUOTE_START blocks which follow BLOCKQUOTE shorthand' do
 778     input = dedent <<-END
 779       > foo
 780       <blockquote>bar</blockquote>
 781     END
 782     expected = dedent <<-END
 783       <blockquote>
 784         <p>foo</p>
 785       </blockquote>
 786       <blockquote>
 787         <p>bar</p>
 788       </blockquote>
 789     END
 790     @parser.parse(input).should == expected
 791   end
 792
 793   # https://wincent.com/issues/818
 794   it 'should handle PRE_START blocks which follow BLOCKQUOTE shorthand' do
 795     input = dedent <<-END
 796       > foo
 797       <pre>bar</pre>
 798     END
 799     expected = dedent <<-END
 800       <blockquote>
 801         <p>foo</p>
 802       </blockquote>
 803       <pre>bar</pre>
 804     END
 805     @parser.parse(input).should == expected
 806   end
 807
 808   # https://wincent.com/issues/818
 809   it 'should handle BLOCKQUOTE_START blocks which follow nested BLOCKQUOTE shorthand' do
 810     input = dedent <<-END
 811       >>> foo
 812       <blockquote>bar</blockquote>
 813     END
 814     expected = dedent <<-END
 815       <blockquote>
 816         <blockquote>
 817           <blockquote>
 818             <p>foo</p>
 819           </blockquote>
 820         </blockquote>
 821       </blockquote>
 822       <blockquote>
 823         <p>bar</p>
 824       </blockquote>
 825     END
 826     @parser.parse(input).should == expected
 827   end
 828
 829   # https://wincent.com/issues/818
 830   it 'should handle PRE_START blocks which follow nested BLOCKQUOTE shorthand' do
 831     input = dedent <<-END
 832       >>> foo
 833       <pre>bar</pre>
 834     END
 835     expected = dedent <<-END
 836       <blockquote>
 837         <blockquote>
 838           <blockquote>
 839             <p>foo</p>
 840           </blockquote>
 841         </blockquote>
 842       </blockquote>
 843       <pre>bar</pre>
 844     END
 845     @parser.parse(input).should == expected
 846   end
 847
 848   # https://wincent.com/issues/1289
 849   it 'should handle empty (zero-width) link targets' do
 850     # these were badly broken (caused exceptions to be raised)
 851     @parser.parse('[[]]').should == "<p>[[]]</p>\n"
 852     @parser.parse('[[|]]').should == "<p>[[|]]</p>\n"
 853     @parser.parse('[[|foo]]').should == "<p>[[|foo]]</p>\n"
 854
 855     # was working, but check here anyway to guard against regressions
 856     @parser.parse('[[foo|]]').should == %Q{<p><a href="/wiki/foo">foo</a></p>\n}
 857   end
 858
 859   it 'should handle empty (whitespace only) link targets' do
 860     # no exception raised, but clearly not desirable behaviour
 861     # formerly these all returned: <p><a href="/wiki/"></a></p>\n
 862     @parser.parse('[[ ]]').should == "<p>[[ ]]</p>\n"
 863     @parser.parse('[[  ]]').should == "<p>[[  ]]</p>\n"
 864     @parser.parse('[[  |]]').should == "<p>[[  |]]</p>\n"
 865
 866     # and this one returned: <p><a href="/wiki/">foo</a></p>\n
 867     @parser.parse('[[  |foo]]').should == "<p>[[  |foo]]</p>\n"
 868   end
 869 end