xamplr 1.2.0

data/lib/xamplr/test-support/test-misc.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require "test/unit"
+
+require "xamplr-generator"
+
+include XamplGenerator
+include Xampl
+
+class TestXampl < Test::Unit::TestCase
+
+  def setup
+    Xampl.disable_all_persisters
+    FromXML.reset_registry
+  end
+
+  def test_tokenise
+    assert_equal(nil, FromXML.tokenise_string(nil))
+    assert_equal("", FromXML.tokenise_string(""))
+    assert_equal("abc", FromXML.tokenise_string("abc"))
+    assert_equal("abc def ghi", FromXML.tokenise_string("abc def ghi"))
+    assert_equal("a b c", FromXML.tokenise_string("a b c"))
+    assert_equal("a b c", FromXML.tokenise_string(" a b c"))
+    assert_equal("a b c", FromXML.tokenise_string("a b c "))
+    assert_equal("a b c", FromXML.tokenise_string(" a b c "))
+    assert_equal("a b c", FromXML.tokenise_string("a    b    c"))
+    assert_equal("a b c", FromXML.tokenise_string("a\nb\tc"))
+    assert_equal("a b c", FromXML.tokenise_string("a\n\t\n\tb\t\n\t\nc"))
+    assert_equal("a b c", FromXML.tokenise_string("\n\n\t\ta\n\t\n\tb\t\n\t\nc\n\n"))
+    assert_equal("abc", FromXML.tokenise_string("\n abc"))
+
+    str = "\n\n\t\ta\n\t\n\tb\t\n\t\nc\n\n"
+    FromXML.tokenise_string str
+    assert_equal("a b c", str)
+
+    #assert_equal(" a b c", FromXML.tokenise_string(" a b c", false))
+    #assert_equal(" a b c", FromXML.tokenise_string("    a b c", false))
+    #assert_equal(" a b c", FromXML.tokenise_string("\n\n\t    a b c", false))
+  end
+
+  def test_xml_text
+    xml=%Q{
+<unknown a='1'
+         b='2'
+         xmlns='dummy.ns'
+         xmlns:ns='another-dummy.ns'
+         xmlns:ns1='never-used.ns'
+         xmlns:ns2='used-only-by-attr.ns'>
+  hello <ns:strong ns2:c='3'
+                   ns3:d='4'
+                   xmlns:ns3='also-used-only-by-attr.ns'>there</ns:strong>
+  hello <strong ns2:c='3'
+                ns3:d='4'
+                xmlns='another-dummy.ns'
+                xmlns:ns3='also-used-only-by-attr.ns'>there</strong>
+</unknown>
+}
+    xml_expected=%Q{<unknown a='1' b='2' xmlns:ns='another-dummy.ns' xmlns:ns2='used-only-by-attr.ns' xmlns:ns3='also-used-only-by-attr.ns' xmlns='dummy.ns'>
+  hello <ns:strong ns2:c='3' ns3:d='4' xmlns='another-dummy.ns'>there</ns:strong>
+  hello <strong ns2:c='3' ns3:d='4' xmlns='another-dummy.ns'>there</strong>
+</unknown>}
+    pp = FromXML.new
+    pp.setup_parse_string(xml)
+    while !pp.startElement?
+      pp.nextEvent
+    end
+    xml_text = XMLText.new
+    xml_text.build(pp)
+
+    assert_equal(xml_expected, xml_text.text)
+  end
+end
+

data/lib/xamplr/test-support/test-names.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+require "xamplr-generator"
+
+include XamplGenerator
+include Xampl
+
+class TestXampl < Test::Unit::TestCase
+
+  def setup
+    Xampl.disable_all_persisters
+  end
+
+  def test_same_names
+    options = Xampl.make(Options) { | options |
+      options.new_index_attribute("name")
+      options.new_resolve{ | resolver |
+        resolver.pkg = "XamplExampleNames"
+        resolver.namespace="http://xampl.com/example"
+      }
+    }
+    generator = Generator.new(options)
+    xml = %Q{
+<conflict name="hansel" xmlns='http://xampl.com/example'>
+  <xname name='blah'>
+	  <conflict name='nested'/>
+	</xname>
+  <name name='blah'>
+	  <conflict name='nested'/>
+	</name>
+</conflict>
+}
+    generator.comprehend_from_strings([ xml ])
+    generator.generate_and_eval() { | module_definition, name |
+      eval(module_definition, nil, name, 1)
+    }
+
+    parser = FromXML.new
+    conflict = parser.parse_string(xml)
+
+    assert(conflict)
+    assert_equal("hansel", conflict.name)
+    assert_equal("hansel"[0], conflict.name[0])
+    assert_equal("blah", conflict.xname_child[0].name)
+    assert_equal("blah", conflict.name_child[0].name)
+    assert_nil(conflict.name['blah'])
+  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
+

