* imported and refactored original test cases

* added methods XMLRPC::XMLParser.each_installed_parser and
  XMLRPC::XMLWriter.each_installed_writer to simply original test cases

* use Object#allocate instead of defining an empty #initialize

* module XMLRPC::Marshallable is now only used for tagging


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@7274 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

lib/xmlrpc/create.rb

@@ -86,6 +86,18 @@ module XMLRPC
 
     end # class XMLParser
 
+    Classes = [Simple, XMLParser]
+
+    # yields an instance of each installed XML writer
+    def self.each_installed_writer
+      XMLRPC::XMLWriter::Classes.each do |klass|
+        begin
+          yield klass.new
+        rescue LoadError
+        end
+      end
+    end
+
   end # module XMLWriter
 
   class Create
@@ -248,7 +260,10 @@ module XMLRPC
           if Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable
             # convert Ruby object into Hash
             ret = {"___class___" => param.class.name}
-            param.__get_instance_variables.each {|name, val| 
+            param.instance_variables.each {|v| 
+              name = v[1..-1]
+              val = param.instance_variable_get(v)
+
               if val.nil?
                 ret[name] = val if Config::ENABLE_NIL_CREATE
               else

lib/xmlrpc/parser.rb

@@ -113,30 +113,12 @@ module XMLRPC
           mod = Module
           klass.split("::").each {|const| mod = mod.const_get(const.strip)}
 
-          Thread.critical = true
-          # let initialize take 0 parameters
-          mod.module_eval %{
-            begin
-              alias __initialize initialize
-            rescue NameError
-            end
-            def initialize; end
-          }
-
-          obj = mod.new
-
-          # restore old initialize
-          mod.module_eval %{
-            undef initialize
-            begin
-              alias initialize __initialize
-            rescue NameError
-            end
-          }
-          Thread.critical = false
+          obj = mod.allocate
           
           hash.delete "___class___"
-          hash.each {|k,v| obj.__set_instance_variable(k, v) } 
+          hash.each {|key, value| 
+            obj.instance_variable_set("@#{ key }", value) if key =~ /^([\w_][\w_0-9]*)$/
+          }
           obj
         rescue
           hash
@@ -801,6 +783,16 @@ module XMLRPC
                NQXMLStreamParser, NQXMLTreeParser, 
                REXMLStreamParser, XMLScanStreamParser]
 
+    # yields an instance of each installed parser
+    def self.each_installed_parser
+      XMLRPC::XMLParser::Classes.each do |klass|
+        begin
+          yield klass.new
+        rescue LoadError
+        end
+      end
+    end
+
   end # module XMLParser
 
 

lib/xmlrpc/utils.rb

@@ -17,13 +17,6 @@ module XMLRPC
   # key/value pair "___class___" => ClassName
   # 
   module Marshallable
-    def __get_instance_variables
-      instance_variables.collect {|var| [var[1..-1], eval(var)] }
-    end
-
-    def __set_instance_variable(key, value)
-      eval("@#$1 = value") if key =~ /^([\w_][\w_0-9]*)$/
-    end
   end
 
 

test/xmlrpc/data/bug_bool.expected

@@ -0,0 +1 @@
+[true, false]

test/xmlrpc/data/bug_bool.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<methodResponse>
+  <params>
+    <param>
+      <value><boolean>0</boolean></value>
+    </param>
+  </params>
+</methodResponse>

test/xmlrpc/data/bug_cdata.expected

@@ -0,0 +1 @@
+[true, "test"]

test/xmlrpc/data/bug_cdata.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<methodResponse>
+  <params>
+    <param>
+      <value><string><![CDATA[test]]></string></value>
+    </param>
+  </params>
+</methodResponse>

test/xmlrpc/data/bug_covert.expected

@@ -0,0 +1 @@
+[true, "Site,SANs,Array\nConfigured Capacity,Array Reserved Capacity,Array Ava\nilable Capacity,Array % Reserved,Host Allocated,Host Used,Host Free,Host %\nUsed\n"]

test/xmlrpc/data/bug_covert.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0"
+encoding="ISO-8859-1"?><methodResponse><params><param><value>Site,SANs,Array
+Configured Capacity,Array Reserved Capacity,Array Ava
+ilable Capacity,Array % Reserved,Host Allocated,Host Used,Host Free,Host %
+Used
+</value></param></params></methodResponse>

test/xmlrpc/data/fault.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<methodResponse>
+  <fault>
+    <value><struct>
+      <member>
+        <name>faultCode</name>
+        <value><int>4</int></value>
+      </member>
+      <member>
+        <name>faultString</name>
+        <value>an error message</value>
+      </member>
+    </struct></value>
+  </fault>
+</methodResponse>
+

test/xmlrpc/data/value.expected

@@ -0,0 +1 @@
+["Test", ["Hallo Leute", "   Hallo   ", "", "   "]]

test/xmlrpc/data/value.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<methodCall>
+  <methodName>Test</methodName>
+  <params>
+    <param>
+      <value>Hallo Leute</value>
+    </param>
+    <param>
+      <value>   Hallo   </value>
+    </param>
+    <param>
+      <value></value>
+    </param>
+    <param>
+      <value>   </value>
+    </param>
+  </params>
+</methodCall>
+
+
+
+

test/xmlrpc/test_datetime.rb

@@ -0,0 +1,160 @@
+$LOAD_PATH.unshift '../../lib'
+require 'test/unit'
+require "xmlrpc/datetime"
+
+class Test_DateTime < Test::Unit::TestCase
+
+  def test_new
+    dt = createDateTime()
+
+    assert_instance_of(XMLRPC::DateTime, dt)
+  end
+
+  def test_new_exception
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(4.5, 13, 32, 25, 60, 60) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 12, 32, 25, 60, 60) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 12, 31, 25, 60, 60) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 12, 31, 24, 60, 60) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 12, 31, 24, 59, 60) }
+    assert_nothing_raised(ArgumentError) { XMLRPC::DateTime.new(2001, 12, 31, 24, 59, 59) }
+
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 0, 0, -1, -1, -1) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 1, 0, -1, -1, -1) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 1, 1, -1, -1, -1) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 1, 1, 0, -1, -1) }
+    assert_raises(ArgumentError) { XMLRPC::DateTime.new(2001, 1, 1, 0, 0, -1) }
+    assert_nothing_raised(ArgumentError) { XMLRPC::DateTime.new(2001, 1, 1, 0, 0, 0) }
+  end
+
+
+  def test_get_values
+    y, m, d, h, mi, s = 1970, 3, 24, 12, 0, 5
+    dt = XMLRPC::DateTime.new(y, m, d, h, mi, s)
+
+    assert_equal(y, dt.year)
+    assert_equal(m, dt.month)
+    assert_equal(m, dt.mon)
+    assert_equal(d, dt.day)
+
+    assert_equal(h, dt.hour)
+    assert_equal(mi,dt.min)
+    assert_equal(s, dt.sec)
+  end
+
+  def test_set_values
+    dt = createDateTime()
+    y, m, d, h, mi, s = 1950, 12, 9, 8, 52, 30
+
+    dt.year  = y
+    dt.month = m
+    dt.day   = d
+    dt.hour  = h
+    dt.min   = mi
+    dt.sec   = s
+
+    assert_equal(y, dt.year)
+    assert_equal(m, dt.month)
+    assert_equal(m, dt.mon)
+    assert_equal(d, dt.day)
+
+    assert_equal(h, dt.hour)
+    assert_equal(mi,dt.min)
+    assert_equal(s, dt.sec)
+
+    dt.mon = 5
+    assert_equal(5, dt.month)
+    assert_equal(5, dt.mon)
+  end
+
+  def test_set_exception
+    dt = createDateTime()
+    
+    assert_raises(ArgumentError)    { dt.year = 4.5 }
+    assert_nothing_raised(ArgumentError) { dt.year = -2000 }
+ 
+    assert_raises(ArgumentError) { dt.month = 0 }
+    assert_raises(ArgumentError) { dt.month = 13 }
+    assert_nothing_raised(ArgumentError) { dt.month = 7 }
+
+    assert_raises(ArgumentError) { dt.mon = 0 }
+    assert_raises(ArgumentError) { dt.mon = 13 }
+    assert_nothing_raised(ArgumentError) { dt.mon = 7 }
+
+    assert_raises(ArgumentError) { dt.day = 0 }
+    assert_raises(ArgumentError) { dt.day = 32 }
+    assert_nothing_raised(ArgumentError) { dt.day = 16 }
+
+    assert_raises(ArgumentError) { dt.hour = -1 }
+    assert_raises(ArgumentError) { dt.hour = 25 }
+    assert_nothing_raised(ArgumentError) { dt.hour = 12 }
+
+    assert_raises(ArgumentError) { dt.min = -1 }
+    assert_raises(ArgumentError) { dt.min = 60 }
+    assert_nothing_raised(ArgumentError) { dt.min = 30 }
+
+    assert_raises(ArgumentError) { dt.sec = -1 }
+    assert_raises(ArgumentError) { dt.sec = 60 }
+    assert_nothing_raised(ArgumentError) { dt.sec = 30 }
+  end
+
+  def test_to_a
+    y, m, d, h, mi, s = 1970, 3, 24, 12, 0, 5
+    dt = XMLRPC::DateTime.new(y, m, d, h, mi, s)
+    a = dt.to_a 
+
+    assert_instance_of(Array, a)
+    assert_equal(6,  a.size, "Returned array has wrong size")
+
+    assert_equal(y,  a[0])
+    assert_equal(m,  a[1])
+    assert_equal(d,  a[2])
+    assert_equal(h,  a[3])
+    assert_equal(mi, a[4])
+    assert_equal(s,  a[5])
+  end
+
+  def test_to_time1
+    y, m, d, h, mi, s = 1970, 3, 24, 12, 0, 5
+    dt = XMLRPC::DateTime.new(y, m, d, h, mi, s)
+    time = dt.to_time 
+    
+    assert_not_nil(time)
+
+    assert_equal(y,  time.year)
+    assert_equal(m,  time.month)
+    assert_equal(d,  time.day)
+    assert_equal(h,  time.hour)
+    assert_equal(mi, time.min)
+    assert_equal(s,  time.sec)
+  end
+
+  def test_to_time2
+    dt = createDateTime()
+    dt.year = 1969
+    
+    assert_nil(dt.to_time)
+  end
+
+  def test_to_date1
+    y, m, d, h, mi, s = 1970, 3, 24, 12, 0, 5
+    dt = XMLRPC::DateTime.new(y, m, d, h, mi, s)
+    date = dt.to_date 
+ 
+    assert_equal(y, date.year)
+    assert_equal(m, date.month)
+    assert_equal(d, date.day)
+  end
+
+  def test_to_date2
+    dt = createDateTime()
+    dt.year = 666
+    
+    assert_equal(666, dt.to_date.year)
+  end
+
+
+  def createDateTime
+    XMLRPC::DateTime.new(1970, 3, 24, 12, 0, 5)
+  end
+
+end

