asciidoctor 1.5.8 → 2.0.0.rc.1

data/test/test_helper.rb

@@ -1,447 +0,0 @@
-# encoding: UTF-8
-ASCIIDOCTOR_TEST_DIR = File.expand_path File.dirname __FILE__
-ASCIIDOCTOR_PROJECT_DIR = File.dirname ASCIIDOCTOR_TEST_DIR
-ASCIIDOCTOR_LIB_DIR = ENV['ASCIIDOCTOR_LIB_DIR'] || File.join(ASCIIDOCTOR_PROJECT_DIR, 'lib')
-Dir.chdir ASCIIDOCTOR_PROJECT_DIR
-
-if RUBY_VERSION < '1.9'
-  require 'rubygems'
-end
-
-require 'simplecov' if ENV['COVERAGE'] == 'true'
-
-require File.join(ASCIIDOCTOR_LIB_DIR, 'asciidoctor')
-
-require 'socket'
-require 'nokogiri'
-require 'tempfile'
-require 'tmpdir'
-
-autoload :FileUtils, 'fileutils'
-autoload :Pathname,  'pathname'
-autoload :Open3, 'open3'
-
-RE_XMLNS_ATTRIBUTE = / xmlns="[^"]+"/
-RE_DOCTYPE = /\s*<!DOCTYPE (.*)/
-
-require 'minitest/autorun'
-
-# Minitest 4 doesn't have Minitest::Test
-Minitest::Test = MiniTest::Unit::TestCase unless defined? Minitest::Test
-
-class Minitest::Test
-  def windows?
-    RbConfig::CONFIG['host_os'] =~ /win|ming/
-  end
-
-  def disk_root
-    %(#{windows? ? ASCIIDOCTOR_PROJECT_DIR.split('/')[0] : ''}/)
-  end
-
-  def empty_document options = {}
-    if options[:parse]
-      (Asciidoctor::Document.new [], options).parse
-    else
-      Asciidoctor::Document.new [], options
-    end
-  end
-
-  def empty_safe_document options = {}
-    options[:safe] = :safe
-    Asciidoctor::Document.new [], options
-  end
-
-  def sample_doc_path(name)
-    name = name.to_s
-    unless name.include?('.')
-      ['asciidoc', 'txt'].each do |ext|
-        if File.exist?(fixture_path("#{name}.#{ext}"))
-          name = "#{name}.#{ext}"
-          break
-        end
-      end
-    end
-    fixture_path(name)
-  end
-
-  def testdir
-    ASCIIDOCTOR_TEST_DIR
-  end
-
-  def fixturedir
-    File.join testdir, 'fixtures'
-  end
-
-  def fixture_path name
-    File.join fixturedir, name
-  end
-
-  def example_document(name, opts = {})
-    document_from_string IO.read(sample_doc_path(name)), opts
-  end
-
-  def xmlnodes_at_css(css, content, count = nil)
-    xmlnodes_at_path(:css, css, content, count)
-  end
-
-  def xmlnodes_at_xpath(xpath, content, count = nil)
-    xmlnodes_at_path(:xpath, xpath, content, count)
-  end
-
-  def xmlnodes_at_path(type, path, content, count = nil)
-    doc = xmldoc_from_string content
-    case type
-      when :xpath
-        namespaces = doc.respond_to?(:root) ? doc.root.namespaces : {}
-        results = doc.xpath("#{path.sub('/', './')}", namespaces)
-      when :css
-        results = doc.css(path)
-    end
-    count == 1 ? results.first : results
-  end
-
-  # Generate an xpath attribute matcher that matches a name in the class attribute
-  def contains_class(name)
-    %(contains(concat(' ', normalize-space(@class), ' '), ' #{name} '))
-  end
-
-  def assert_css(css, content, count = nil)
-    assert_path(:css, css, content, count)
-  end
-
-  def assert_xpath(xpath, content, count = nil)
-    assert_path(:xpath, xpath, content, count)
-  end
-
-  def assert_path(type, path, content, count = nil)
-    case type
-    when :xpath
-      type_name = 'XPath'
-    when :css
-      type_name = 'CSS'
-    end
-
-    results = xmlnodes_at_path type, path, content
-
-    if (count == true || count == false)
-      if (count != results)
-        flunk "#{type_name} #{path} yielded #{results} rather than #{count} for:\n#{content}"
-      else
-        assert true
-      end
-    elsif (count && results.size != count)
-      flunk "#{type_name} #{path} yielded #{results.size} elements rather than #{count} for:\n#{content}"
-    elsif (count.nil? && results.empty?)
-      flunk "#{type_name} #{path} not found in:\n#{content}"
-    else
-      assert true
-    end
-  end
-
-  def assert_message logger, severity, expected_message, kind = String, idx = nil
-    unless idx
-      assert_equal 1, logger.messages.size
-      idx = 0
-    end
-    message = logger.messages[idx]
-    assert_equal severity, message[:severity]
-    assert_kind_of kind, message[:message]
-    if kind == String
-      actual_message = message[:message]
-    else
-      refute_nil message[:message][:source_location]
-      actual_message = message[:message].inspect
-    end
-    if expected_message.start_with? '~'
-      assert_includes actual_message, expected_message[1..-1]
-    else
-      assert_equal expected_message, actual_message
-    end
-  end
-
-  def assert_messages logger, expected_messages
-    assert_equal expected_messages.size, logger.messages.size
-    expected_messages.each_with_index do |expected_message_details, idx|
-      severity, expected_message, kind = expected_message_details
-      assert_message logger, severity, expected_message, (kind || String), idx
-    end
-  end
-
-  def xmldoc_from_string(content)
-    if content.match(RE_XMLNS_ATTRIBUTE)
-      Nokogiri::XML::Document.parse(content)
-    elsif !(doctype_match = content.match(RE_DOCTYPE))
-      Nokogiri::HTML::DocumentFragment.parse(content)
-    elsif doctype_match[1].start_with? 'html'
-      Nokogiri::HTML::Document.parse(content)
-    else
-      Nokogiri::XML::Document.parse(content)
-    end
-  end
-
-  def document_from_string(src, opts = {})
-    assign_default_test_options opts
-    if opts[:parse]
-      (Asciidoctor::Document.new src.lines.entries, opts).parse
-    else
-      Asciidoctor::Document.new src.lines.entries, opts
-    end
-  end
-
-  def block_from_string(src, opts = {})
-    opts[:header_footer] = false
-    doc = document_from_string src, opts
-    doc.blocks.first
-  end
-
-  def convert_string(src, opts = {})
-    keep_namespaces = opts.delete(:keep_namespaces)
-    if keep_namespaces
-      document_from_string(src, opts).convert
-    else
-      # this is required because nokogiri is ignorant
-      result = document_from_string(src, opts).convert
-      result = result.sub(RE_XMLNS_ATTRIBUTE, '') if result
-      result
-    end
-  end
-
-  def convert_string_to_embedded(src, opts = {})
-    opts[:header_footer] = false
-    document_from_string(src, opts).convert
-  end
-
-  def convert_inline_string(src, opts = {})
-    opts[:doctype] = :inline
-    document_from_string(src, opts).convert
-  end
-
-  def parse_header_metadata(source, doc = nil)
-    reader = Asciidoctor::Reader.new source.split ::Asciidoctor::LF
-    [::Asciidoctor::Parser.parse_header_metadata(reader, doc), reader]
-  end
-
-  def assign_default_test_options(opts)
-    opts[:header_footer] = true unless opts.key? :header_footer
-    opts[:parse] = true unless opts.key? :parse
-    if opts[:header_footer]
-      # don't embed stylesheet unless test requests the default behavior
-      if opts.has_key? :linkcss_default
-        opts.delete(:linkcss_default)
-      else
-        opts[:attributes] ||= {}
-        opts[:attributes]['linkcss'] = ''
-      end
-    end
-    if (template_dir = ENV['TEMPLATE_DIR'])
-      opts[:template_dir] = template_dir unless opts.has_key? :template_dir
-    end
-    nil
-  end
-
-  # Decode the numeric character reference, such as 8212, to a Unicode glyph
-  # so it may be used in an XPath expression.
-  #
-  # Examples
-  #
-  #   decode_char 60
-  #   # => "<"
-  #
-  # Returns the decoded String that corresponds to the numeric character reference
-  def decode_char number
-    [number].pack 'U1'
-  end
-
-  def invoke_cli_with_filenames(argv = [], filenames = [], &block)
-    filepaths = Array.new
-
-    filenames.each {|filename|
-      if filenames.nil? || ::Pathname.new(filename).absolute?
-        filepaths << filename
-      else
-        filepaths << (fixture_path filename)
-      end
-    }
-
-    invoker = Asciidoctor::Cli::Invoker.new(argv + filepaths)
-
-    invoker.invoke!(&block)
-    invoker
-  end
-
-  def invoke_cli_to_buffer(argv = [], filename = 'sample.asciidoc', &block)
-    invoke_cli(argv, filename, [StringIO.new, StringIO.new], &block)
-  end
-
-  def invoke_cli(argv = [], filename = 'sample.asciidoc', buffers = nil, &block)
-    if filename.nil? || filename == '-' || ::Pathname.new(filename).absolute?
-      filepath = filename
-    else
-      filepath = fixture_path filename
-    end
-    invoker = Asciidoctor::Cli::Invoker.new(argv + [filepath])
-    if buffers
-      invoker.redirect_streams(*buffers)
-    end
-    invoker.invoke!(&block)
-    invoker
-  end
-
-  def redirect_streams
-    old_stdout, $stdout = $stdout, (tmp_stdout = ::StringIO.new)
-    old_stderr, $stderr = $stderr, (tmp_stderr = ::StringIO.new)
-    old_logger = Asciidoctor::LoggerManager.logger
-    old_logger_level = old_logger.level
-    new_logger = (Asciidoctor::LoggerManager.logger = Asciidoctor::Logger.new $stderr)
-    new_logger.level = old_logger_level
-    yield tmp_stdout, tmp_stderr
-  ensure
-    $stdout, $stderr = old_stdout, old_stderr
-    Asciidoctor::LoggerManager.logger = old_logger
-  end
-
-  def resolve_localhost
-    (RUBY_VERSION < '1.9' || RUBY_ENGINE == 'rbx') ? Socket.gethostname :
-        Socket.ip_address_list.find {|addr| addr.ipv4? }.ip_address
-  end
-
-  def using_memory_logger
-    old_logger = Asciidoctor::LoggerManager.logger
-    memory_logger = Asciidoctor::MemoryLogger.new
-    begin
-      Asciidoctor::LoggerManager.logger = memory_logger
-      yield memory_logger
-    ensure
-      Asciidoctor::LoggerManager.logger = old_logger
-    end
-  end
-
-  def in_verbose_mode
-    begin
-      old_verbose, $VERBOSE = $VERBOSE, true
-      yield
-    ensure
-      $VERBOSE = old_verbose
-    end
-  end
-
-  def using_test_webserver host = resolve_localhost, port = 9876
-    server = TCPServer.new host, port
-    base_dir = testdir
-    t = Thread.new do
-      while (session = server.accept)
-        request = session.gets
-        resource = nil
-        if (m = /GET (\S+) HTTP\/1\.1$/.match(request.chomp))
-          resource = (resource = m[1]) == '' ? '.' : resource
-        else
-          session.print %(HTTP/1.1 405 Method Not Allowed\r\nContent-Type: text/plain\r\n\r\n)
-          session.print %(405 - Method not allowed\n)
-          session.close
-          break
-        end
-
-        if resource == '/name/asciidoctor'
-          session.print %(HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n)
-          session.print %({"name": "asciidoctor"}\n)
-        elsif File.file?(resource_file = (File.join base_dir, resource))
-          mimetype = if (ext = ::File.extname(resource_file)[1..-1])
-            ext == 'adoc' ? 'text/plain' : %(image/#{ext})
-          else
-            'text/plain'
-          end
-          session.print %(HTTP/1.1 200 OK\r\nContent-Type: #{mimetype}\r\n\r\n)
-          File.open resource_file, 'rb' do |fd|
-            until fd.eof? do
-              buffer = fd.read 256
-              session.write buffer
-            end
-          end
-        else
-          session.print %(HTTP/1.1 404 File Not Found\r\nContent-Type: text/plain\r\n\r\n)
-          session.print %(404 - Resource not found.\n)
-        end
-        session.close
-      end
-    end
-    begin
-      yield
-    ensure
-      begin
-        server.shutdown
-      # "Errno::ENOTCONN: Socket is not connected' is reported on some platforms; call #close instead of #shutdown
-      rescue Errno::ENOTCONN
-        server.close
-      end
-      t.exit
-    end
-  end
-end
-
-###
-#
-# Context goodness provided by @citrusbyte's contest.
-# See https://github.com/citrusbyte/contest
-#
-###
-
-# Contest adds +teardown+, +test+ and +context+ as class methods, and the
-# instance methods +setup+ and +teardown+ now iterate on the corresponding
-# blocks. Note that all setup and teardown blocks must be defined with the
-# block syntax. Adding setup or teardown instance methods defeats the purpose
-# of this library.
-class Minitest::Test
-  def self.setup(&block)
-    define_method :setup do
-      super(&block)
-      instance_eval(&block)
-    end
-  end
-
-  def self.teardown(&block)
-    define_method :teardown do
-      instance_eval(&block)
-      super(&block)
-    end
-  end
-
-  def self.context(*name, &block)
-    subclass = Class.new(self)
-    remove_tests(subclass)
-    subclass.class_eval(&block) if block_given?
-    const_set(context_name(name.join(" ")), subclass)
-  end
-
-  def self.test(name, &block)
-    define_method(test_name(name), &block)
-  end
-
-  class << self
-    alias_method :should, :test
-    alias_method :describe, :context
-  end
-
-private
-
-  def self.context_name(name)
-    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
-  end
-
-  def self.test_name(name)
-    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
-  end
-
-  def self.sanitize_name(name)
-    name.gsub(/\W+/, ' ').strip
-  end
-
-  def self.remove_tests(subclass)
-    subclass.public_instance_methods.grep(/^test_/).each do |meth|
-      subclass.send(:undef_method, meth.to_sym)
-    end
-  end
-end
-
-def context(*name, &block)
-  Minitest::Test.context(name, &block)
-end

data/test/text_test.rb

@@ -1,309 +0,0 @@
-# encoding: UTF-8
-unless defined? ASCIIDOCTOR_PROJECT_DIR
-  $: << File.dirname(__FILE__); $:.uniq!
-  require 'test_helper'
-end
-
-context "Text" do
-  test "proper encoding to handle utf8 characters in document using html backend" do
-    output = example_document(:encoding).convert
-    assert_xpath '//p', output, 4
-    assert_xpath '//a', output, 1
-  end
-
-  test "proper encoding to handle utf8 characters in embedded document using html backend" do
-    output = example_document(:encoding, :header_footer => false).convert
-    assert_xpath '//p', output, 4
-    assert_xpath '//a', output, 1
-  end
-
-  test "proper encoding to handle utf8 characters in document using docbook45 backend" do
-    output = example_document(:encoding, :attributes => {'backend' => 'docbook45', 'xmlns' => ''}).convert
-    assert_xpath '//xmlns:simpara', output, 4
-    assert_xpath '//xmlns:ulink', output, 1
-  end
-
-  test "proper encoding to handle utf8 characters in embedded document using docbook45 backend" do
-    output = example_document(:encoding, :header_footer => false, :attributes => {'backend' => 'docbook45'}).convert
-    assert_xpath '//simpara', output, 4
-    assert_xpath '//ulink', output, 1
-  end
-
-  # NOTE this test ensures we have the encoding line on block templates too
-  test 'proper encoding to handle utf8 characters in arbitrary block' do
-    input = []
-    input << "[verse]\n"
-    input.concat(File.readlines(sample_doc_path(:encoding)))
-    doc = empty_document
-    reader = Asciidoctor::PreprocessorReader.new doc, input, nil, :normalize => true
-    block = Asciidoctor::Parser.next_block(reader, doc)
-    assert_xpath '//pre', block.convert.gsub(/^\s*\n/, ''), 1
-  end
-
-  test 'proper encoding to handle utf8 characters from included file' do
-    input = <<-EOS
-include::fixtures/encoding.asciidoc[tags=romé]
-    EOS
-    doc = empty_safe_document :base_dir => testdir
-    reader = Asciidoctor::PreprocessorReader.new doc, input, nil, :normalize => true
-    block = Asciidoctor::Parser.next_block(reader, doc)
-    output = block.convert
-    assert_css '.paragraph', output, 1
-  end
-
-  test 'escaped text markup' do
-    assert_match(/All your &lt;em&gt;inline&lt;\/em&gt; markup belongs to &lt;strong&gt;us&lt;\/strong&gt;!/,
-        convert_string('All your <em>inline</em> markup belongs to <strong>us</strong>!'))
-  end
-
-  test "line breaks" do
-    assert_xpath "//br", convert_string("Well this is +\njust fine and dandy, isn't it?"), 1
-  end
-
-  test 'single- and double-quoted text' do
-    output = convert_string_to_embedded(%q(``Where?,'' she said, flipping through her copy of `The New Yorker.'), :attributes => {'compat-mode' => ''})
-    assert_match(/&#8220;Where\?,&#8221;/, output)
-    assert_match(/&#8216;The New Yorker.&#8217;/, output)
-
-    output = convert_string_to_embedded(%q("`Where?,`" she said, flipping through her copy of '`The New Yorker.`'))
-    assert_match(/&#8220;Where\?,&#8221;/, output)
-    assert_match(/&#8216;The New Yorker.&#8217;/, output)
-  end
-
-  test 'multiple double-quoted text on a single line' do
-    assert_equal '&#8220;Our business is constantly changing&#8221; or &#8220;We need faster time to market.&#8221;',
-        convert_inline_string(%q(``Our business is constantly changing'' or ``We need faster time to market.''), :attributes => {'compat-mode' => ''})
-    assert_equal '&#8220;Our business is constantly changing&#8221; or &#8220;We need faster time to market.&#8221;',
-        convert_inline_string(%q("`Our business is constantly changing`" or "`We need faster time to market.`"))
-  end
-
-  test 'horizontal rule' do
-    input = <<-EOS
-This line is separated by a horizontal rule...
-
-'''
-
-...from this line.
-    EOS
-    output = convert_string_to_embedded input
-    assert_xpath "//hr", output, 1
-    assert_xpath "/*[@class='paragraph']", output, 2
-    assert_xpath "(/*[@class='paragraph'])[1]/following-sibling::hr", output, 1
-    assert_xpath "/hr/following-sibling::*[@class='paragraph']", output, 1
-  end
-
-  test 'markdown horizontal rules' do
-    variants = [
-      '---',
-      '- - -',
-      '***',
-      '* * *',
-      '___',
-      '_ _ _'
-    ]
-
-    offsets = [
-      '',
-      ' ',
-      '  ',
-      '   '
-    ]
-
-    variants.each do |variant|
-      offsets.each do |offset|
-        input = <<-EOS
-This line is separated by a horizontal rule...
-
-#{offset}#{variant}
-
-...from this line.
-        EOS
-        output = convert_string_to_embedded input
-        assert_xpath "//hr", output, 1
-        assert_xpath "/*[@class='paragraph']", output, 2
-        assert_xpath "(/*[@class='paragraph'])[1]/following-sibling::hr", output, 1
-        assert_xpath "/hr/following-sibling::*[@class='paragraph']", output, 1
-      end
-    end
-  end
-
-  test 'markdown horizontal rules negative case' do
-
-    bad_variants = [
-      '- - - -',
-      '* * * *',
-      '_ _ _ _'
-    ]
-
-    good_offsets = [
-      '',
-      ' ',
-      '  ',
-      '   '
-    ]
-
-    bad_variants.each do |variant|
-      good_offsets.each do |offset|
-        input = <<-EOS
-This line is separated by something that is not a horizontal rule...
-
-#{offset}#{variant}
-
-...from this line.
-        EOS
-        output = convert_string_to_embedded input
-        assert_xpath '//hr', output, 0
-      end
-    end
-
-    good_variants = [
-      '- - -',
-      '* * *',
-      '_ _ _'
-    ]
-
-    bad_offsets = [
-      "\t",
-      '    '
-    ]
-
-    good_variants.each do |variant|
-      bad_offsets.each do |offset|
-        input = <<-EOS
-This line is separated by something that is not a horizontal rule...
-
-#{offset}#{variant}
-
-...from this line.
-        EOS
-        output = convert_string_to_embedded input
-        assert_xpath '//hr', output, 0
-      end
-    end
-  end
-
-  test "emphasized text using underscore characters" do
-    assert_xpath "//em", convert_string("An _emphatic_ no")
-  end
-
-  test 'emphasized text with single quote using apostrophe characters' do
-    rsquo = decode_char 8217
-    assert_xpath %(//em[text()="Johnny#{rsquo}s"]), convert_string(%q(It's 'Johnny's' phone), :attributes => {'compat-mode' => ''})
-    assert_xpath %(//p[text()="It#{rsquo}s 'Johnny#{rsquo}s' phone"]), convert_string(%q(It's 'Johnny's' phone))
-  end
-
-  test 'emphasized text with escaped single quote using apostrophe characters' do
-    assert_xpath %(//em[text()="Johnny's"]), convert_string(%q(It's 'Johnny\\'s' phone), :attributes => {'compat-mode' => ''})
-    assert_xpath %(//p[text()="It's 'Johnny's' phone"]), convert_string(%q(It\\'s 'Johnny\\'s' phone))
-  end
-
-  test "escaped single quote is restored as single quote" do
-    assert_xpath "//p[contains(text(), \"Let's do it!\")]", convert_string("Let\\'s do it!")
-  end
-
-  test 'unescape escaped single quote emphasis in compat mode only' do
-    assert_xpath %(//p[text()="A 'single quoted string' example"]), convert_string_to_embedded(%(A \\'single quoted string' example), :attributes => {'compat-mode' => ''})
-    assert_xpath %(//p[text()="'single quoted string'"]), convert_string_to_embedded(%(\\'single quoted string'), :attributes => {'compat-mode' => ''})
-
-    assert_xpath %(//p[text()="A \\'single quoted string' example"]), convert_string_to_embedded(%(A \\'single quoted string' example))
-    assert_xpath %(//p[text()="\\'single quoted string'"]), convert_string_to_embedded(%(\\'single quoted string'))
-  end
-
-  test "emphasized text at end of line" do
-    assert_xpath "//em", convert_string("This library is _awesome_")
-  end
-
-  test "emphasized text at beginning of line" do
-    assert_xpath "//em", convert_string("_drop_ it")
-  end
-
-  test "emphasized text across line" do
-    assert_xpath "//em", convert_string("_check it_")
-  end
-
-  test "unquoted text" do
-    refute_match(/#/, convert_string("An #unquoted# word"))
-  end
-
-  test 'backticks and straight quotes in text' do
-    backslash = '\\'
-    assert_equal %q(run <code>foo</code> <em>dog</em>), convert_inline_string(%q(run `foo` 'dog'), :attributes => {'compat-mode' => ''})
-    assert_equal %q(run <code>foo</code> 'dog'), convert_inline_string(%q(run `foo` 'dog'))
-    assert_equal %q(run `foo` 'dog'), convert_inline_string(%(run #{backslash}`foo` 'dog'))
-    assert_equal %q(run &#8216;foo` 'dog&#8217;), convert_inline_string(%q(run '`foo` 'dog`'))
-    assert_equal %q(run '`foo` 'dog`'), convert_inline_string(%(run #{backslash}'`foo` 'dog#{backslash}`'))
-  end
-
-  test 'plus characters inside single plus passthrough' do
-    assert_xpath '//p[text()="+"]', convert_string_to_embedded('+++')
-    assert_xpath '//p[text()="+="]', convert_string_to_embedded('++=+')
-  end
-
-  test 'plus passthrough escapes entity reference' do
-    assert_match(/&amp;#44;/, convert_string_to_embedded('+&#44;+'))
-    assert_match(/one&amp;#44;two/, convert_string_to_embedded('one++&#44;++two'))
-  end
-
-  context "basic styling" do
-    setup do
-      @output = convert_string("A *BOLD* word.  An _italic_ word.  A `mono` word.  ^superscript!^ and some ~subscript~.")
-    end
-
-    test "strong" do
-      assert_xpath "//strong", @output, 1
-    end
-
-    test "italic" do
-      assert_xpath "//em", @output, 1
-    end
-
-    test "monospaced" do
-      assert_xpath "//code", @output, 1
-    end
-
-    test "superscript" do
-      assert_xpath "//sup", @output, 1
-    end
-
-    test "subscript" do
-      assert_xpath "//sub", @output, 1
-    end
-
-    test "passthrough" do
-      assert_xpath "//code", convert_string("This is +passed through+."), 0
-      assert_xpath "//code", convert_string("This is +passed through and monospaced+.", :attributes => {'compat-mode' => ''}), 1
-    end
-
-    test "nested styles" do
-      output = convert_string("Winning *big _time_* in the +city *boyeeee*+.", :attributes => {'compat-mode' => ''})
-
-      assert_xpath "//strong/em", output
-      assert_xpath "//code/strong", output
-
-      output = convert_string("Winning *big _time_* in the `city *boyeeee*`.")
-
-      assert_xpath "//strong/em", output
-      assert_xpath "//code/strong", output
-    end
-
-    test 'unconstrained quotes' do
-      output = convert_string('**B**__I__++M++[role]++M++', :attributes => {'compat-mode' => ''})
-      assert_xpath '//strong', output, 1
-      assert_xpath '//em', output, 1
-      assert_xpath '//code[not(@class)]', output, 1
-      assert_xpath '//code[@class="role"]', output, 1
-
-      output = convert_string('**B**__I__``M``[role]``M``')
-      assert_xpath '//strong', output, 1
-      assert_xpath '//em', output, 1
-      assert_xpath '//code[not(@class)]', output, 1
-      assert_xpath '//code[@class="role"]', output, 1
-    end
-  end
-
-  test 'should format Asian characters as words' do
-    assert_xpath '//strong', (convert_string_to_embedded 'bold *要* bold')
-    assert_xpath '//strong', (convert_string_to_embedded 'bold *素* bold')
-    assert_xpath '//strong', (convert_string_to_embedded 'bold *要素* bold')
-  end
-end