wikitext 0.1

data/spec/link_encoding_spec.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+# Copyright 2007-2008 Wincent Colaiuta
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+require 'wikitext'
+require 'uri'
+
+describe Wikitext, 'encoding a link target' do
+  it 'should complain if passed nil' do
+    lambda { Wikitext::Parser.encode_link_target(nil) }.should raise_error
+  end
+
+  it 'should do nothing on zero-length input' do
+    Wikitext::Parser.encode_link_target('').should == ''
+  end
+
+  it 'should convert embedded spaces into "%20"' do
+    Wikitext::Parser.encode_link_target('hello world').should == 'hello%20world'
+  end
+
+  it 'should eat leading spaces' do
+    Wikitext::Parser.encode_link_target(' hello world').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('  hello world').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('   hello world').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('    hello world').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('     hello world').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('      hello world').should == 'hello%20world'
+  end
+
+  it 'should eat trailing spaces' do
+    Wikitext::Parser.encode_link_target('hello world ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('hello world  ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('hello world   ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('hello world    ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('hello world     ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('hello world      ').should == 'hello%20world'
+  end
+
+  it 'should eat leading and trailing spaces combined' do
+    Wikitext::Parser.encode_link_target('     hello world ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('     hello world ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('    hello world  ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('   hello world   ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target('  hello world    ').should == 'hello%20world'
+    Wikitext::Parser.encode_link_target(' hello world     ').should == 'hello%20world'
+  end
+
+  it 'should return nothing for input consisting entirely of spaces' do
+    Wikitext::Parser.encode_link_target(' ').should == ''
+    Wikitext::Parser.encode_link_target('  ').should == ''
+    Wikitext::Parser.encode_link_target('   ').should == ''
+    Wikitext::Parser.encode_link_target('    ').should == ''
+    Wikitext::Parser.encode_link_target('     ').should == ''
+    Wikitext::Parser.encode_link_target('      ').should == ''
+  end
+
+  it 'should convert reserved symbols into percent escapes' do
+    Wikitext::Parser.encode_link_target('http://www.apple.com/q?foo').should == 'http%3a%2f%2fwww.apple.com%2fq%3ffoo'
+  end
+
+  it 'should convert non-ASCII into UTF-8 and then apply percent escapes' do
+    Wikitext::Parser.encode_link_target('cañon').should == 'ca%c3%b1on'
+  end
+
+  it 'should handle mixed scenarios (commas, double-quotes and UTF-8)' do
+    Wikitext::Parser.encode_link_target('foo, "bar" & baz €').should == 'foo%2c%20%22bar%22%20%26%20baz%20%e2%82%ac'
+  end
+
+  it 'should get the same answer as URI.escape' do
+    reserved = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+    ['foo bar', 'http://www.google.com/search?q=hello&foo=bar', '€'].each do |string|
+      Wikitext::Parser.encode_link_target(string).should == URI.escape(string, reserved).downcase
+    end
+  end
+
+  # "special" links don't get transformed in any way
+  describe 'special links' do
+    it 'should recognize links which match /\A[a-z]+\/\d+\z/ as being special' do
+      string = 'foo/10'
+      Wikitext::Parser.encode_special_link_target(string).should == string
+      Wikitext::Parser.encode_link_target(string).should_not == string
+    end
+
+    it "should not recognize links which don't match at /\A/ as being special" do
+      string = '  foo/10'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+      string = '..foo/10'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+      string = '12foo/10'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+    end
+
+    it "should not recognize links which don't match at /\z/ as being special" do
+      string = 'foo/10  '
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+      string = 'foo/10__'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+      string = 'foo/10##'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+      string = 'foo/10ab'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+    end
+
+    it "should not recognize links which don't match at /[a-z]/ (case differences) as being special" do
+      string = 'FOO/10'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+    end
+
+    it "should not recognize links which don't match at /[0-9]/ (case differences) as being special" do
+      string = 'foo/xx'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+    end
+
+    it "should not recognize links which don't match at /\// as being special" do
+      string = 'foo 10'
+      Wikitext::Parser.encode_special_link_target(string).should_not == string
+    end
+  end
+end
+

data/spec/link_sanitizing_spec.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+# Copyright 2007-2008 Wincent Colaiuta
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+require 'wikitext'
+
+describe Wikitext, 'sanitizing a link target' do
+  it 'should complain if passed nil' do
+    lambda { Wikitext::Parser.sanitize_link_target(nil) }.should raise_error
+  end
+
+  it 'should complain if passed <' do
+    lambda { Wikitext::Parser.sanitize_link_target('<') }.should raise_error(RangeError, /</)
+  end
+
+  it 'should complain if passed >' do
+    lambda { Wikitext::Parser.sanitize_link_target('>') }.should raise_error(RangeError, />/)
+  end
+
+  it 'should do nothing on zero-length input' do
+    Wikitext::Parser.sanitize_link_target('').should == ''
+  end
+
+  it 'should do nothing to embedded spaces' do
+    Wikitext::Parser.sanitize_link_target('hello world').should == 'hello world'
+  end
+
+  it 'should eat leading spaces' do
+    Wikitext::Parser.sanitize_link_target(' hello world').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('  hello world').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('   hello world').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('    hello world').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('     hello world').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('      hello world').should == 'hello world'
+  end
+
+  it 'should eat trailing spaces' do
+    Wikitext::Parser.sanitize_link_target('hello world ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('hello world  ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('hello world   ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('hello world    ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('hello world     ').should == 'hello world'   # was a crasher
+    Wikitext::Parser.sanitize_link_target('hello world      ').should == 'hello world'  # was a crasher
+
+    # same but with lots of entities to force a reallocation (we were crashing under reallocation)
+    expected = '&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;'
+    Wikitext::Parser.sanitize_link_target('""""""""""      ').should == expected
+  end
+
+  it 'should eat leading and trailing spaces combined' do
+    Wikitext::Parser.sanitize_link_target(' hello world     ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('  hello world    ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('   hello world   ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('    hello world  ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('     hello world  ').should == 'hello world'
+    Wikitext::Parser.sanitize_link_target('      hello world ').should == 'hello world'
+  end
+
+  it 'should return nothing for input consisting entirely of spaces' do
+    Wikitext::Parser.sanitize_link_target(' ').should == ''
+    Wikitext::Parser.sanitize_link_target('  ').should == ''
+    Wikitext::Parser.sanitize_link_target('   ').should == ''
+    Wikitext::Parser.sanitize_link_target('    ').should == ''
+    Wikitext::Parser.sanitize_link_target('     ').should == ''
+    Wikitext::Parser.sanitize_link_target('      ').should == ''
+  end
+
+  it 'should convert double quotes into named entities' do
+    Wikitext::Parser.sanitize_link_target('hello "world"').should == 'hello &quot;world&quot;'
+  end
+
+  it 'should convert ampersands into named entities' do
+    Wikitext::Parser.sanitize_link_target('hello & goodbye').should == 'hello &amp; goodbye'
+  end
+
+  it 'should convert non-ASCII hexadecimal entities' do
+    Wikitext::Parser.sanitize_link_target('cañon').should == 'ca&#x00f1;on'
+  end
+
+  it 'should handle mixed scenarios (ampersands, double-quotes and non-ASCII)' do
+    Wikitext::Parser.sanitize_link_target('foo, "bar" & baz €').should == 'foo, &quot;bar&quot; &amp; baz &#x20ac;'
+  end
+
+  # here we're exercising the _Wikitext_utf8_to_utf32 function
+  describe 'with invalidly encoded input' do
+    it 'should raise an exception for missing second byte' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::TWO_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::TWO_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for malformed second byte' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::TWO_BYTES_MALFORMED_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::TWO_BYTES_MALFORMED_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+    end
+
+    it 'should raise an exception for overlong sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::OVERLONG)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::OVERLONG)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+
+      # alternate
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::OVERLONG_ALT)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::OVERLONG_ALT)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+    end
+
+    it 'should raise an exception for missing second byte in three-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::THREE_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::THREE_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for missing third byte in three-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::THREE_BYTES_MISSING_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::THREE_BYTES_MISSING_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for malformed second byte in three-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::THREE_BYTES_MALFORMED_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::THREE_BYTES_MALFORMED_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+    end
+
+    it 'should raise an exception for malformed third byte in three-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::THREE_BYTES_MALFORMED_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::THREE_BYTES_MALFORMED_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /malformed/)
+    end
+
+    it 'should raise an exception for missing second byte in four-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_MISSING_SECOND_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for missing third byte in four-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_MISSING_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_MISSING_THIRD_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for missing fourth byte in four-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_MISSING_FOURTH_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_MISSING_FOURTH_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /truncated/)
+    end
+
+    it 'should raise an exception for illegal first byte in four-byte sequence' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE_ALT)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE_ALT)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE_ALT2)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::FOUR_BYTES_ILLEGAL_FIRST_BYTE_ALT2)
+      }.should raise_error(Wikitext::Parser::Error, /overlong/)
+    end
+
+    it 'should raise an exception for unexpected bytes' do
+      lambda {
+        Wikitext::Parser.sanitize_link_target(UTF8::Invalid::UNEXPECTED_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /unexpected/)
+      lambda {
+        Wikitext::Parser.sanitize_link_target('good text' + UTF8::Invalid::UNEXPECTED_BYTE)
+      }.should raise_error(Wikitext::Parser::Error, /unexpected/)
+    end
+  end
+end

data/spec/nowiki_spec.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+# Copyright 2007-2008 Wincent Colaiuta
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+require 'wikitext'
+
+describe Wikitext::Parser, 'parsing <nowiki> spans' do
+  before do
+    @parser = Wikitext::Parser.new
+  end
+
+  it 'should not echo paired <nowiki> and </nowiki> tags' do
+    @parser.parse('foo <nowiki>bar</nowiki> baz').should == "<p>foo bar baz</p>\n"
+  end
+
+  it 'should automatically handle missing closing tags (at end of outpt)' do
+    # note that CRLF doesn't auto-terminate a <nowiki> span, unlike other inline spans
+    @parser.parse('foo <nowiki>bar').should == "<p>foo bar</p>\n"
+  end
+
+  it 'should unconditionally echo newlines inside <nowiki> spans' do
+    @parser.parse("<nowiki>foo\nbar</nowiki>").should == "<p>foo\nbar</p>\n"
+    @parser.parse("<nowiki>foo\n\nbar</nowiki>").should == "<p>foo\n\nbar</p>\n"
+    @parser.parse("<nowiki>foo\n\n\nbar</nowiki>").should == "<p>foo\n\n\nbar</p>\n"
+  end
+
+  it 'should convert unexpected closing tags into entities' do
+    @parser.parse('foo </nowiki>bar').should == "<p>foo &lt;/nowiki&gt;bar</p>\n"
+  end
+
+  it 'should convert nested opening tags into entities' do
+    @parser.parse('<nowiki>foo<nowiki>bar</nowiki>baz').should == "<p>foo&lt;nowiki&gt;barbaz</p>\n"
+  end
+
+  it 'should have no effect inside <pre> blocks' do
+    @parser.parse(' <nowiki>foo</nowiki>').should == "<pre>&lt;nowiki&gt;foo&lt;/nowiki&gt;</pre>\n"
+  end
+
+  it 'should pass short BLOCKQUOTE tokens through without any special meaning' do
+    @parser.parse("<nowiki>\n></nowiki>").should == "<p>\n&gt;</p>\n"
+  end
+
+  it 'should pass long BLOCKQUOTE tokens through without any special meaning' do
+    @parser.parse("<nowiki>\n> </nowiki>").should == "<p>\n&gt; </p>\n"
+  end
+
+  it 'should pass <tt> and </tt> tags through without any special meaning' do
+    @parser.parse('<nowiki>foo <tt>bar</tt></nowiki>').should == "<p>foo &lt;tt&gt;bar&lt;/tt&gt;</p>\n"
+  end
+
+  it 'should pass <em> and </em> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo ''bar''</nowiki>").should == "<p>foo ''bar''</p>\n"
+  end
+
+  it 'should pass <strong> and </strong> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo '''bar'''</nowiki>").should == "<p>foo '''bar'''</p>\n"
+  end
+
+  it 'should pass combined <strong>/<em> and </strong>/</em> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo '''''bar'''''</nowiki>").should == "<p>foo '''''bar'''''</p>\n"
+  end
+
+  it 'should pass <h1> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n= foo</nowiki>").should == "<p>\n= foo</p>\n"
+  end
+
+  it 'should pass </h1> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo =\n</nowiki>").should == "<p>foo =\n</p>\n"
+  end
+
+  it 'should pass <h2> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n== foo</nowiki>").should == "<p>\n== foo</p>\n"
+  end
+
+  it 'should pass </h2> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo ==\n</nowiki>").should == "<p>foo ==\n</p>\n"
+  end
+
+  it 'should pass <h3> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n=== foo</nowiki>").should == "<p>\n=== foo</p>\n"
+  end
+
+  it 'should pass </h3> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo ===\n</nowiki>").should == "<p>foo ===\n</p>\n"
+  end
+
+  it 'should pass <h4> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n==== foo</nowiki>").should == "<p>\n==== foo</p>\n"
+  end
+
+  it 'should pass </h4> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo ====\n</nowiki>").should == "<p>foo ====\n</p>\n"
+  end
+
+  it 'should pass <h5> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n===== foo</nowiki>").should == "<p>\n===== foo</p>\n"
+  end
+
+  it 'should pass </h5> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo =====\n</nowiki>").should == "<p>foo =====\n</p>\n"
+  end
+
+  it 'should pass <h6> tags through without any special meaning' do
+    @parser.parse("<nowiki>\n====== foo</nowiki>").should == "<p>\n====== foo</p>\n"
+  end
+
+  it 'should pass </h6> tags through without any special meaning' do
+    @parser.parse("<nowiki>foo ======\n</nowiki>").should == "<p>foo ======\n</p>\n"
+  end
+
+  it 'should pass link start tokens through unchanged' do
+    @parser.parse('<nowiki>[[</nowiki>').should == "<p>[[</p>\n"
+  end
+
+  it 'should pass link end tokens through unchanged' do
+    @parser.parse('<nowiki>]]</nowiki>').should == "<p>]]</p>\n"
+  end
+
+  it 'should pass external link start tokens through unchanged' do
+    @parser.parse('<nowiki>[</nowiki>').should == "<p>[</p>\n"
+  end
+
+  it 'should pass external link end tokens through unchanged' do
+    @parser.parse('<nowiki>]</nowiki>').should == "<p>]</p>\n"
+  end
+
+  it 'should pass named entities through unchanged' do
+    @parser.parse('<nowiki>&euro;</nowiki>').should == "<p>&euro;</p>\n"
+  end
+
+  it 'should pass numeric (decimal) entities through unchanged' do
+    @parser.parse('<nowiki>&#8364;</nowiki>').should == "<p>&#8364;</p>\n"
+  end
+
+  it 'should pass numeric (hexadecimal) entities through unchanged' do
+    @parser.parse('<nowiki>&#x20ac;</nowiki>').should == "<p>&#x20ac;</p>\n"
+    @parser.parse('<nowiki>&#X20Ac;</nowiki>').should == "<p>&#x20ac;</p>\n"
+  end
+
+  it 'should convert non-ASCII characters to numeric entities' do
+    @parser.parse('<nowiki>€</nowiki>').should == "<p>&#x20ac;</p>\n"
+  end
+end