test/xmlrpc/test_features.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift '../../lib'
+require 'test/unit'
+require "xmlrpc/create"
+require "xmlrpc/parser"
+require "xmlrpc/config"
+
+#XMLRPC::Config.const_set(ENABLE_NIL_CREATE, true)
+#XMLRPC::Config.const_set(ENABLE_NIL_PARSER, true)
+
+class Test_Features < Test::Unit::TestCase
+
+  def setup
+    @params = [nil, {"test" => nil}, [nil, 1, nil]]
+  end
+
+  def test_nil_create
+    XMLRPC::XMLWriter.each_installed_writer do |writer|
+      c = XMLRPC::Create.new(writer)
+
+      XMLRPC::Config.const_set(:ENABLE_NIL_CREATE, false)
+      assert_raises(RuntimeError) { str = c.methodCall("test", *@params) }
+
+      XMLRPC::Config.const_set(:ENABLE_NIL_CREATE, true)
+      assert_nothing_raised { str = c.methodCall("test", *@params) }
+    end
+  end
+
+  def test_nil_parse
+    XMLRPC::Config.const_set(:ENABLE_NIL_CREATE, true)
+
+    XMLRPC::XMLWriter.each_installed_writer do |writer|
+      c = XMLRPC::Create.new(writer)
+      str = c.methodCall("test", *@params) 
+      XMLRPC::XMLParser.each_installed_parser do |parser|
+        para = nil
+
+        XMLRPC::Config.const_set(:ENABLE_NIL_PARSER, false)
+        assert_raises(RuntimeError) { para = parser.parseMethodCall(str) }
+
+        XMLRPC::Config.const_set(:ENABLE_NIL_PARSER, true)
+        assert_nothing_raised { para = parser.parseMethodCall(str) }
+        assert_equal(para[1], @params)
+      end
+    end
+  end
+
+end

