diff options
Diffstat (limited to 'ruby_1_8_6/test/soap/test_property.rb')
| -rw-r--r-- | ruby_1_8_6/test/soap/test_property.rb | 424 |
1 files changed, 0 insertions, 424 deletions
diff --git a/ruby_1_8_6/test/soap/test_property.rb b/ruby_1_8_6/test/soap/test_property.rb deleted file mode 100644 index 7acd2c8437..0000000000 --- a/ruby_1_8_6/test/soap/test_property.rb +++ /dev/null @@ -1,424 +0,0 @@ -require 'test/unit' -require 'soap/property' - - -module SOAP - - -class TestProperty < Test::Unit::TestCase - FrozenError = (RUBY_VERSION >= "1.9.0") ? RuntimeError : TypeError - - def setup - @prop = ::SOAP::Property.new - end - - def teardown - # Nothing to do. - end - - def test_s_load - propstr = <<__EOP__ - -# comment1 - -# comment2\r -# comment2 - -\r -a.b.0 = 1 -a.b.1 = 2 -a.b.2 = 3 -client.protocol.http.proxy=http://myproxy:8080 \r -client.protocol.http.no_proxy: intranet.example.com,local.example.com\r -client.protocol.http.protocol_version = 1.0 -foo\\:bar\\=baz = qux -foo\\\\.bar.baz=\tq\\\\ux\ttab - a\\ b = 1 -[ppp.qqq.rrr] -sss = 3 -ttt.uuu = 4 - -[ sss.ttt.uuu ] -vvv.www = 5 -[ ] -xxx.yyy.zzz = 6 -__EOP__ - prop = Property.load(propstr) - assert_equal(["1", "2", "3"], prop["a.b"].values.sort) - assert_equal("intranet.example.com,local.example.com", - prop["client.protocol.http.no_proxy"]) - assert_equal("http://myproxy:8080", prop["client.protocol.http.proxy"]) - assert_equal("1.0", prop["client.protocol.http.protocol_version"]) - assert_equal("q\\ux\ttab", prop['foo\.bar.baz']) - assert_equal("1", prop['a b']) - assert_equal("3", prop['ppp.qqq.rrr.sss']) - assert_equal("4", prop['ppp.qqq.rrr.ttt.uuu']) - assert_equal("5", prop['sss.ttt.uuu.vvv.www']) - assert_equal("6", prop['xxx.yyy.zzz']) - end - - def test_load - prop = Property.new - hooked = false - prop.add_hook("foo.bar.baz") do |name, value| - assert_equal(["foo", "bar", "baz"], name) - assert_equal("123", value) - hooked = true - end - prop.lock - prop["foo.bar"].lock - prop.load("foo.bar.baz = 123") - assert(hooked) - assert_raises(FrozenError) do - prop.load("foo.bar.qux = 123") - end - prop.load("foo.baz = 456") - assert_equal("456", prop["foo.baz"]) - end - - def test_initialize - prop = ::SOAP::Property.new - # store is empty - assert_nil(prop["a"]) - # does hook work? - assert_equal(1, prop["a"] = 1) - end - - def test_aref - # name_to_a - assert_nil(@prop[:foo]) - assert_nil(@prop["foo"]) - assert_nil(@prop[[:foo]]) - assert_nil(@prop[["foo"]]) - assert_raises(ArgumentError) do - @prop[1] - end - @prop[:foo] = :foo - assert_equal(:foo, @prop[:foo]) - assert_equal(:foo, @prop["foo"]) - assert_equal(:foo, @prop[[:foo]]) - assert_equal(:foo, @prop[["foo"]]) - end - - def test_referent - # referent(1) - assert_nil(@prop["foo.foo"]) - assert_nil(@prop[["foo", "foo"]]) - assert_nil(@prop[["foo", :foo]]) - @prop["foo.foo"] = :foo - assert_equal(:foo, @prop["foo.foo"]) - assert_equal(:foo, @prop[["foo", "foo"]]) - assert_equal(:foo, @prop[[:foo, "foo"]]) - # referent(2) - @prop["bar.bar.bar"] = :bar - assert_equal(:bar, @prop["bar.bar.bar"]) - assert_equal(:bar, @prop[["bar", "bar", "bar"]]) - assert_equal(:bar, @prop[[:bar, "bar", :bar]]) - end - - def test_to_key_and_deref - @prop["foo.foo"] = :foo - assert_equal(:foo, @prop["fOo.FoO"]) - assert_equal(:foo, @prop[[:fOO, :FOO]]) - assert_equal(:foo, @prop[["FoO", :Foo]]) - # deref_key negative test - assert_raises(ArgumentError) do - @prop["baz"] = 1 - @prop["baz.qux"] = 2 - end - end - - def test_hook_name - tag = Object.new - tested = false - @prop.add_hook("foo.bar") do |key, value| - assert_raise(FrozenError) do - key << "baz" - end - tested = true - end - @prop["foo.bar"] = tag - assert(tested) - end - - def test_value_hook - tag = Object.new - tested = false - @prop.add_hook("FOO.BAR.BAZ") do |key, value| - assert_equal(["Foo", "baR", "baZ"], key) - assert_equal(tag, value) - tested = true - end - @prop["Foo.baR.baZ"] = tag - assert_equal(tag, @prop["foo.bar.baz"]) - assert(tested) - @prop["foo.bar"] = 1 # unhook the above block - assert_equal(1, @prop["foo.bar"]) - end - - def test_key_hook_no_cascade - tag = Object.new - tested = 0 - @prop.add_hook do |key, value| - assert(false) - end - @prop.add_hook(false) do |key, value| - assert(false) - end - @prop.add_hook("foo") do |key, value| - assert(false) - end - @prop.add_hook("foo.bar", false) do |key, value| - assert(false) - end - @prop.add_hook("foo.bar.baz") do |key, value| - assert(false) - end - @prop.add_hook("foo.bar.baz.qux", false) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop["foo.bar.baz.qux"] = tag - assert_equal(tag, @prop["foo.bar.baz.qux"]) - assert_equal(1, tested) - end - - def test_key_hook_cascade - tag = Object.new - tested = 0 - @prop.add_hook(true) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop.add_hook("foo", true) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop.add_hook("foo.bar", true) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop.add_hook("foo.bar.baz", true) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop.add_hook("foo.bar.baz.qux", true) do |key, value| - assert_equal(["foo", "bar", "baz", "qux"], key) - assert_equal(tag, value) - tested += 1 - end - @prop["foo.bar.baz.qux"] = tag - assert_equal(tag, @prop["foo.bar.baz.qux"]) - assert_equal(5, tested) - end - - def test_keys - assert(@prop.keys.empty?) - @prop["foo"] = 1 - @prop["bar"] - @prop["BAz"] = 2 - assert_equal(2, @prop.keys.size) - assert(@prop.keys.member?("foo")) - assert(@prop.keys.member?("baz")) - # - assert_nil(@prop["a"]) - @prop["a.a"] = 1 - assert_instance_of(::SOAP::Property, @prop["a"]) - @prop["a.b"] = 1 - @prop["a.c"] = 1 - assert_equal(3, @prop["a"].keys.size) - assert(@prop["a"].keys.member?("a")) - assert(@prop["a"].keys.member?("b")) - assert(@prop["a"].keys.member?("c")) - end - - def test_lshift - assert(@prop.empty?) - @prop << 1 - assert_equal([1], @prop.values) - assert_equal(1, @prop["0"]) - @prop << 1 - assert_equal([1, 1], @prop.values) - assert_equal(1, @prop["1"]) - @prop << 1 - assert_equal([1, 1, 1], @prop.values) - assert_equal(1, @prop["2"]) - # - @prop["abc.def"] = o = SOAP::Property.new - tested = 0 - o.add_hook do |k, v| - tested += 1 - end - @prop["abc.def"] << 1 - @prop["abc.def"] << 2 - @prop["abc.def"] << 3 - @prop["abc.def"] << 4 - assert_equal(4, tested) - end - - def test_lock_each - @prop["a.b.c.d.e"] = 1 - @prop["a.b.d"] = branch = ::SOAP::Property.new - @prop["a.b.d.e.f"] = 2 - @prop.lock - assert(@prop.locked?) - assert_instance_of(::SOAP::Property, @prop["a"]) - assert_raises(FrozenError) do - @prop["b"] - end - # - @prop["a"].lock - assert_raises(FrozenError) do - @prop["a"] - end - assert_instance_of(::SOAP::Property, @prop["a.b"]) - # - @prop["a.b"].lock - assert_raises(FrozenError) do - @prop["a.b"] - end - assert_raises(FrozenError) do - @prop["a"] - end - # - @prop["a.b.c.d"].lock - assert_instance_of(::SOAP::Property, @prop["a.b.c"]) - assert_raises(FrozenError) do - @prop["a.b.c.d"] - end - assert_instance_of(::SOAP::Property, @prop["a.b.d"]) - # - branch["e"].lock - assert_instance_of(::SOAP::Property, @prop["a.b.d"]) - assert_raises(FrozenError) do - @prop["a.b.d.e"] - end - assert_raises(FrozenError) do - branch["e"] - end - end - - def test_lock_cascade - @prop["a.a"] = nil - @prop["a.b.c"] = 1 - @prop["b"] = false - @prop.lock(true) - assert(@prop.locked?) - assert_equal(nil, @prop["a.a"]) - assert_equal(1, @prop["a.b.c"]) - assert_equal(false, @prop["b"]) - assert_raises(FrozenError) do - @prop["c"] - end - assert_raises(FrozenError) do - @prop["c"] = 2 - end - assert_raises(FrozenError) do - @prop["a.b.R"] - end - assert_raises(FrozenError) do - @prop.add_hook do - assert(false) - end - end - assert_raises(FrozenError) do - @prop.add_hook("c") do - assert(false) - end - end - assert_raises(FrozenError) do - @prop.add_hook("a.c") do - assert(false) - end - end - assert_nil(@prop["a.a"]) - @prop["a.a"] = 2 - assert_equal(2, @prop["a.a"]) - # - @prop.unlock(true) - assert_nil(@prop["c"]) - @prop["c"] = 2 - assert_equal(2, @prop["c"]) - @prop["a.d.a.a"] = :foo - assert_equal(:foo, @prop["a.d.a.a"]) - tested = false - @prop.add_hook("a.c") do |name, value| - assert(true) - tested = true - end - @prop["a.c"] = 3 - assert(tested) - end - - def test_hook_then_lock - tested = false - @prop.add_hook("a.b.c") do |name, value| - assert_equal(["a", "b", "c"], name) - tested = true - end - @prop["a.b"].lock - assert(!tested) - @prop["a.b.c"] = 5 - assert(tested) - assert_equal(5, @prop["a.b.c"]) - assert_raises(FrozenError) do - @prop["a.b.d"] = 5 - end - end - - def test_lock_unlock_return - assert_equal(@prop, @prop.lock) - assert_equal(@prop, @prop.unlock) - end - - def test_lock_split - @prop["a.b.c"] = 1 - assert_instance_of(::SOAP::Property, @prop["a.b"]) - @prop["a.b.d"] = branch = ::SOAP::Property.new - @prop["a.b.d.e"] = 2 - assert_equal(branch, @prop["a.b.d"]) - assert_equal(branch, @prop[:a][:b][:d]) - @prop.lock(true) - # split error 1 - assert_raises(FrozenError) do - @prop["a.b"] - end - # split error 2 - assert_raises(FrozenError) do - @prop["a"] - end - @prop["a.b.c"] = 2 - assert_equal(2, @prop["a.b.c"]) - # replace error - assert_raises(FrozenError) do - @prop["a.b.c"] = ::SOAP::Property.new - end - # override error - assert_raises(FrozenError) do - @prop["a.b"] = 1 - end - # - assert_raises(FrozenError) do - @prop["a.b.d"] << 1 - end - assert_raises(FrozenError) do - branch << 1 - end - branch.unlock(true) - branch << 1 - branch << 2 - branch << 3 - assert_equal(2, @prop["a.b.d.e"]) - assert_equal(1, @prop["a.b.d.1"]) - assert_equal(2, @prop["a.b.d.2"]) - assert_equal(3, @prop["a.b.d.3"]) - end -end - - -end |