data/lib/xamplr/test-support/test-rollback.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby -w -I..
+
+require "test/unit"
+require "xamplr-generator"
+
+include XamplGenerator
+include Xampl
+
+class TestRollback < Test::Unit::TestCase
+
+  xml = %Q{
+<sack pid='white'>
+  <bag mark='one'>
+    <thing info='something'>hello</thing>
+    <stuff id='my stuff'>blah</stuff>
+    <bag/>
+  </bag>
+  <sack pid='black'/>
+</sack>
+    }
+
+  Generator.new.go(:strings => [ xml ],
+                   :directory => "step7")
+
+  require "step7/XamplAdHoc"
+  include XamplAdHoc
+
+  def test_rollback
+    #sack1 = sack2 = nil
+
+    Xampl.transaction("step7-persister", :in_memory){
+      sack1 = Sack.new
+      sack1.pid = "sack1"
+
+      sack2 = sack1.new_sack("sack2"){ | sack |
+        sack.new_bag{ | bag |
+          bag.new_thing{ | thing |
+            thing.info = "thing in sack2"
+          }
+        }
+      }
+    }
+
+    #assert_equal(0, Xampl.count_changed)
+    begin
+      Xampl.transaction("step7-persister"){
+        sack2 = Sack["sack2"]
+
+        assert_equal(0, Xampl.count_changed)
+
+        sack2.bag[0].thing[0].info = "this is a mistake"
+
+        assert_equal(1, Xampl.count_changed)
+
+        raise
+      }
+    rescue Exception
+    end
+
+    #assert_equal(0, Xampl.count_changed)
+
+    Xampl.transaction("step7-persister"){
+      sack1 = Sack["sack1"]
+      assert_equal("thing in sack2", sack1.sack[0].bag[0].thing[0].info)
+    }
+
+  end
+
+  def test_rollback_in_fs
+    #sack1 = sack2 = nil
+
+    pname = "test_rollback_in_fs" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.transaction(pname, :filesystem){
+      sack1 = Sack.new
+      sack1.pid = "sack1"
+
+      sack2 = sack1.new_sack("sack2"){ | sack |
+        sack.new_bag{ | bag |
+          bag.new_thing{ | thing |
+            thing.info = "thing in sack2"
+          }
+        }
+      }
+    }
+
+    #assert_equal(0, Xampl.count_changed)
+    begin
+      Xampl.transaction(pname, :filesystem){
+        sack2 = Sack["sack2"]
+
+        sack2.bag[0].thing[0].info = "this is a mistake"
+
+        raise
+      }
+    rescue Exception
+    end
+
+    #assert_equal(0, Xampl.count_changed)
+
+    Xampl.transaction(pname, :filesystem){
+      sack1 = Sack["sack1"]
+      assert_equal("thing in sack2", sack1.sack[0].bag[0].thing[0].info)
+    }
+
+  end
+end

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