test/xmlrpc/test_marshal.rb

@@ -0,0 +1,94 @@
+$LOAD_PATH.unshift '../../lib'
+require 'test/unit'
+require "xmlrpc/marshal"
+
+class Test_Marshal < Test::Unit::TestCase
+  # for test_parser_values
+  class Person
+    include XMLRPC::Marshallable
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+
+  def test1_dump_response
+    assert_nothing_raised(NameError) {
+      XMLRPC::Marshal.dump_response('arg')
+    }
+  end
+
+  def test1_dump_call
+    assert_nothing_raised(NameError) {
+      XMLRPC::Marshal.dump_call('methodName', 'arg')
+    }
+  end
+
+  def test2_dump_load_response
+    value = [1, 2, 3, {"test" => true}, 3.4]
+    res   = XMLRPC::Marshal.dump_response(value)
+
+    assert_equal(value, XMLRPC::Marshal.load_response(res))
+  end
+
+  def test2_dump_load_call
+    methodName = "testMethod"
+    value      = [1, 2, 3, {"test" => true}, 3.4]
+    exp        = [methodName, [value, value]]
+
+    res   = XMLRPC::Marshal.dump_call(methodName, value, value)
+
+    assert_equal(exp, XMLRPC::Marshal.load_call(res))
+  end
+
+  def test_parser_values
+    v1 = [ 
+      1, -7778,                        # integers
+      1.0, 0.0, -333.0, 2343434343.0,  # floats
+      false, true, true, false,        # booleans
+      "Hallo", "with < and >", ""      # strings
+    ]
+
+    v2 = [
+      [v1, v1, v1],
+      {"a" => v1}
+    ]
+
+    v3 = [
+      XMLRPC::Base64.new("\001"*1000), # base64
+      :aSymbol, :anotherSym            # symbols (-> string)
+    ]
+    v3_exp = [
+      "\001"*1000,
+      "aSymbol", "anotherSym"
+    ]
+    person = Person.new("Michael")
+
+    XMLRPC::XMLParser.each_installed_parser do |parser|
+      m = XMLRPC::Marshal.new(parser)
+
+      assert_equal( v1, m.load_response(m.dump_response(v1)) )
+      assert_equal( v2, m.load_response(m.dump_response(v2)) )
+      assert_equal( v3_exp, m.load_response(m.dump_response(v3)) )
+
+      pers = m.load_response(m.dump_response(person))
+      
+      assert( pers.is_a?(Person) )
+      assert( person.name == pers.name ) 
+    end
+
+    # missing, Date, Time, DateTime
+    # Struct
+  end
+
+  def test_no_params_tag
+    # bug found by Idan Sofer
+
+    expect = %{<?xml version="1.0" ?><methodCall><methodName>myMethod</methodName><params/></methodCall>\n}
+
+    str = XMLRPC::Marshal.dump_call("myMethod")
+    assert_equal(expect, str)
+  end
+
+end

