blankslate 3.1.2 → 3.1.3

data/test/test_blankslate.rb

@@ -1,217 +0,0 @@
-#!/usr/bin/env ruby
-
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-require 'test/unit'
-require 'test/preload'
-require 'blankslate'
-require 'stringio'
-
-# Methods to be introduced into the Object class late.
-module LateObject
-  def late_object
-    33
-  end
-  def LateObject.included(mod)
-    # Modules defining an included method should not prevent blank
-    # slate erasure!
-  end
-end
-
-# Methods to be introduced into the Kernel module late.
-module LateKernel
-  def late_kernel
-    44
-  end
-  def LateKernel.included(mod)
-    # Modules defining an included method should not prevent blank
-    # slate erasure!
-  end
-end
-
-# Introduce some late methods (both module and direct) into the Kernel
-# module.
-module Kernel
-  include LateKernel
-
-  def late_addition
-    1234
-  end
-
-  def double_late_addition
-    11
-  end
-
-  def double_late_addition
-    22
-  end
-end
-
-
-# Introduce some late methods (both module and direct) into the Object
-# class.
-class Object
-  include LateObject
-  def another_late_addition
-    4321
-  end
-end
-
-# Introduce some late methods by inclusion.
-module GlobalModule
- def global_inclusion
-   42
- end
-end
-include GlobalModule
-
-def direct_global
-  43
-end
-
-######################################################################
-# Test case for blank slate.
-#
-class TestBlankSlate < Test::Unit::TestCase
-  def setup
-    @bs = BlankSlate.new
-  end
-
-  def test_undefined_methods_remain_undefined
-    assert_raise(NoMethodError) { @bs.no_such_method }
-    assert_raise(NoMethodError) { @bs.nil? }
-  end
-
-
-  # NOTE: NameError is acceptable because the lack of a '.' means that
-  # Ruby can't tell if it is a method or a local variable.
-  def test_undefined_methods_remain_undefined_during_instance_eval
-    assert_raise(NoMethodError, NameError)  do
-      @bs.instance_eval do nil? end
-    end
-    assert_raise(NoMethodError, NameError)  do
-      @bs.instance_eval do no_such_method end
-    end
-  end
-
-  def test_private_methods_are_undefined
-    assert_raise(NoMethodError) do
-      @bs.puts "HI"
-    end
-  end
-
-  def test_targetted_private_methods_are_undefined_during_instance_eval
-    assert_raise(NoMethodError, NameError) do
-      @bs.instance_eval do self.puts "HI" end
-    end
-  end
-
-  def test_untargetted_private_methods_are_defined_during_instance_eval
-    oldstdout = $stdout
-    $stdout = StringIO.new
-    @bs.instance_eval do
-      puts "HI"
-    end
-  ensure
-    $stdout = oldstdout
-  end
-
-  def test_methods_added_late_to_kernel_remain_undefined
-    assert_equal 1234, nil.late_addition
-    assert_raise(NoMethodError) { @bs.late_addition }
-  end
-
-  def test_methods_added_late_to_object_remain_undefined
-    assert_equal 4321, nil.another_late_addition
-    assert_raise(NoMethodError) { @bs.another_late_addition }
-  end
-
-  def test_methods_added_late_to_global_remain_undefined
-    assert_equal 42, global_inclusion
-    assert_raise(NoMethodError) { @bs.global_inclusion }
-  end
-
-  def test_preload_method_added
-    assert Kernel.k_added_names.include?(:late_addition)
-    assert Object.o_added_names.include?(:another_late_addition)
-  end
-
-  def test_method_defined_late_multiple_times_remain_undefined
-    assert_equal 22, nil.double_late_addition
-    assert_raise(NoMethodError) { @bs.double_late_addition }
-  end
-
-  def test_late_included_module_in_object_is_ok
-    assert_equal 33, 1.late_object
-    assert_raise(NoMethodError) { @bs.late_object }
-  end
-
-  def test_late_included_module_in_kernel_is_ok
-    assert_raise(NoMethodError) { @bs.late_kernel }
-  end
-
-  def test_revealing_previously_hidden_methods_are_callable
-    with_to_s = Class.new(BlankSlate) do
-      reveal :to_s
-    end
-    assert_match(/^#<.*>$/, with_to_s.new.to_s)
-  end
-
-  def test_revealing_previously_hidden_methods_are_callable_with_block
-    Object.class_eval <<-EOS
-      def given_block(&block)
-        block
-      end
-    EOS
-
-    with_given_block = Class.new(BlankSlate) do
-      reveal :given_block
-    end
-    assert_not_nil with_given_block.new.given_block {}
-  end
-
-  def test_revealing_a_hidden_method_twice_is_ok
-    with_to_s = Class.new(BlankSlate) do
-      reveal :to_s
-      reveal :to_s
-    end
-    assert_match(/^#<.*>$/, with_to_s.new.to_s)
-  end
-
-  def test_revealing_unknown_hidden_method_is_an_error
-    assert_raises(RuntimeError) do
-      Class.new(BlankSlate) do
-        reveal :xyz
-      end
-    end
-  end
-
-  def test_global_includes_still_work
-    assert_nothing_raised do
-      assert_equal 42, global_inclusion
-      assert_equal 42, Object.new.global_inclusion
-      assert_equal 42, "magic number".global_inclusion
-      assert_equal 43, direct_global
-    end
-  end
-
-  def test_reveal_should_not_bind_to_an_instance
-    with_object_id = Class.new(BlankSlate) do
-      reveal(:object_id)
-    end
-
-    obj1 = with_object_id.new
-    obj2 = with_object_id.new
-
-    assert obj1.object_id != obj2.object_id,
-       "Revealed methods should not be bound to a particular instance"
-  end
-end

data/test/test_eventbuilder.rb

@@ -1,150 +0,0 @@
-#!/usr/bin/env ruby
-
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-require 'test/unit'
-require 'test/preload'
-require 'builder'
-require 'builder/xmlevents'
-
-class TestEvents < Test::Unit::TestCase
-
-  class Target
-    attr_reader :events
-
-    def initialize
-      @events = []
-    end
-
-    def start_tag(tag, attrs)
-      @events << [:start_tag, tag, attrs]
-    end
-
-    def end_tag(tag)
-      @events << [:end_tag, tag]
-    end
-    
-    def text(string)
-      @events << [:text, string]
-    end
-    
-  end
-
-
-  def setup
-    @target = Target.new
-    @xml = Builder::XmlEvents.new(:target=>@target)
-  end
-
-  def test_simple
-    @xml.one
-    expect [:start_tag, :one, nil]
-    expect [:end_tag, :one]
-    expect_done
-  end
-
-  def test_nested
-    @xml.one { @xml.two }
-    expect [:start_tag, :one, nil]
-    expect [:start_tag, :two, nil]
-    expect [:end_tag, :two]
-    expect [:end_tag, :one]
-    expect_done
-  end
-
-  def test_text
-    @xml.one("a")
-    expect [:start_tag, :one, nil]
-    expect [:text, "a"]
-    expect [:end_tag, :one]
-    expect_done
-  end
-
-  def test_special_text
-    @xml.one("H&R")
-    expect [:start_tag, :one, nil]
-    expect [:text, "H&R"]
-    expect [:end_tag, :one]
-    expect_done
-  end
-
-  def test_text_with_entity
-    @xml.one("H&amp;R")
-    expect [:start_tag, :one, nil]
-    expect [:text, "H&amp;R"]
-    expect [:end_tag, :one]
-    expect_done
-  end
-
-  def test_attributes
-    @xml.a(:b=>"c", :x=>"y")
-    expect [:start_tag, :a, {:x => "y", :b => "c"}]
-    expect [:end_tag, :a]
-    expect_done
-  end
-
-  def test_moderately_complex
-    @xml.tag! "address-book" do |x|
-      x.entry :id=>"1" do
-	x.name {
-	  x.first "Bill"
-	  x.last "Smith"
-	}
-	x.address "Cincinnati"
-      end
-      x.entry :id=>"2" do
-	x.name {
-	  x.first "John"
-	  x.last "Doe"
-	}
-	x.address "Columbus"
-      end
-    end
-    expect [:start_tag, "address-book".intern, nil]
-    expect [:start_tag, :entry, {:id => "1"}]
-    expect [:start_tag, :name, nil]
-    expect [:start_tag, :first, nil]
-    expect [:text, "Bill"]
-    expect [:end_tag, :first]
-    expect [:start_tag, :last, nil]
-    expect [:text, "Smith"]
-    expect [:end_tag, :last]
-    expect [:end_tag, :name]
-    expect [:start_tag, :address, nil]
-    expect [:text, "Cincinnati"]
-    expect [:end_tag, :address]
-    expect [:end_tag, :entry]
-    expect [:start_tag, :entry, {:id => "2"}]
-    expect [:start_tag, :name, nil]
-    expect [:start_tag, :first, nil]
-    expect [:text, "John"]
-    expect [:end_tag, :first]
-    expect [:start_tag, :last, nil]
-    expect [:text, "Doe"]
-    expect [:end_tag, :last]
-    expect [:end_tag, :name]
-    expect [:start_tag, :address, nil]
-    expect [:text, "Columbus"]
-    expect [:end_tag, :address]
-    expect [:end_tag, :entry]
-    expect [:end_tag, "address-book".intern]
-    expect_done
-  end
-
-  def expect(value)
-    assert_equal value, @target.events.shift
-  end
-
-  def expect_done
-    assert_nil @target.events.shift
-  end
-
-end

data/test/test_markupbuilder.rb

@@ -1,573 +0,0 @@
-#!/usr/bin/env ruby
-
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-require 'test/unit'
-require 'test/preload'
-require 'builder'
-require 'builder/xmlmarkup'
-
-class TestMarkup < Test::Unit::TestCase
-  def setup
-    @xml = Builder::XmlMarkup.new
-  end
-
-  def test_create
-    assert_not_nil @xml
-  end
-
-  def test_simple
-    @xml.simple
-    assert_equal "<simple/>", @xml.target!
-  end
-
-  def test_value
-    @xml.value("hi")
-    assert_equal "<value>hi</value>", @xml.target!
-  end
-
-  def test_empty_value
-    @xml.value("")
-    assert_equal "<value/>", @xml.target!
-  end
-
-  def test_nil_value
-    @xml.value(nil)
-    assert_equal "<value/>", @xml.target!
-  end
-
-  def test_nested
-    @xml.outer { |x| x.inner("x") }
-    assert_equal "<outer><inner>x</inner></outer>", @xml.target!
-  end
-
-  def test_attributes
-    @xml.ref(:id => 12)
-    assert_equal %{<ref id="12"/>}, @xml.target!
-  end
-
-  def test_string_attributes_are_quoted_by_default
-    @xml.ref(:id => "H&R")
-    assert_equal %{<ref id="H&amp;R"/>}, @xml.target!
-  end
-
-  def test_symbol_attributes_are_unquoted_by_default
-    @xml.ref(:id => :"H&amp;R")
-    assert_equal %{<ref id="H&amp;R"/>}, @xml.target!
-  end
-
-  def test_attributes_quoted_can_be_turned_on
-    @xml = Builder::XmlMarkup.new
-    @xml.ref(:id => "<H&R \"block\">")
-    assert_equal %{<ref id="&lt;H&amp;R &quot;block&quot;&gt;"/>}, @xml.target!
-  end
-
-  def test_mixed_attribute_quoting_with_nested_builders
-    x = Builder::XmlMarkup.new(:target=>@xml)
-    @xml.ref(:id=>:"H&amp;R") {
-      x.element(:tag=>"Long&Short")
-    }
-    assert_equal "<ref id=\"H&amp;R\"><element tag=\"Long&amp;Short\"/></ref>",
-      @xml.target!
-  end
-
-  def test_multiple_attributes
-    @xml.ref(:id => 12, :name => "bill")
-    assert_match %r{^<ref( id="12"| name="bill"){2}/>$}, @xml.target!
-  end
-
-  def test_attributes_with_text
-    @xml.a("link", :href=>"http://onestepback.org")
-    assert_equal %{<a href="http://onestepback.org">link</a>}, @xml.target!
-  end
-
-  def test_attributes_with_newlines
-    @xml.abbr("W3C", :title=>"World\nWide\rWeb\r\nConsortium")
-    assert_equal %{<abbr title="World&#10;Wide&#13;Web&#13;&#10;Consortium">W3C</abbr>},
-      @xml.target!
-  end
-
-  def test_complex
-    @xml.body(:bg=>"#ffffff") { |x|
-      x.title("T", :style=>"red")
-    }
-    assert_equal %{<body bg="#ffffff"><title style="red">T</title></body>}, @xml.target!
-  end
-
-  def test_funky_symbol
-    @xml.tag!("non-ruby-token", :id=>1) { |x| x.ok }
-    assert_equal %{<non-ruby-token id="1"><ok/></non-ruby-token>}, @xml.target!
-  end
-
-  def test_tag_can_handle_private_method
-    @xml.tag!("loop", :id=>1) { |x| x.ok }
-    assert_equal %{<loop id="1"><ok/></loop>}, @xml.target!
-  end
-
-  def test_no_explicit_marker
-    @xml.p { |x| x.b("HI") }
-    assert_equal "<p><b>HI</b></p>", @xml.target!
-  end
-
-  def test_reference_local_vars
-    n = 3
-    @xml.ol { |x| n.times { x.li(n) } }
-    assert_equal "<ol><li>3</li><li>3</li><li>3</li></ol>", @xml.target!
-  end
-
-  def test_reference_methods
-    @xml.title { |x| x.a { x.b(name) } }
-    assert_equal "<title><a><b>bob</b></a></title>", @xml.target!
-  end
-
-  def test_append_text
-    @xml.p { |x| x.br; x.text! "HI" }
-    assert_equal "<p><br/>HI</p>", @xml.target!
-  end
-
-  def test_ambiguous_markup
-    ex = assert_raise(ArgumentError) {
-      @xml.h1("data1") { b }
-    }
-    assert_match(/\btext\b/, ex.message)
-    assert_match(/\bblock\b/, ex.message)
-  end
-
-  def test_capitalized_method
-    @xml.P { |x| x.B("hi"); x.BR(); x.EM { x.text! "world" } }
-    assert_equal "<P><B>hi</B><BR/><EM>world</EM></P>", @xml.target!
-  end
-
-  def test_escaping
-    @xml.div { |x| x.text! "<hi>"; x.em("H&R Block") }
-    assert_equal %{<div>&lt;hi&gt;<em>H&amp;R Block</em></div>}, @xml.target!
-  end
-
-  def test_non_escaping
-    @xml.div("ns:xml"=>:"&xml;") { |x| x << "<h&i>"; x.em("H&R Block") }
-    assert_equal %{<div ns:xml="&xml;"><h&i><em>H&amp;R Block</em></div>}, @xml.target!
-  end
-
-  def test_return_value
-    str = @xml.x("men")
-    assert_equal @xml.target!, str
-  end
-
-  def test_stacked_builders
-    b = Builder::XmlMarkup.new( :target => @xml )
-    b.div { @xml.span { @xml.a("text", :href=>"ref") } }
-    assert_equal "<div><span><a href=\"ref\">text</a></span></div>", @xml.target!
-  end
-
-  def name
-    "bob"
-  end
-end
-
-class TestAttributeEscaping < Test::Unit::TestCase
-
-  def setup
-    @xml = Builder::XmlMarkup.new
-  end
-
-  def test_element_gt
-    @xml.title('1<2')
-    assert_equal '<title>1&lt;2</title>', @xml.target!
-  end
-
-  def test_element_amp
-    @xml.title('AT&T')
-    assert_equal '<title>AT&amp;T</title>', @xml.target!
-  end
-
-  def test_element_amp2
-    @xml.title('&amp;')
-    assert_equal '<title>&amp;amp;</title>', @xml.target!
-  end
-
-  def test_attr_less
-    @xml.a(:title => '2>1')
-    assert_equal '<a title="2&gt;1"/>', @xml.target!
-  end
-
-  def test_attr_amp
-    @xml.a(:title => 'AT&T')
-    assert_equal '<a title="AT&amp;T"/>', @xml.target!
-  end
-
-  def test_attr_quot
-    @xml.a(:title => '"x"')
-    assert_equal '<a title="&quot;x&quot;"/>', @xml.target!
-  end
-
-end
-
-class TestNameSpaces < Test::Unit::TestCase
-  def setup
-    @xml = Builder::XmlMarkup.new(:indent=>2)
-  end
-
-  def test_simple_name_spaces
-    @xml.rdf :RDF
-    assert_equal "<rdf:RDF/>\n", @xml.target!
-  end
-
-  def test_long
-    xml = Builder::XmlMarkup.new(:indent=>2)
-    xml.instruct!
-    xml.rdf :RDF,
-      "xmlns:rdf" => :"&rdf;",
-      "xmlns:rdfs" => :"&rdfs;",
-      "xmlns:xsd" => :"&xsd;",
-      "xmlns:owl" => :"&owl;" do
-      xml.owl :Class, :'rdf:ID'=>'Bird' do
-	xml.rdfs :label, 'bird'
-	xml.rdfs :subClassOf do
-	  xml.owl :Restriction do
-	    xml.owl :onProperty, 'rdf:resource'=>'#wingspan'
-	    xml.owl :maxCardinality,1,'rdf:datatype'=>'&xsd;nonNegativeInteger'
-	  end
-	end
-      end
-    end
-    assert_match(/^<\?xml/, xml.target!)
-    assert_match(/\n<rdf:RDF/m, xml.target!)
-    assert_match(/xmlns:rdf="&rdf;"/m, xml.target!)
-    assert_match(/<owl:Restriction>/m, xml.target!)
-  end
-
-  def test_ensure
-    xml = Builder::XmlMarkup.new
-    xml.html do
-      xml.body do
-       begin
-         xml.p do
-           raise Exception.new('boom')
-         end
-       rescue Exception => e
-         xml.pre e
-       end
-      end
-    end
-    assert_match %r{<p>},  xml.target!
-    assert_match %r{</p>}, xml.target!
-  end
-end
-
-class TestDeclarations < Test::Unit::TestCase
-  def setup
-    @xml = Builder::XmlMarkup.new(:indent=>2)
-  end
-
-  def test_declare
-    @xml.declare! :element
-    assert_equal "<!element>\n", @xml.target!
-  end
-
-  def test_bare_arg
-    @xml.declare! :element, :arg
-    assert_equal"<!element arg>\n", @xml.target!
-  end
-
-  def test_string_arg
-    @xml.declare! :element, "string"
-    assert_equal"<!element \"string\">\n", @xml.target!
-  end
-
-  def test_mixed_args
-    @xml.declare! :element, :x, "y", :z, "-//OASIS//DTD DocBook XML//EN"
-    assert_equal "<!element x \"y\" z \"-//OASIS//DTD DocBook XML//EN\">\n", @xml.target!
-  end
-
-  def test_nested_declarations
-    @xml = Builder::XmlMarkup.new
-    @xml.declare! :DOCTYPE, :chapter do |x|
-      x.declare! :ELEMENT, :chapter, "(title,para+)".intern
-    end
-    assert_equal "<!DOCTYPE chapter [<!ELEMENT chapter (title,para+)>]>", @xml.target!
-  end
-
-  def test_nested_indented_declarations
-    @xml.declare! :DOCTYPE, :chapter do |x|
-      x.declare! :ELEMENT, :chapter, "(title,para+)".intern
-    end
-    assert_equal "<!DOCTYPE chapter [\n  <!ELEMENT chapter (title,para+)>\n]>\n", @xml.target!
-  end
-
-  def test_complex_declaration
-    @xml.declare! :DOCTYPE, :chapter do |x|
-      x.declare! :ELEMENT, :chapter, "(title,para+)".intern
-      x.declare! :ELEMENT, :title, "(#PCDATA)".intern
-      x.declare! :ELEMENT, :para, "(#PCDATA)".intern
-    end
-    expected = %{<!DOCTYPE chapter [
-  <!ELEMENT chapter (title,para+)>
-  <!ELEMENT title (#PCDATA)>
-  <!ELEMENT para (#PCDATA)>
-]>
-}
-    assert_equal expected, @xml.target!
-  end
-end
-
-
-class TestSpecialMarkup < Test::Unit::TestCase
-  def setup
-    @xml = Builder::XmlMarkup.new(:indent=>2)
-  end
-
-  def test_comment
-    @xml.comment!("COMMENT")
-    assert_equal "<!-- COMMENT -->\n", @xml.target!
-  end
-
-  def test_indented_comment
-    @xml.p { @xml.comment! "OK" }
-    assert_equal "<p>\n  <!-- OK -->\n</p>\n", @xml.target!
-  end
-
-  def test_instruct
-    @xml.instruct! :abc, :version=>"0.9"
-    assert_equal "<?abc version=\"0.9\"?>\n", @xml.target!
-  end
-
-  def test_indented_instruct
-    @xml.p { @xml.instruct! :xml }
-    assert_match %r{<p>\n  <\?xml version="1.0" encoding="UTF-8"\?>\n</p>\n},
-      @xml.target!
-  end
-
-  def test_instruct_without_attributes
-    @xml.instruct! :zz
-    assert_equal "<?zz?>\n", @xml.target!
-  end
-
-  def test_xml_instruct
-    @xml.instruct!
-    assert_match(/^<\?xml version="1.0" encoding="UTF-8"\?>$/, @xml.target!)
-  end
-
-  def test_xml_instruct_with_overrides
-    @xml.instruct! :xml, :encoding=>"UCS-2"
-    assert_match(/^<\?xml version="1.0" encoding="UCS-2"\?>$/, @xml.target!)
-  end
-
-  def test_xml_instruct_with_standalong
-    @xml.instruct! :xml, :encoding=>"UCS-2", :standalone=>"yes"
-    assert_match(/^<\?xml version="1.0" encoding="UCS-2" standalone="yes"\?>$/, @xml.target!)
-  end
-
-  def test_no_blocks
-    assert_raise(Builder::IllegalBlockError) do
-      @xml.instruct! { |x| x.hi }
-    end
-    assert_raise(Builder::IllegalBlockError) do
-      @xml.comment!(:element) { |x| x.hi }
-    end
-  end
-
-  def test_cdata
-    @xml.cdata!("TEST")
-    assert_equal "<![CDATA[TEST]]>\n", @xml.target!
-  end
-
-  def test_cdata_with_ampersand
-    @xml.cdata!("TEST&CHECK")
-    assert_equal "<![CDATA[TEST&CHECK]]>\n", @xml.target!
-  end
-
-  def test_cdata_with_included_close
-    @xml.cdata!("TEST]]>CHECK")
-    assert_equal "<![CDATA[TEST]]]]><![CDATA[>CHECK]]>\n", @xml.target!
-  end
-end
-
-class TestIndentedXmlMarkup < Test::Unit::TestCase
-  def setup
-    @xml = Builder::XmlMarkup.new(:indent=>2)
-  end
-
-  def test_one_level
-    @xml.ol { |x| x.li "text" }
-    assert_equal "<ol>\n  <li>text</li>\n</ol>\n", @xml.target!
-  end
-
-  def test_two_levels
-    @xml.p { |x|
-      x.ol { x.li "text" }
-      x.br
-    }
-    assert_equal "<p>\n  <ol>\n    <li>text</li>\n  </ol>\n  <br/>\n</p>\n", @xml.target!
-  end
-
-  def test_initial_level
-    @xml = Builder::XmlMarkup.new(:indent=>2, :margin=>4)
-    @xml.name { |x| x.first("Jim") }
-    assert_equal "        <name>\n          <first>Jim</first>\n        </name>\n", @xml.target!
-  end
-
-  class TestUtfMarkup < Test::Unit::TestCase
-    if ! String.method_defined?(:encode)
-      def setup
-        @old_kcode = $KCODE
-      end
-
-      def teardown
-        $KCODE = @old_kcode
-      end
-
-      def test_use_entities_if_no_encoding_is_given_and_kcode_is_none
-        $KCODE = 'NONE'
-        xml = Builder::XmlMarkup.new
-        xml.p("\xE2\x80\x99")
-        assert_match(%r(<p>&#8217;</p>), xml.target!) #
-      end
-
-      def test_use_entities_if_encoding_is_utf_but_kcode_is_not
-        $KCODE = 'NONE'
-        xml = Builder::XmlMarkup.new
-        xml.instruct!(:xml, :encoding => 'UTF-8')
-        xml.p("\xE2\x80\x99")
-        assert_match(%r(<p>&#8217;</p>), xml.target!) #
-      end
-    else
-      # change in behavior.  As there is no $KCODE anymore, the default
-      # moves from "does not understand utf-8" to "supports utf-8".
-
-      def test_use_entities_if_no_encoding_is_given_and_kcode_is_none
-        xml = Builder::XmlMarkup.new
-        xml.p("\xE2\x80\x99")
-        assert_match("<p>\u2019</p>", xml.target!) #
-      end
-
-      def test_use_entities_if_encoding_is_utf_but_kcode_is_not
-        xml = Builder::XmlMarkup.new
-        xml.instruct!(:xml, :encoding => 'UTF-8')
-        xml.p("\xE2\x80\x99")
-        assert_match("<p>\u2019</p>", xml.target!) #
-      end
-    end
-
-    def encode string, encoding
-      if !String.method_defined?(:encode)
-        $KCODE = encoding
-        string
-      elsif encoding == 'UTF8'
-        string.force_encoding('UTF-8')
-      else
-        string
-      end
-    end
-
-    def test_use_entities_if_kcode_is_utf_but_encoding_is_dummy_encoding
-      xml = Builder::XmlMarkup.new
-      xml.instruct!(:xml, :encoding => 'UTF-16')
-      xml.p(encode("\xE2\x80\x99", 'UTF8'))
-      assert_match(%r(<p>&#8217;</p>), xml.target!) #
-    end
-
-    def test_use_entities_if_kcode_is_utf_but_encoding_is_unsupported_encoding
-      xml = Builder::XmlMarkup.new
-      xml.instruct!(:xml, :encoding => 'UCS-2')
-      xml.p(encode("\xE2\x80\x99", 'UTF8'))
-      assert_match(%r(<p>&#8217;</p>), xml.target!) #
-    end
-
-    def test_use_utf8_if_encoding_defaults_and_kcode_is_utf8
-      xml = Builder::XmlMarkup.new
-      xml.p(encode("\xE2\x80\x99",'UTF8'))
-      assert_equal encode("<p>\xE2\x80\x99</p>",'UTF8'), xml.target!
-    end
-
-    def test_use_utf8_if_both_encoding_and_kcode_are_utf8
-      xml = Builder::XmlMarkup.new
-      xml.instruct!(:xml, :encoding => 'UTF-8')
-      xml.p(encode("\xE2\x80\x99",'UTF8'))
-      assert_match encode("<p>\xE2\x80\x99</p>",'UTF8'), xml.target!
-    end
-
-    def test_use_utf8_if_both_encoding_and_kcode_are_utf8_with_lowercase
-      xml = Builder::XmlMarkup.new
-      xml.instruct!(:xml, :encoding => 'utf-8')
-      xml.p(encode("\xE2\x80\x99",'UTF8'))
-      assert_match encode("<p>\xE2\x80\x99</p>",'UTF8'), xml.target!
-    end
-  end
-
-  class TestXmlEvents < Test::Unit::TestCase
-    def setup
-      @handler = EventHandler.new
-      @xe = Builder::XmlEvents.new(:target=>@handler)
-    end
-
-    def test_simple
-      @xe.p
-      assert_equal [:start, :p, nil], @handler.events.shift
-      assert_equal [:end, :p], @handler.events.shift
-    end
-
-    def test_text
-      @xe.p("HI")
-      assert_equal [:start, :p, nil], @handler.events.shift
-      assert_equal [:text, "HI"], @handler.events.shift
-      assert_equal [:end, :p], @handler.events.shift
-    end
-
-    def test_attributes
-      @xe.p("id"=>"2")
-      ev = @handler.events.shift
-      assert_equal [:start, :p], ev[0,2]
-      assert_equal "2", ev[2]['id']
-      assert_equal [:end, :p], @handler.events.shift
-    end
-
-    def test_indented
-      @xml = Builder::XmlEvents.new(:indent=>2, :target=>@handler)
-      @xml.p { |x| x.b("HI") }
-      assert_equal [:start, :p, nil], @handler.events.shift
-      assert_equal "\n  ", pop_text
-      assert_equal [:start, :b, nil], @handler.events.shift
-      assert_equal "HI", pop_text
-      assert_equal [:end, :b], @handler.events.shift
-      assert_equal "\n", pop_text
-      assert_equal [:end, :p], @handler.events.shift
-    end
-
-    def pop_text
-      result = ''
-      while ! @handler.events.empty? && @handler.events[0][0] == :text
-	result << @handler.events[0][1]
-	@handler.events.shift
-      end
-      result
-    end
-
-    class EventHandler
-      attr_reader :events
-      def initialize
-	@events = []
-      end
-
-      def start_tag(sym, attrs)
-	@events << [:start, sym, attrs]
-      end
-
-      def end_tag(sym)
-	@events << [:end, sym]
-      end
-
-      def text(txt)
-	@events << [:text, txt]
-      end
-    end
-  end
-
-end