xamplr 1.2.0

data/lib/xamplr/handwritten/test-handwritten.rb

@@ -0,0 +1,873 @@
+#!/usr/bin/env ruby
+
+require "test/unit"
+
+require "xamplr-generator"
+require "example"
+
+include XamplGenerator
+include Xampl
+include XamplExample
+
+class TestXampl < Test::Unit::TestCase
+
+  def test_simple_xampl
+    emph1 = Emph.new
+    assert_not_nil(emph1.is_changed)
+    emph2 = Emph.new
+    assert_not_nil(emph2.is_changed)
+    emph3 = Emph.new
+    assert_not_nil(emph3.is_changed)
+
+    emph1.content = "emph 1"
+    assert_not_nil(emph1.is_changed)
+    emph2.content = "emph 2"
+    assert_not_nil(emph2.is_changed)
+
+    assert_equal("emph 1", emph1.content)
+    assert_equal("emph 2", emph2.content)
+
+    assert_equal("<ns0:emph xmlns:ns0='http://xampl.com/example'>emph 1</ns0:emph>", emph1.to_xml)
+    assert_equal("<ns0:emph xmlns:ns0='http://xampl.com/example'>emph 2</ns0:emph>", emph2.to_xml)
+    assert_equal("<ns0:emph xmlns:ns0='http://xampl.com/example'/>", emph3.to_xml)
+
+    fakeRules = XMLPrinter.new("fake...")
+    emph1.to_xml_internal(fakeRules)
+    r = fakeRules.done
+
+    assert_equal("fake... xmlns:ns0='http://xampl.com/example'<ns0:emph>emph 1</ns0:emph>", r)
+
+    assert_not_nil(emph1.is_changed)
+    assert_not_nil(emph2.is_changed)
+    assert_not_nil(emph3.is_changed)
+
+    check_parents(emph1)
+    check_parents(emph2)
+    check_parents(emph3)
+  end
+
+  def test_empty_xampl
+    stuff1 = Stuff.new
+    assert_not_nil(stuff1.is_changed)
+    stuff1.kind = 'test'
+    assert_not_nil(stuff1.is_changed)
+
+    stuff2 = Stuff.new
+    assert_not_nil(stuff2.is_changed)
+
+    stuff3 = Stuff.new
+    assert_not_nil(stuff3.is_changed)
+    stuff3.kind = 'test'
+    assert_not_nil(stuff3.is_changed)
+    stuff3.special = 'test'
+    assert_not_nil(stuff3.is_changed)
+
+    assert_equal("<ns1:stuff kind='test' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+    assert_equal("<ns1:stuff xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff2.to_xml)
+    assert_equal("<ns1:stuff kind='test' ns0:special='test' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff3.to_xml)
+
+    fakeRules = XMLPrinter.new("fake...")
+    stuff1.to_xml_internal(fakeRules)
+    r = fakeRules.done
+    assert_equal("fake... xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'<ns1:stuff kind='test'/>", r)
+
+    check_parents(stuff1)
+    check_parents(stuff2)
+    check_parents(stuff3)
+  end
+
+  def test_mixed_xampl
+    desc1 = Description.new
+    assert_not_nil(desc1.is_changed)
+    desc1.kind = "desc1"
+    assert_not_nil(desc1.is_changed)
+    assert_equal("<ns0:description kind='desc1' xmlns:ns0='http://xampl.com/example'/>",
+                 desc1.to_xml)
+
+    desc1.add_content("hello ")
+    emph_content_1 = "there"
+    desc1.new_emph.content = emph_content_1
+    desc1.add_content("! How ")
+    emph_content_2 = "are"
+    desc1.new_emph.content = emph_content_2
+    desc1.add_content(" you?")
+
+    assert_not_nil(desc1.is_changed)
+    assert_equal("<ns0:description kind='desc1' xmlns:ns0='http://xampl.com/example'>hello <ns0:emph>there</ns0:emph>! How <ns0:emph>are</ns0:emph> you?</ns0:description>",
+                 desc1.to_xml)
+    assert_equal(desc1.emph_child.length, 2)
+    assert_equal(emph_content_1, desc1.emph_child[0].content, emph_content_1)
+    assert_equal(emph_content_2, desc1.emph_child[1].content, emph_content_2)
+
+    check_parents(desc1)
+  end
+
+  def test_data_xampl
+    emph_content_1 = "there"
+    emph_content_2 = "are"
+    big_thing = Xampl.make(Thing){ | big_thing |
+      big_thing.new_thing("thing"){ | thing |
+        thing.new_stuff.kind = "stuff1"
+
+        thing.new_description{ | desc |
+          desc.kind = "desc1"
+
+          desc.add_content("hello ")
+          desc.new_emph.content = emph_content_1
+          desc.add_content("! How ")
+          desc.new_emph.content = emph_content_2
+          desc.add_content(" you?")
+        }
+      }
+    }
+
+    ###    desc1 = Description.new
+    ###    desc1.kind = "desc1"
+    ###
+    ###    desc1.add_content("hello ")
+    ###		emph_content_1 = "there"
+    ###    desc1.new_emph.content = emph_content_1
+    ###    desc1.add_content("! How ")
+    ###		emph_content_2 = "are"
+    ###    desc1.new_emph.content = emph_content_2
+    ###    desc1.add_content(" you?")
+    ###
+    ###    thing = Thing.new
+    ###		thing.pid = "thing"
+    ###		assert(thing.is_changed)
+    ###    thing.new_stuff.kind = "stuff1"
+    ###		assert_not_nil(thing.is_changed)
+    ###		thing.is_changed = nil
+    ###    thing.add_description(desc1)
+    ###		assert_not_nil(thing.is_changed)
+    ###
+    ###    big_thing = Thing.new
+    ###    big_thing.add_thing(thing)
+    assert_equal("<ns0:thing xmlns:ns0='http://xampl.com/example' xmlns:ns1='http://xampl.com/example/special'><ns0:thing pid='thing'><ns0:stuff kind='stuff1'/><ns0:description kind='desc1'>hello <ns0:emph>there</ns0:emph>! How <ns0:emph>are</ns0:emph> you?</ns0:description></ns0:thing></ns0:thing>",
+                 big_thing.to_xml)
+
+    assert_equal(1, big_thing.children.length)
+    assert_equal(2, big_thing.thing_child[0].children.length)
+    assert_equal(big_thing.thing_child[0].description_child[0].emph_child.length, 2)
+    assert_equal(emph_content_1, big_thing.thing_child[0].description_child[0].emph_child[0].content, emph_content_1)
+    assert_equal(emph_content_2, big_thing.thing_child[0].description_child[0].emph_child[1].content, emph_content_2)
+
+    check_parents(big_thing)
+  end
+
+  def test_data_xampl_using_append
+    emph_content_1 = "there"
+    emph1 = Emph.new
+    emph1 << emph_content_1
+
+    emph_content_2 = "are"
+    emph2 = Emph.new
+    emph2.content = emph_content_2
+
+    desc1 = Description.new
+    desc1.kind = "desc1"
+
+    desc1.is_changed = nil
+    desc1 << "hello " << emph1 << "! How " << emph2 << " you?"
+    assert_not_nil(desc1.is_changed)
+
+    thing = Thing.new
+    thing.pid = "thing"
+    thing.new_stuff.kind = "stuff1"
+    thing << desc1
+
+    big_thing = Thing.new
+    big_thing << thing
+
+    assert_equal("<ns0:thing xmlns:ns0='http://xampl.com/example' xmlns:ns1='http://xampl.com/example/special'><ns0:thing pid='thing'><ns0:stuff kind='stuff1'/><ns0:description kind='desc1'>hello <ns0:emph>there</ns0:emph>! How <ns0:emph>are</ns0:emph> you?</ns0:description></ns0:thing></ns0:thing>",
+                 big_thing.to_xml)
+
+    assert_equal(2, big_thing.thing_child[0].description_child[0].emph_child.length)
+    assert_equal(emph_content_1, big_thing.thing_child[0].description_child[0].emph_child[0].content)
+    assert_equal(emph_content_2, big_thing.thing_child[0].description_child[0].emph_child[1].content)
+
+    check_parents(big_thing)
+  end
+
+  def test_from_xml
+    emph_content_1 = "there"
+    emph1 = Emph.new
+    emph1 << emph_content_1
+
+    emph_content_2 = "are"
+    emph2 = Emph.new
+    emph2.content = emph_content_2
+
+    desc1 = Description.new
+    desc1.kind = "desc1"
+
+    desc1.is_changed = nil
+    desc1 << "hello " << emph1 << "! How " << emph2 << " you?"
+
+    thing = Thing.new
+    thing.pid = "thing"
+    thing.new_stuff.kind = "stuff1"
+    thing << desc1
+
+    big_thing = Thing.new
+    big_thing << "leading content" << thing << "trailing content"
+
+    #puts big_thing.to_xml
+    #pp = FromXML.new
+    #pp.setup_parse_string(big_thing.to_xml)
+    #while not pp.endDocument?
+    #event = pp.next_interesting_event
+    #puts event
+    #if (event == Xampl_PP::TEXT) then
+    #puts "TEXT [[[" << pp.text << "]]]"
+    #end
+    #end
+
+    pp = FromXML.new
+    pp.setup_parse_string(big_thing.to_xml)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::START_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::TEXT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_ELEMENT)
+    assert_equal(pp.next_interesting_event, Xampl_PP::END_DOCUMENT)
+    assert(pp.endDocument?)
+
+    pp = FromXML.new
+    another_big_thing = pp.parse_string(big_thing.to_xml)
+    assert_equal(big_thing.to_xml, another_big_thing.to_xml)
+  end
+
+  def test_index
+    thing = Thing.new
+    thing.new_key_value("one").value = "1"
+    thing.new_key_value("two").value = "2"
+
+    assert_equal(thing.key_value_child[0], thing.key_value_map["one"])
+    assert_equal(thing.key_value_child[1], thing.key_value_map["two"])
+
+    check_parents(thing)
+  end
+
+  def test_parents
+    thing = Thing.new
+    (kv1 = thing.new_key_value("one")).value = "1"
+    (kv2 = thing.new_key_value("two")).value = "2"
+
+    assert_equal(thing, thing.key_value_child[0].parents[0])
+    assert_equal(thing, thing.key_value_child[1].parents[0])
+
+    another_thing = Thing.new
+    another_thing << kv1 << kv2
+
+    assert_equal(2, kv1.parents.size)
+    assert_equal(2, kv2.parents.size)
+
+    check_parents(thing)
+    check_parents(another_thing)
+  end
+
+  def test_non_string_attributes
+    stuff1 = Stuff.new
+
+    stuff1.kind = 123.456
+    assert_equal("<ns1:stuff kind='123.456' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+
+    stuff1.kind = nil
+    assert_equal("<ns1:stuff xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+
+    stuff1.kind = [1, 2, 3]
+    assert_equal("<ns1:stuff kind='123' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+
+    stuff2 = Stuff.new
+    stuff2.kind = 123
+    stuff1.kind = stuff2
+    assert_equal("<ns1:stuff kind='&lt;ns1:stuff kind=&apos;123&apos; xmlns:ns1=&apos;http://xampl.com/example&apos; xmlns:ns0=&apos;http://xampl.com/example/special&apos;/&gt;' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff2
+    stuff1.kind = thing
+    # TODO -- check what happens with a PIDed thing
+    assert_equal("<ns1:stuff kind='&lt;ns0:thing pid=&apos;thing&apos; xmlns:ns0=&apos;http://xampl.com/example&apos; xmlns:ns1=&apos;http://xampl.com/example/special&apos;&gt;&lt;ns0:stuff kind=&apos;123&apos;/&gt;&lt;/ns0:thing&gt;' xmlns:ns1='http://xampl.com/example' xmlns:ns0='http://xampl.com/example/special'/>",
+                 stuff1.to_xml)
+
+    # TODO -- check round tripping of this stuff
+    check_parents(stuff1)
+  end
+
+  def test_registry
+    assert_equal([ Emph ], FromXML::registered(Emph::ns_tag))
+    assert_equal([ Emph ], FromXML::registered(Emph::tag))
+    assert_equal([ Stuff ], FromXML::registered(Stuff::ns_tag))
+    assert_equal([ Stuff ], FromXML::registered(Stuff::tag))
+
+    FromXML::register(Emph::tag, Emph::ns_tag, Emph)
+    assert_equal([ Emph ], FromXML::registered(Emph::ns_tag))
+    assert_equal([ Emph ], FromXML::registered(Emph::tag))
+
+    FromXML::register(Emph::tag, Thing::ns_tag, Thing)
+    assert_equal([ Emph ], FromXML::registered(Emph::ns_tag))
+    assert_equal([ Emph, Thing ], FromXML::registered(Emph::tag))
+  end
+
+  def test_in_memory_persistence_basics
+    stuff = Stuff.new
+    thing = Thing.new
+    thing << stuff
+
+    assert(!stuff.persist_required)
+    assert(thing.persist_required)
+    assert(nil == thing.persister)
+
+    persister = InMemoryPersister.new
+
+    assert(!persister.write(thing))
+
+    thing.pid = "thing"
+
+    assert(persister.write(thing))
+
+    saved_thing = persister.read(Thing, "thing")
+    assert(saved_thing)
+
+    assert_equal(thing.to_xml, saved_thing.to_xml)
+
+    Xampl.in_memory_persister("first")
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    assert_nil(Xampl.lookup(Thing, "thing"))
+
+    assert(nil == thing.persister)
+    assert(thing.is_changed)
+    assert(0 == Xampl.count_changed)
+    Xampl.introduce_to_persister(thing)
+    assert(thing.persister)
+    assert_equal(1, Xampl.count_changed)
+    assert_equal(thing, Xampl.lookup(Thing, "thing"), "cannot lookup new stuff")
+
+    #Xampl.print_stats
+
+    assert_equal(1, Xampl.count_changed)
+    writes = Xampl.sync
+    assert_equal(1, writes)
+    assert_equal(0, Xampl.count_changed)
+    assert(Xampl.lookup(Thing, "thing"))
+
+    assert_equal(thing, Xampl.lookup(Thing, "thing"), "cannot lookup cached stuff")
+
+    Xampl.clear_cache
+
+    found = Xampl.lookup(Thing, "thing")
+    assert_not_equal(thing, found)
+
+    #Xampl.print_stats
+  end
+
+  def test_escaping
+    description = Description.new
+    description.kind = "<>&'\""
+    description << "<>&'\""
+
+    expect = "<ns0:description kind='&lt;&gt;&amp;&apos;&quot;' xmlns:ns0='http://xampl.com/example'>&lt;>&amp;'\"</ns0:description>"
+
+    assert_equal(expect, description.to_xml)
+  end
+
+  def test_generator
+    options = Xampl.make(Options) { | options |
+      options.new_index_attribute("name")
+      options.new_index_attribute("id")
+      options.new_index_attribute("pid").persisted = true
+
+      options.new_resolve{ | resolver |
+        resolver.pkg = "XamplExample"
+        resolver.namespace="http://xampl.com/example"
+      }
+      options.new_resolve{ | resolver |
+        resolver.pkg = "XamplExamplePlay"
+        resolver.namespace="http://xampl.com/example/play"
+      }
+    }
+    generator = Generator.new(options)
+
+    generator.comprehend_from_strings([
+            %Q{
+<things xmlns='http://xampl.com/example'
+        xmlns:xampl='http://xampl.com/example/special'>
+  <thing pid=''>
+    <description kind=''>blah <emph>blah</emph> blah</description>
+    <keyValue id='' value=''/>
+    <stuff kind='' xampl:special=''/>
+    <thing pid=''/>
+    <things/>
+  </thing>
+</things>
+}
+    ])
+
+    ns = "http://xampl.com/example"
+    emap = generator.elements_map
+    assert_equal(1, emap.size)
+    elements = emap[ns]
+    assert_not_nil(elements)
+    assert_equal(6, elements.element_child.size)
+
+    ename = "emph"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(!element.empty)
+    assert(element.has_content)
+
+    ename = "description"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(!element.empty)
+    assert(element.has_content)
+
+    assert_equal(1, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["kind"])
+    assert_nil(element.attribute_map["kind"].namespace)
+
+    assert_equal(1, element.child_element_child.size)
+    cname = "{#{ns}}emph"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("emph", element.child_element_map[cname].element_name)
+
+    ename = "stuff"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(2, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["kind"])
+    assert_nil(element.attribute_map["kind"].namespace)
+    assert_not_nil(element.attribute_map["special"])
+    assert_equal('http://xampl.com/example/special', element.attribute_map["special"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "keyValue"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(2, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["id"])
+    assert_nil(element.attribute_map["id"].namespace)
+    assert_not_nil(element.attribute_map["value"])
+    assert_nil(element.attribute_map["value"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "thing"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(1, element.attribute_child.size)
+    assert_equal(1, element.attribute_map.size)
+    assert_not_nil(element.attribute_map["pid"])
+    assert_nil(element.attribute_map["pid"].namespace)
+
+    assert_equal(5, element.child_element_child.size)
+
+    cname = "{#{ns}}description"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("description", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}keyValue"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("keyValue", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}stuff"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("stuff", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}thing"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("thing", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}things"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("things", element.child_element_map[cname].element_name)
+
+    ename = "things"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(0, element.attribute_child.size)
+    assert_equal(1, element.child_element_child.size)
+
+    cname = "{#{ns}}thing"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("thing", element.child_element_map[cname].element_name)
+
+    #generator.print_stats
+    #generator.analyse
+
+    ename = "emph"
+    element = elements.element_map[ename]
+    assert_equal("simple", element.kind, "emph is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplExample", element.package)
+    assert_equal("Emph", element.class_name)
+    assert_equal("emph", element.attribute_name)
+
+    ename = "description"
+    element = elements.element_map[ename]
+    assert_equal("mixed", element.kind, "description is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplExample", element.package)
+    assert_equal("Description", element.class_name)
+    assert_equal("description", element.attribute_name)
+
+    ename = "stuff"
+    element = elements.element_map[ename]
+    assert_equal("empty", element.kind, "stuff is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplExample", element.package)
+    assert_equal("Stuff", element.class_name)
+    assert_equal("stuff", element.attribute_name)
+
+    ename = "keyValue"
+    element = elements.element_map[ename]
+    assert_equal("empty", element.kind, "keyValue is wrong kind")
+    assert_equal("id", element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplExample", element.package)
+    assert_equal("KeyValue", element.class_name)
+    assert_equal("key_value", element.attribute_name)
+
+    ename = "thing"
+    element = elements.element_map[ename]
+    assert_equal("data", element.kind, "thing is wrong kind")
+    assert_equal("pid", element.indexed_by)
+    assert_not_nil(element.persisted)
+    assert_equal("XamplExample", element.package)
+    assert_equal("Thing", element.class_name)
+    assert_equal("thing", element.attribute_name)
+
+    generator.generate_to_directory(nil)
+  end
+
+  def test_generator_with_no_namespace
+    generator = Generator.new
+    generator.comprehend_from_strings([
+            %Q{
+<things xmlns:xampl='http://xampl.com/example/special'>
+  <thing pid=''>
+    <description kind=''>blah <emph>blah</emph> blah</description>
+    <keyValue id='' value=''/>
+    <stuff kind='' xampl:special=''/>
+    <thing pid=''/>
+    <things/>
+  </thing>
+</things>
+}
+    ])
+
+    ns = ""
+    #ns = nil
+    emap = generator.elements_map
+    assert_equal(1, emap.size)
+    elements = emap[ns]
+    assert_not_nil(elements)
+    assert_equal(6, elements.element_child.size)
+
+    ename = "emph"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(!element.empty)
+    assert(element.has_content)
+
+    ename = "description"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(!element.empty)
+    assert(element.has_content)
+
+    assert_equal(1, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["kind"])
+    assert_nil(element.attribute_map["kind"].namespace)
+
+    assert_equal(1, element.child_element_child.size)
+    cname = "{#{ns}}emph"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("emph", element.child_element_map[cname].element_name)
+
+    ename = "stuff"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(2, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["kind"])
+    assert_nil(element.attribute_map["kind"].namespace)
+    assert_not_nil(element.attribute_map["special"])
+    assert_equal('http://xampl.com/example/special', element.attribute_map["special"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "keyValue"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(2, element.attribute_child.size)
+    assert_not_nil(element.attribute_map["id"])
+    assert_nil(element.attribute_map["id"].namespace)
+    assert_not_nil(element.attribute_map["value"])
+    assert_nil(element.attribute_map["value"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "thing"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(1, element.attribute_child.size)
+    assert_equal(1, element.attribute_map.size)
+    assert_not_nil(element.attribute_map["pid"])
+    assert_nil(element.attribute_map["pid"].namespace)
+
+    assert_equal(5, element.child_element_child.size)
+
+    cname = "{#{ns}}description"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("description", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}keyValue"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("keyValue", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}stuff"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("stuff", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}thing"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("thing", element.child_element_map[cname].element_name)
+
+    cname = "{#{ns}}things"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("things", element.child_element_map[cname].element_name)
+
+    ename = "things"
+    element = elements.element_map[ename]
+    assert_not_nil(element)
+    assert_equal(ns, element.namespace)
+    assert_equal("{#{ns}}#{ename}", element.nstag)
+    assert(element.empty)
+    assert(!element.has_content)
+
+    assert_equal(0, element.attribute_child.size)
+    assert_equal(1, element.child_element_child.size)
+
+    cname = "{#{ns}}thing"
+    assert_not_nil(element.child_element_map[cname])
+    assert_equal(ns, element.child_element_map[cname].namespace)
+    assert_equal("thing", element.child_element_map[cname].element_name)
+
+    #generator.print_stats
+    #generator.analyse
+
+    ename = "emph"
+    element = elements.element_map[ename]
+    assert_equal("simple", element.kind, "emph is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplAdHoc", element.package)
+    assert_equal("Emph", element.class_name)
+    assert_equal("emph", element.attribute_name)
+
+    ename = "description"
+    element = elements.element_map[ename]
+    assert_equal("mixed", element.kind, "description is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplAdHoc", element.package)
+    assert_equal("Description", element.class_name)
+    assert_equal("description", element.attribute_name)
+
+    ename = "stuff"
+    element = elements.element_map[ename]
+    assert_equal("empty", element.kind, "stuff is wrong kind")
+    assert_nil(element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplAdHoc", element.package)
+    assert_equal("Stuff", element.class_name)
+    assert_equal("stuff", element.attribute_name)
+
+    ename = "keyValue"
+    element = elements.element_map[ename]
+    assert_equal("empty", element.kind, "keyValue is wrong kind")
+    assert_equal("id", element.indexed_by)
+    assert_nil(element.persisted)
+    assert_equal("XamplAdHoc", element.package)
+    assert_equal("KeyValue", element.class_name)
+    assert_equal("key_value", element.attribute_name)
+
+    ename = "thing"
+    element = elements.element_map[ename]
+    assert_equal("data", element.kind, "thing is wrong kind")
+    assert_equal("pid", element.indexed_by)
+    assert_not_nil(element.persisted)
+    assert_equal("XamplAdHoc", element.package)
+    assert_equal("Thing", element.class_name)
+    assert_equal("thing", element.attribute_name)
+
+    generator.generate_to_directory(nil)
+  end
+
+  def choose_name_test_helper(name, expected_class_name, expected_attribute_name)
+    original_name = name.dup
+    class_name, attribute_name = Generator.choose_names(name)
+    assert_equal(original_name, name, "changed the original name")
+    assert_equal(expected_class_name, class_name, "CLASS name wrong")
+    assert_equal(expected_attribute_name, attribute_name, "ATTRIBUTE name wrong")
+  end
+
+  def test_choose_names
+    choose_name_test_helper("abcd", "Abcd", "abcd")
+    choose_name_test_helper("Abcd", "Abcd", "abcd")
+    choose_name_test_helper("abCd", "AbCd", "ab_cd")
+    choose_name_test_helper("AbCd", "AbCd", "ab_cd")
+    choose_name_test_helper("ABcd", "ABcd", "abcd")
+
+    choose_name_test_helper("ABcdefABCdef", "ABcdefABCdef", "abcdef_abcdef")
+
+    choose_name_test_helper("ab-cd", "AbCd", "ab_cd")
+    choose_name_test_helper("Ab-Cd", "AbCd", "ab_cd")
+
+    choose_name_test_helper("ab--cd", "AbCd", "ab_cd")
+    choose_name_test_helper("Ab--Cd", "AbCd", "ab_cd")
+
+    choose_name_test_helper("ab_-cd", "AbCd", "ab_cd")
+    choose_name_test_helper("Ab_-Cd", "AbCd", "ab_cd")
+
+    choose_name_test_helper("ab__cd", "AbCd", "ab_cd")
+    choose_name_test_helper("Ab__Cd", "AbCd", "ab_cd")
+
+    choose_name_test_helper("ab:cd", "AbCd", "ab_cd")
+    choose_name_test_helper("Ab:Cd", "AbCd", "ab_cd")
+  end
+
+  # TODO -- test no namespace
+
+  def test_bug_indexed_child_same_pid_added_twice
+    element = Element.new
+    attr0 = element.new_attribute("repeated")
+
+    assert_equal(1, element.attribute_map.size)
+    assert_equal(1, element.attribute_child.size)
+    assert_equal(1, element.children.size)
+    assert_equal(attr0, element.children[0])
+
+    ce1 = element.new_child_element("something")
+
+    assert_equal(1, element.attribute_map.size)
+    assert_equal(1, element.attribute_child.size)
+    assert_equal(2, element.children.size)
+    assert_equal(attr0, element.children[0])
+    assert_equal(ce1, element.children[1])
+
+    attr2 = element.new_attribute("repeated")
+
+    assert_equal(1, element.attribute_map.size)
+    assert_equal(1, element.attribute_child.size)
+    assert_equal(2, element.children.size)
+    assert_equal(ce1, element.children[0])
+    assert_equal(attr2, element.children[1])
+  end
+
+  def check_parents(xampl, parent=nil)
+    if (nil != parent) then
+      found = false
+      xampl.parents.each{ | p |
+        found = true if (parent == p)
+      }
+      assert(found)
+    else
+      if (xampl.kind_of? XamplObject)
+        assert((nil == xampl.parents) || (0 == xampl.parents.size))
+      end
+    end
+    xampl.children.each{ | child |
+      check_parents(child, xampl) if (child.kind_of? XamplObject)
+    }
+  end
+end
+