test/xmlrpc/test_parser.rb

@@ -0,0 +1,77 @@
+$LOAD_PATH.unshift '../../lib'
+require 'test/unit'
+require "xmlrpc/parser"
+
+module GenericParserTest
+  def setup
+    @xml1 = File.readlines("data/xml1.xml").to_s
+    @expected1 = File.readlines("data/xml1.expected").to_s.chomp
+
+    @xml2 = File.readlines("data/bug_covert.xml").to_s
+    @expected2 = File.readlines("data/bug_covert.expected").to_s.chomp
+
+    @xml3 = File.readlines("data/bug_bool.xml").to_s
+    @expected3 = File.readlines("data/bug_bool.expected").to_s.chomp
+
+    @xml4 = File.readlines("data/value.xml").to_s
+    @expected4 = File.readlines("data/value.expected").to_s.chomp
+
+    @cdata_xml = File.readlines("data/bug_cdata.xml").to_s.chomp
+    @cdata_expected = File.readlines("data/bug_cdata.expected").to_s.chomp
+
+    @fault_doc = File.readlines("data/fault.xml").to_s
+  end
+
+  # test parseMethodResponse --------------------------------------------------
+  
+  def test_parseMethodResponse1
+    assert_equal(@expected1, @p.parseMethodResponse(@xml1).inspect)
+  end
+
+  def test_parseMethodResponse2
+    assert_equal(@expected2, @p.parseMethodResponse(@xml2).inspect)
+  end
+
+  def test_parseMethodResponse3
+    assert_equal(@expected3, @p.parseMethodResponse(@xml3).inspect)
+  end
+
+  def test_cdata
+    assert_equal(@cdata_expected, @p.parseMethodResponse(@cdata_xml).inspect)
+  end
+
+  # test parseMethodCall ------------------------------------------------------
+
+  def test_parseMethodCall
+    assert_equal(@expected4, @p.parseMethodCall(@xml4).inspect)
+  end
+
+  # test fault ----------------------------------------------------------------
+
+  def test_fault
+    flag, fault = @p.parseMethodResponse(@fault_doc)
+     assert_equal(flag, false)
+     unless fault.is_a? XMLRPC::FaultException
+       assert(false, "must be an instance of class XMLRPC::FaultException")
+     end
+     assert_equal(fault.faultCode, 4)
+     assert_equal(fault.faultString, "an error message")
+  end
+end
+
+# create test class for each installed parser 
+XMLRPC::XMLParser.each_installed_parser do |parser|
+  klass = parser.class
+  name = klass.to_s.split("::").last
+
+  eval %{
+    class Test_#{name} < Test::Unit::TestCase
+      include GenericParserTest
+
+      def setup
+        super
+        @p = #{klass}.new
+      end
+    end
+  }
+end