@@ -0,0 +1,1504 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+require "xamplr-generator"
+
+include XamplGenerator
+include Xampl
+
+def assert_xampl_exception(name)
+  xampl_exception = assert_raise(XamplException){
+    yield
+  }
+  assert_equal(name, xampl_exception.name)
+end
+
+options = Xampl.make(Options) { | options |
+  options.new_index_attribute("name")
+  options.new_index_attribute("id")
+  options.new_index_attribute("pid").persisted = true
+
+  options.resolve("http://xampl.com/example", "XamplExample", "ex")
+  options.resolve("http://xampl.com/example/special", "XamplExampleSpecial", "exs")
+}
+generator = Generator.new(options)
+
+the_xml_file = File.join(".", "xml", "example.xml")
+if (0 < ARGV.size) then
+  File.open(the_xml_file){ | f |
+    s = f.read
+    generator.comprehend_from_strings([s])
+    generator.generate_and_eval() { | module_definition, name |
+      eval(module_definition, nil, name, 1)
+    }
+
+  #generator.print_stats
+  }
+  include XamplExample
+else
+  generator.comprehend_from_files([the_xml_file])
+  generator.generate_to_directory(File.join(".", "tmp"))
+  #generator.print_stats
+
+  require "tmp/XamplExample"
+  include XamplExample
+end
+
+#generator.report_elements
+
+class TestXampl < Test::Unit::TestCase
+
+  def setup
+    Xampl.disable_all_persisters
+    #FromXML.reset_registry
+  end
+
+  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("<ex:emph xmlns:ex='http://xampl.com/example'>emph 1</ex:emph>", emph1.test_to_xml)
+    assert_equal("<ex:emph xmlns:ex='http://xampl.com/example'>emph 2</ex:emph>", emph2.test_to_xml)
+    assert_equal("<ex:emph xmlns:ex='http://xampl.com/example'/>", emph3.test_to_xml)
+
+    fakeRules = XMLPrinter.new("fake...")
+    emph1.test_to_xml_internal(fakeRules)
+    r = fakeRules.done
+
+    assert_equal("fake... xmlns:ex='http://xampl.com/example'<ex:emph>emph 1</ex: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("<ex:stuff kind='test' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+    assert_equal("<ex:stuff xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff2.test_to_xml)
+    assert_equal("<ex:stuff kind='test' exs:special='test' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff3.test_to_xml)
+
+    fakeRules = XMLPrinter.new("fake...")
+    stuff1.test_to_xml_internal(fakeRules)
+    r = fakeRules.done
+    assert_equal("fake... xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'<ex: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("<ex:description kind='desc1' xmlns:ex='http://xampl.com/example'/>",
+                 desc1.test_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("<ex:description kind='desc1' xmlns:ex='http://xampl.com/example'>hello <ex:emph>there</ex:emph>! How <ex:emph>are</ex:emph> you?</ex:description>",
+                 desc1.test_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.pid = "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("<ex:thing pid='big_thing' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'><ex:thing pid='thing'><ex:stuff kind='stuff1'/><ex:description kind='desc1'>hello <ex:emph>there</ex:emph>! How <ex:emph>are</ex:emph> you?</ex:description></ex:thing></ex:thing>",
+                 big_thing.test_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_ensure
+    big_thing = Xampl.make(Thing){ | big_thing |
+      big_thing.pid = "big_thing"
+      big_thing.ensure_thing("thing"){ | thing |
+        thing.info = "first";
+      }
+      big_thing.ensure_thing("thing"){ | thing |
+        flunk "What are you doing in here?"
+        thing.info = "second";
+      }
+    }
+
+    assert_equal(1, big_thing.thing.length)
+    assert_equal("first", big_thing.thing[0].info)
+
+    desc = Description.new
+    desc.ensure_emph
+    assert_equal(1, desc.emph.length)
+    #NOTE -- ensure_emph used to be aliased to new_emph, now it just makes
+    #        sure that there is at least one emph
+  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("<ex:thing xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'><ex:thing pid='thing'><ex:stuff kind='stuff1'/><ex:description kind='desc1'>hello <ex:emph>there</ex:emph>! How <ex:emph>are</ex:emph> you?</ex:description></ex:thing></ex:thing>",
+                 big_thing.test_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.test_to_xml
+    #pp = FromXML.new
+    #pp.setup_parse_string(big_thing.test_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.test_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.test_to_xml)
+    another_big_thing = pp.parse_string(big_thing.pp_xml)
+
+    #assert_equal(big_thing.test_to_xml, another_big_thing.test_to_xml)
+    assert_equal(big_thing.pp_xml.gsub(/\s/, ''), another_big_thing.pp_xml.gsub(/\s/, ''))
+    assert_not_same(big_thing, another_big_thing)
+  end
+
+  def test_index
+    thing = Thing.new
+    thing.new_key_value("one").value = "1"
+    thing.new_key_value("two").value = "2"
+
+    assert_same(thing.key_value_child[0], thing.key_value_child["one"])
+    assert_same(thing.key_value_child[1], thing.key_value_child["two"])
+
+    thing.new_key_value("one").value = "1a"
+
+    assert_same(thing.key_value_child[0], thing.key_value_child["two"])
+    assert_same(thing.key_value_child[1], thing.key_value_child["one"])
+
+    check_parents(thing)
+  end
+
+  def test_indexed_remove
+    thing = Thing.new
+    thing.new_key_value("one").value = "1"
+    thing.remove_key_value(thing.key_value["one"])
+
+    assert_equal(0, thing.children.size)
+    assert_equal(0, thing.key_value_child.size)
+
+    thing = Thing.new
+    thing.new_key_value("one").value = "1"
+    thing.new_key_value("two").value = "2"
+    thing.remove_key_value(thing.key_value["one"])
+
+    assert_equal(1, thing.children.size)
+    assert_equal(1, thing.key_value_child.size)
+    assert_not_nil(thing.key_value["two"])
+    assert_equal("2", thing.key_value["two"].value)
+
+  end
+
+  def test_parents
+    thing = Thing.new
+    (kv1 = thing.new_key_value("one")).value = "1"
+    (kv2 = thing.new_key_value("two")).value = "2"
+
+    assert_same(thing, thing.key_value_child[0].parents[0])
+    assert_same(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("<ex:stuff kind='123.456' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+
+    stuff1.kind = nil
+    assert_equal("<ex:stuff xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+
+    stuff1.kind = [1, 2, 3]
+    assert_equal("<ex:stuff kind='123' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+
+    stuff2 = Stuff.new
+    stuff2.kind = 123
+    stuff1.kind = stuff2
+    assert_equal("<ex:stuff kind='&lt;ex:stuff kind=&apos;123&apos; xmlns:ex=&apos;http://xampl.com/example&apos; xmlns:exs=&apos;http://xampl.com/example/special&apos;/&gt;' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff2
+    stuff1.kind = thing
+    assert_equal("<ex:stuff kind='&lt;ex:thing pid=&apos;thing&apos; xmlns:ex=&apos;http://xampl.com/example&apos; xmlns:exs=&apos;http://xampl.com/example/special&apos;&gt;&lt;ex:stuff kind=&apos;123&apos;/&gt;&lt;/ex:thing&gt;' xmlns:ex='http://xampl.com/example' xmlns:exs='http://xampl.com/example/special'/>",
+                 stuff1.test_to_xml)
+
+    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_xampl_exception(:no_index_so_no_persist){
+      persister.write(thing)
+    }
+
+    thing.pid = "thing"
+
+    assert(persister.write(thing))
+
+    saved_thing = persister.read(Thing, "thing")
+    assert(saved_thing)
+
+    assert_equal(thing.test_to_xml, saved_thing.test_to_xml)
+    assert_not_same(thing, saved_thing)
+
+    pname = "first" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.enable_persister(pname, :in_memory)
+    persister1 = Xampl.persister
+
+    #check that the naming and kind checking is working
+    assert_raise(IncompatiblePersisterRequest){
+      Xampl.enable_persister(pname, :filesystem)
+    }
+    #okay, carry on
+
+    Xampl.enable_persister(pname, :in_memory)
+    persister2 = Xampl.persister
+
+    assert_equal(persister1, persister2)
+
+    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_same(thing, Xampl.lookup(Thing, "thing"), "cannot lookup new stuff")
+    assert_same(thing, Thing.lookup("thing"), "cannot lookup new stuff")
+    assert_same(thing, 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_same(thing, Xampl.lookup(Thing, "thing"), "cannot lookup cached stuff")
+
+    Xampl.clear_cache
+
+    found = Xampl.lookup(Thing, "thing")
+    assert_not_equal(thing, found)
+    assert(thing === found)
+
+    #Xampl.print_stats
+  end
+
+  def test_in_memory_persistence_ruby
+    pname = "test_in_memory_persistence_ruby" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.enable_persister(pname, :in_memory, :ruby_format)
+    persister2 = Xampl.persister
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+    Xampl.sync
+    Xampl.clear_cache
+    found = Xampl.lookup(Thing, "thing")
+
+    assert_not_equal(thing, found)
+    assert(thing === found)
+  end
+
+  def test_in_memory_persistence_rollback
+    pname = "first" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    original_persister = Xampl.enable_persister(pname, :in_memory)
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+
+    Xampl.rollback
+
+    current_persister = Xampl.persister
+
+    #assert_not_equal(original_persister, current_persister)
+    assert_equal(original_persister, current_persister)
+
+    # no sync after thing's creation, so thing should NOT exist after rollback
+    found = Xampl.lookup(Thing, "thing")
+    assert_nil(found)
+
+    assert_equal(original_persister, thing.persister)
+
+    #assert_xampl_exception(:live_across_rollback){
+    #  thing.new_stuff
+    #}
+    assert_raise(XamplIsInvalid){
+      thing.new_stuff
+    }
+
+    writes = Xampl.sync
+
+    assert_equal(0, writes)
+  end
+
+  def test_in_memory_persistence_rollback_survival
+    pname = "first" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    original_persister = Xampl.enable_persister(pname, :in_memory)
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+
+    Xampl.sync
+
+    thing.new_stuff
+    thing.info = "something"
+
+    Xampl.rollback
+
+    assert(thing.load_needed)
+    assert(!thing.is_changed)
+
+    assert_nil(thing.info, "attributes not cleared by the rollback")
+
+    current_persister = Xampl.persister
+
+    #assert_not_equal(original_persister, current_persister)
+    assert_equal(original_persister, current_persister) # stomp
+
+    # a sync done BEFORE the second 'stuff' was added to thing
+    found = Xampl.lookup(Thing, "thing")
+    assert_equal(thing, found)
+
+    assert_equal(original_persister, current_persister)
+    assert_equal(original_persister, thing.persister)
+    assert_equal(current_persister, found.persister)
+
+    assert_equal(1, thing.stuff.size)
+    assert_equal(1, found.stuff.size)
+
+    #    assert_xampl_exception(:live_across_rollback){
+    #      thing.new_stuff
+    #    }
+
+    writes = Xampl.sync
+
+    assert_equal(0, writes)
+
+    new_thing = found.new_thing("new_thing")
+    new_thing.new_stuff
+
+    writes = Xampl.sync
+
+    assert_equal(2, writes)
+
+    new_thing.new_stuff
+    writes = Xampl.sync
+    assert_equal(1, writes)
+  end
+
+  def test_filesystem_persistence_basics
+    stuff = Stuff.new
+    thing = Thing.new
+    thing << stuff
+
+    thing.pid = "thing"
+
+    assert_xampl_exception(:name_required){
+      Xampl.enable_persister(nil, :filesystem)
+    }
+
+    pname = "test_filesystem_persistence_basics_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.enable_persister(pname, :filesystem)
+
+    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_equal(0, Xampl.count_changed)
+
+    Xampl.introduce_to_persister(thing)
+
+    assert(thing.persister)
+    assert_equal(1, Xampl.count_changed)
+    assert_same(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_same(thing, Xampl.lookup(Thing, "thing"), "cannot lookup cached stuff")
+
+    Xampl.clear_cache
+
+    found = Xampl.lookup(Thing, "thing")
+    assert_not_same(thing, found)
+    assert(thing === found)
+
+    Xampl.clear_cache
+
+    # now, changing thing will affect the DB -- VERY SUBTLE POSSIBLIITY OF BUG!
+    thing.new_stuff
+    assert_equal(2, thing.stuff.size)
+    assert_equal(1, found.stuff.size)
+
+    writes = Xampl.sync
+
+    assert_equal(2, thing.stuff.size)
+    assert_equal(1, found.stuff.size)
+
+    found2 = Xampl.lookup(Thing, "thing")
+
+    assert_equal(2, thing.stuff.size)
+    assert_equal(1, found.stuff.size)
+    assert_equal(2, found2.stuff.size)
+
+    assert(!(found === found2))
+    assert(thing === found2)
+
+    assert_not_equal(found, found2)
+
+    #Xampl.print_stats
+  end
+
+  def test_filesystem_persistence_very_many
+    name = "test_filesystem_persistence_very_many_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    holder = nil
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      holder = Thing.new("root")
+    end
+
+    1.upto(200) do |i|
+      Xampl.transaction(name, :filesystem, automatic=true) do
+        child = holder.new_thing("child#{i}")
+      end
+    end
+
+    #Xampl.transaction(name, :filesystem, automatic=true) do
+    #Xampl.print_stats
+    #end
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      holder.thing.each{ | child |
+        found = Xampl.lookup(Thing, child.pid)
+        assert_equal(child, found)
+      }
+      #Xampl.print_stats
+    end
+  end
+
+  def test_filesystem_persistence_over_write_on_parse
+    name = "test_filesystem_persistence_over_write_on_parse_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    holder = nil
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      holder = Thing.new("root")
+    end
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      1.upto(10) do |i|
+        cname = "child#{i}"
+        child = holder.new_thing(cname)
+        child.new_key_value('index').value = cname
+      end
+    end
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      Xampl.print_stats
+    end
+
+    xml = holder.pp_xml
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      1.upto(11) do |i|
+        cname = "child#{i}"
+        child = holder.ensure_thing(cname)
+        child.ensure_key_value('index').value = "changed#{i}"
+      end
+      holder.remove_thing("child1")
+    end
+
+    assert_equal(10, holder.thing.size)
+    assert_equal(holder.children.size, holder.thing.size)
+
+    parsed_holder = nil
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      parsed_holder = XamplObject.from_xml_string(xml)
+    end
+
+    assert_equal(10, holder.thing.size)
+    assert_equal(holder.children.size, holder.thing.size)
+
+    assert_equal(parsed_holder, holder)
+
+    Xampl.transaction(name, :filesystem, automatic=true) do
+      holder.thing.each{ | child |
+        found = Xampl.lookup(Thing, child.pid)
+        assert_equal(child, found)
+        assert_equal(child, parsed_holder.thing[child.pid])
+      }
+      Xampl.print_stats
+    end
+  end
+
+  def test_filesystem_persistence_ruby
+    pname = "test_filesystem_persistence_ruby" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.enable_persister(pname, :filesystem, :ruby_format)
+    persister2 = Xampl.persister
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+    Xampl.sync
+
+    thing.info = "force emptying"
+
+    Xampl.rollback
+
+    assert(thing.load_needed)
+
+    found = Xampl.lookup(Thing, "thing")
+
+    assert_equal(thing.object_id, found.object_id)
+  end
+
+  def test_filesystem_persistence_automatic
+    stuff = Stuff.new
+    thing = Thing.new
+    thing << stuff
+
+    thing.pid = "thing"
+
+    pname = "test_filesystem_persistence_automatic_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    Xampl.enable_persister(pname, :filesystem)
+    Xampl.auto_persistence
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    assert_equal(thing, Xampl.lookup(Thing, "thing"))
+
+    assert(thing.persister)
+    assert(thing.is_changed)
+    assert_equal(1, Xampl.count_changed)
+
+    assert_equal(thing, Xampl.lookup(Thing, "thing"), "cannot lookup new stuff")
+
+    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")
+    assert_same(thing, Xampl.lookup(Thing, "thing"), "cannot lookup cached stuff")
+
+    Xampl.clear_cache
+
+    found = Xampl.lookup(Thing, "thing")
+    assert_not_equal(thing, found)
+    assert_not_same(thing, found)
+
+    root = Thing.new
+    root.pid = "root"
+    found2 = root.new_thing("thing")
+
+    assert_equal(found, found2, "in automatic persistence mode, supposed to look stuff up")
+
+    #Xampl.print_stats
+  end
+
+  def test_filesystem_persistence_rollback
+    pname = "test_filesystem_persistence_rollback_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    original_persister = Xampl.enable_persister(pname, :filesystem)
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+
+    Xampl.rollback
+
+    current_persister = Xampl.persister
+
+    assert_equal(original_persister, current_persister)
+    #assert_not_equal(original_persister, current_persister)
+
+    # no sync after thing's creation, so thing should NOT exist after rollback
+    found = Xampl.lookup(Thing, "thing")
+    assert_nil(found)
+
+    assert_equal(original_persister, thing.persister)
+
+    #assert_xampl_exception(:live_across_rollback){
+    #  thing.new_stuff
+    #}
+    thing.stuff.size
+
+    writes = Xampl.sync
+
+    assert_equal(0, writes)
+  end
+
+  def test_filesystem_persistence_rollback_survival
+    pname = "test_filesystem_persistence_rollback_survival_ut" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    original_persister = Xampl.enable_persister(pname, :filesystem)
+
+    stuff = Stuff.new
+    thing = Thing.new
+    thing.pid = "thing"
+    thing << stuff
+
+    Xampl.introduce_to_persister(thing)
+
+    assert_equal(1, thing.stuff.size)
+    Xampl.sync
+    assert_equal(1, thing.stuff.size)
+
+    thing.new_stuff
+    thing.info = "something"
+
+    assert_equal(2, thing.stuff.size)
+
+    Xampl.rollback
+
+    assert(thing.load_needed)
+    assert_nil(thing.info, "attributes not cleared by the rollback")
+    assert(!thing.load_needed)
+    assert_equal(1, thing.stuff.size)
+
+    current_persister = Xampl.persister
+
+    assert_equal(original_persister, current_persister)
+
+    # a sync done BEFORE the second 'stuff' was added to thing
+    found = Xampl.lookup(Thing, "thing")
+    assert_equal(found.object_id, thing.object_id)
+
+    assert_equal(original_persister, current_persister)
+    assert_equal(current_persister, thing.persister)
+    assert_equal(current_persister, found.persister)
+
+    assert(!thing.load_needed)
+    assert(!thing.is_changed)
+
+    thing.stuff.size
+
+    assert(!thing.load_needed)
+    assert(!thing.is_changed)
+
+    assert_equal(found.object_id, thing.object_id)
+    assert_equal(1, thing.stuff.size)
+    assert_equal(1, found.stuff.size)
+
+    #assert_xampl_exception(:live_across_rollback){
+    #  thing.new_stuff
+    #}
+
+    assert(!thing.is_changed)
+    writes = Xampl.sync
+
+    assert_equal(0, writes)
+
+    new_thing = found.new_thing("new_thing")
+    new_thing.new_stuff
+
+    writes = Xampl.sync
+
+    assert_equal(2, writes)
+
+    new_thing.new_stuff
+    writes = Xampl.sync
+    assert_equal(1, writes)
+
+    Xampl.rollback
+
+    assert_equal(0, Xampl.persister.read_count)
+
+    thing = Thing.lookup("thing")
+    assert_not_nil(thing)
+    assert_equal(0, Xampl.persister.read_count, "not in the cache")
+
+    new_thing = thing.thing["new_thing"]
+    assert_not_nil(new_thing)
+    assert_equal(0, Xampl.persister.read_count, "not in the cache")
+
+    keep_new_thing = new_thing
+
+    # these (to xml, ruby) will NOT suck the child thing into memory
+    xml = thing.test_to_xml
+
+    ruby = thing.to_ruby
+    ruby_thing = XamplObject.from_ruby(ruby)
+
+    assert_equal(0, Xampl.persister.read_count, "not in the cache")
+
+    # this will trigger the lazy load of new_thing
+    size = new_thing.stuff.size
+
+    assert_equal(0, Xampl.persister.read_count, "not in the cache")
+    assert_equal(keep_new_thing, new_thing)
+    assert_equal(new_thing, thing.thing["new_thing"])
+
+    Xampl.rollback
+
+    # another way to get stuff into memory
+    # ACTUALLY, this is not legal, there is a cache conflict problem
+    illegal_lazy_thing = Thing.new
+    illegal_lazy_thing.pid = "thing"
+    illegal_lazy_thing.load_needed = true
+    #assert_xampl_exception(:cache_conflict){
+    #  assert(thing === illegal_lazy_thing)
+    #}
+    #assert_raise(XamplIsInvalid){
+    #  # due to a change in xampl this is OK (it isn't invalid yet)
+    #illegal_lazy_thing.info = "oops"
+    #}
+
+    okay_thing = Thing.lookup("thing")
+    assert(okay_thing)
+    okay_thing.info = "okay"
+  end
+
+
+  def test_escaping
+    description = Description.new
+    description.kind = "<>&'\""
+    description << "<>&'\""
+
+    expect = "<ex:description kind='&lt;&gt;&amp;&apos;&quot;' xmlns:ex='http://xampl.com/example'>&lt;>&amp;'\"</ex:description>"
+
+    assert_equal(expect, description.test_to_xml)
+  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_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_child[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_child[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_child["kind"])
+    assert_nil(element.attribute_child["kind"].namespace)
+
+    assert_equal(1, element.child_element_child.size)
+    cname = "{#{ns}}emph"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("emph", element.child_element_child[cname].element_name)
+
+    ename = "stuff"
+    element = elements.element_child[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_child["kind"])
+    assert_nil(element.attribute_child["kind"].namespace)
+    assert_not_nil(element.attribute_child["special"])
+    assert_equal('http://xampl.com/example/special', element.attribute_child["special"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "keyValue"
+    element = elements.element_child[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_child["id"])
+    assert_nil(element.attribute_child["id"].namespace)
+    assert_not_nil(element.attribute_child["value"])
+    assert_nil(element.attribute_child["value"].namespace)
+
+    assert_equal(0, element.child_element_child.size)
+
+    ename = "thing"
+    element = elements.element_child[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_child.size)
+    assert_not_nil(element.attribute_child["pid"])
+    assert_nil(element.attribute_child["pid"].namespace)
+
+    assert_equal(5, element.child_element_child.size)
+
+    cname = "{#{ns}}description"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("description", element.child_element_child[cname].element_name)
+
+    cname = "{#{ns}}keyValue"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("keyValue", element.child_element_child[cname].element_name)
+
+    cname = "{#{ns}}stuff"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("stuff", element.child_element_child[cname].element_name)
+
+    cname = "{#{ns}}thing"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("thing", element.child_element_child[cname].element_name)
+
+    cname = "{#{ns}}things"
+    assert_not_nil(element.child_element_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("things", element.child_element_child[cname].element_name)
+
+    ename = "things"
+    element = elements.element_child[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_child[cname])
+    assert_equal(ns, element.child_element_child[cname].namespace)
+    assert_equal("thing", element.child_element_child[cname].element_name)
+
+    #generator.print_stats
+    generator.analyse
+
+    ename = "emph"
+    element = elements.element_child[ename]
+    assert_equal("simple", element.kind, "emph is wrong kind")
+    assert_nil(element.indexed_by_attr)
+    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_child[ename]
+    assert_equal("mixed", element.kind, "description is wrong kind")
+    assert_nil(element.indexed_by_attr)
+    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_child[ename]
+    assert_equal("empty", element.kind, "stuff is wrong kind")
+    assert_nil(element.indexed_by_attr)
+    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_child[ename]
+    assert_equal("empty", element.kind, "keyValue is wrong kind")
+    assert_equal("id", element.indexed_by_attr)
+    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_child[ename]
+    assert_equal("data", element.kind, "thing is wrong kind")
+    assert_equal("pid", element.indexed_by_attr)
+    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 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")
+
+    choose_name_test_helper("ab.cd", "AbCd", "ab_cd")
+
+    choose_name_test_helper("ab9cd", "AbCd", "ab_cd")
+    choose_name_test_helper("ab9Cd", "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_child.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_child.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_child.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 test_cycles_and_bushy_lookup
+    pname = "test_cycles_and_bushy" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    #Xampl.enable_persister(pname, :filesystem)
+    Xampl.enable_persister(pname, :in_memory)
+    Xampl.auto_persistence
+
+    root = Thing.new("root")
+    root.info = "one"
+
+    root.new_thing("branch1").new_thing("leaf").info = "two"
+    root.new_thing("branch2").new_thing("leaf").info = "three"
+    root.new_thing("branch3").new_thing("leaf").info = "four"
+
+    root.new_thing("cycle0").info = "five"
+    Thing.lookup("cycle0").new_thing("cycle1").new_thing("cycle2").info = "six"
+    Thing.lookup("cycle2").new_thing("cycle0")
+
+    assert(Thing.lookup("cycle2").thing["cycle0"] == Thing.lookup("cycle0"))
+    assert(Thing.lookup("root").thing["cycle0"] == Thing.lookup("cycle0"))
+
+    Xampl.sync
+
+    assert_equal(8, CountingVisitor.new.start(root).count)
+
+    pp_xml = root.pp_xml
+    #puts root.pp_xml
+  end
+
+  def test_cycles_and_bushy2_locals
+    pname = "test_cycles_and_bushy" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    #Xampl.enable_persister(pname, :filesystem)
+    Xampl.enable_persister(pname, :in_memory)
+    Xampl.auto_persistence
+
+    root = Thing.new("root")
+
+    root.new_thing("branch1").new_thing("leaf")
+    root.new_thing("branch2").new_thing("leaf")
+    root.new_thing("branch3").new_thing("leaf")
+
+    cycle0 = root.new_thing("cycle0")
+    cycle0.new_thing("cycle1").new_thing("cycle2").new_thing("cycle0")
+
+    assert_equal(Thing.lookup("cycle2").thing["cycle0"],
+                 Thing.lookup("root").thing["cycle0"])
+
+    Xampl.sync
+
+    assert_equal(8, CountingVisitor.new.start(root).count)
+
+    #puts root.pp_xml
+  end
+
+  def test_internal_cycles_and_bushy
+    pname = "test_internal_cycles_and_bushy" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+    #Xampl.enable_persister(pname, :filesystem)
+    Xampl.enable_persister(pname, :in_memory)
+    Xampl.auto_persistence
+
+    root = Thing.new("root")
+    root.info = "root"
+
+    (branch1 = Branch.new).info='one'
+    (branch2 = Branch.new).info='two'
+    (branch3 = Branch.new).info='three'
+    (branch4 = Branch.new).info='four'
+    (branch5 = Branch.new).info='five'
+
+    #puts branch1.pp_xml
+
+    #
+    #                1
+    #             2     3
+    #                4
+    #                1
+    #        and 5 is a child of 1, 2, 3, and 4
+
+    root << branch1
+
+    branch1 << branch2
+    branch1 << branch3
+
+    branch2 << branch4
+    branch3 << branch4
+
+    branch4 << branch1
+
+    branch1 << branch5
+    branch2 << branch5
+    branch3 << branch5
+    branch4 << branch5
+
+    #assert_xampl_exception(:cycle_detected_in_xampl_cluster){
+    assert_xampl_exception(:cycle_detected_in_xampl_cluster){
+      xml = PersistXML.new("").start(root).done
+    }
+
+    assert_xampl_exception(:cycle_detected_in_xampl_cluster){
+      Xampl.sync
+    }
+
+    #there is one thing and 5 branches, so 6 different things
+    assert_equal(6, CountingVisitor.new.start(root).count)
+
+    pp_xml = root.pp_xml
+  end
+
+#  def test_fsdb_extension_persistence_basics
+#    require 'persister/fsdb'
+#    stuff = Stuff.new
+#    thing = Thing.new
+#    thing << stuff
+#
+#    thing.pid = "thing"
+#
+#    assert_xampl_exception(:name_required){
+#      Xampl.enable_persister(nil, :fsdb)
+#    }
+#
+#    pname = "test_fsdb_extension_persistence_basics" << Time.now.strftime("%Y%m%d-%H%M-%S") << rand.to_s
+#    Xampl.enable_persister(pname, :fsdb)
+#
+#    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_equal(0, Xampl.count_changed)
+#
+#    Xampl.introduce_to_persister(thing)
+#
+#    assert(thing.persister)
+#    assert_equal(1, Xampl.count_changed)
+#    assert_same(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"))
+#
+#    thing2 = Xampl.lookup(Thing, "thing")
+#    assert_same(thing, thing2, "cannot lookup cached stuff")
+#
+#    Xampl.clear_cache
+#
+#    found = Xampl.lookup(Thing, "thing")
+#    assert_not_same(thing, found)
+#    assert(thing === found)
+#
+#    Xampl.clear_cache
+#
+#    # now, changing thing will affect the DB -- VERY SUBTLE POSSIBLIITY OF BUG!
+#    thing.new_stuff
+#    assert_equal(2, thing.stuff.size)
+#    assert_equal(1, found.stuff.size)
+#
+#    writes = Xampl.sync
+#
+#    assert_equal(2, thing.stuff.size)
+#    assert_equal(1, found.stuff.size)
+#
+#    found2 = Xampl.lookup(Thing, "thing")
+#
+#    assert_equal(2, thing.stuff.size)
+#    assert_equal(1, found.stuff.size)
+#    assert_equal(2, found2.stuff.size)
+#
+#    assert(!(found === found2))
+#    assert(thing === found2)
+#
+#    assert_not_equal(found, found2)
+#
+#    #Xampl.print_stats
+#  end
+
+  def test_simple_extension_persistence_basics
+    stuff = Stuff.new
+    thing = Thing.new
+    thing << stuff
+
+    thing.pid = "thing"
+
+    Xampl.enable_persister(nil, :simple)
+
+    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_equal(0, Xampl.count_changed)
+
+    Xampl.introduce_to_persister(thing)
+
+    assert(thing.persister)
+    assert_equal(0, Xampl.count_changed)
+    assert_same(thing, Xampl.lookup(Thing, "thing"), "cannot lookup new stuff")
+
+    #Xampl.print_stats
+
+    assert_equal(0, Xampl.count_changed)
+    writes = Xampl.sync
+    assert_equal(0, Xampl.count_changed)
+    assert(Xampl.lookup(Thing, "thing"))
+
+    thing2 = Xampl.lookup(Thing, "thing")
+    assert_same(thing, thing2, "cannot lookup cached stuff")
+
+    found = Xampl.lookup(Thing, "thing")
+    assert_equal(thing.object_id, found.object_id)
+
+    #Xampl.print_stats
+  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
+