rtiss_soap4r 1.6.1 → 2.0.4

data/test/soap/test_soapelement.rb

@@ -1,139 +0,0 @@
-# encoding: ASCII-8BIT
-require 'helper'
-require 'soap/baseData'
-require 'soap/mapping'
-
-
-module SOAP
-
-
-class TestSOAPElement < Test::Unit::TestCase
-  include SOAP
-
-  def setup
-    # Nothing to do.
-  end
-
-  def teardown
-    # Nothing to do.
-  end
-
-  def d(elename = nil, text = nil)
-    elename ||= n(nil, nil)
-    if text
-      SOAPElement.new(elename, text)
-    else
-      SOAPElement.new(elename)	# do not merge.
-    end
-  end
-
-  def n(namespace, name)
-    XSD::QName.new(namespace, name)
-  end
-
-  def test_initialize
-    elename = n(nil, nil)
-    obj = d(elename)
-    assert_equal(elename, obj.elename)
-    assert_equal(LiteralNamespace, obj.encodingstyle)
-    assert_equal({}, obj.extraattr)
-    assert_equal([], obj.precedents)
-    assert_equal(nil, obj.qualified)
-    assert_equal(nil, obj.text)
-    assert(obj.members.empty?)
-
-    obj = d("foo", "text")
-    assert_equal(n(nil, "foo"), obj.elename)
-    assert_equal("text", obj.text)
-  end
-
-  def test_add
-    obj = d()
-    child = d("abc")
-    obj.add(child)
-    assert(obj.key?("abc"))
-    assert_same(child, obj["abc"])
-    assert_same(child, obj["abc"])
-    child = d("foo")
-    obj.add(child)
-    assert_equal(child, obj["foo"])
-    child = d("_?a?b_")
-    obj.add(child)
-    assert_equal(child, obj["_?a?b_"])
-  end
-
-  def test_member
-    obj = d()
-    c1 = d("c1")
-    obj.add(c1)
-    c2 = d("c2")
-    obj.add(c2)
-    assert(obj.key?("c1"))
-    assert(obj.key?("c2"))
-    assert_equal(c1, obj["c1"])
-    assert_equal(c2, obj["c2"])
-    c22 = d("c22")
-    obj["c2"] = c22
-    assert(obj.key?("c2"))
-    assert_equal(c22, obj["c2"])
-    assert_equal(["c1", "c2"], obj.members.sort)
-    #
-    k_expect = ["c1", "c2"]
-    v_expect = [c1, c22]
-    obj.each do |k, v|
-      assert(k_expect.include?(k))
-      assert(v_expect.include?(v))
-      k_expect.delete(k)
-      v_expect.delete(v)
-    end
-    assert(k_expect.empty?)
-    assert(v_expect.empty?)
-  end
-
-  def test_to_obj
-    obj = d("root")
-    ct1 = d("ct1", "t1")
-    obj.add(ct1)
-    c2 = d("c2")
-    ct2 = d("ct2", "t2")
-    c2.add(ct2)
-    obj.add(c2)
-    assert_equal({ "ct1" => "t1", "c2" => { "ct2" => "t2" }}, obj.to_obj) 
-    #
-    assert_equal(nil, d().to_obj)
-    assert_equal("abc", d(nil, "abc").to_obj)
-    assert_equal(nil, d("abc", nil).to_obj)
-  end
-
-  def test_from_obj
-    source = { "ct1" => "t1", "c2" => { "ct2" => "t2" }}
-    assert_equal(source, SOAPElement.from_obj(source).to_obj)
-    source = { "1" => nil }
-    assert_equal(source, SOAPElement.from_obj(source).to_obj)
-    source = {}
-    assert_equal(nil, SOAPElement.from_obj(source).to_obj)	# not {}
-    source = nil
-    assert_equal(nil, SOAPElement.from_obj(source).to_obj)
-  end
-
-  def test_from_obj_xmlattr
-    source = { "xmlattr_c1" => "t1",
-      "ymlattr_c2" => {
-        XSD::QName.new("urn:foo", "xmlattr_c2") => "t2",
-        XSD::QName.new("urn:foo", "ymlattr_c3") => "t3" }}
-    obj = SOAPElement.from_obj(source)
-    assert_equal("t1", obj.extraattr[XSD::QName.new(nil, "c1")])
-    assert_equal("t2", obj["ymlattr_c2"].extraattr[XSD::QName.new("urn:foo", "c2")])
-    assert_equal("t3", obj["ymlattr_c2"]["ymlattr_c3"].text)
-    #
-    source = { "xmlattr_xmlattr_c1" => "t1",
-      "xmlele_xmlattr_c2" => {
-        XSD::QName.new("urn:foo", "xmlele_xmlele_c3") => "t3" }}
-    obj = SOAPElement.from_obj(source)
-    assert_equal("t1", obj.extraattr[XSD::QName.new(nil, "xmlattr_c1")])
-    assert_equal("t3", obj["xmlattr_c2"]["xmlele_c3"].text)
-  end
-end
-
-
-end

data/test/soap/test_streamhandler.rb

@@ -1,271 +0,0 @@
-# encoding: ASCII-8BIT
-require 'helper'
-require 'testutil'
-require 'soap/rpc/driver'
-require 'webrick'
-require 'webrick/httpproxy'
-require 'logger'
-
-
-module SOAP
-
-
-class TestStreamHandler < Test::Unit::TestCase
-  Port = 17171
-  ProxyPort = 17172
-
-  def setup
-    @logger = Logger.new(STDERR)
-    @logger.level = Logger::Severity::FATAL
-    @url = "http://localhost:#{Port}/"
-    @proxyurl = "http://localhost:#{ProxyPort}/"
-    @server = @proxyserver = @client = nil
-    @server_thread = @proxyserver_thread = nil
-    setup_server
-    setup_client
-  end
-
-  def teardown
-    teardown_client if @client
-    teardown_proxyserver if @proxyserver
-    teardown_server if @server
-  end
-
-  def setup_server
-    @server = WEBrick::HTTPServer.new(
-      :BindAddress => "0.0.0.0",
-      :Logger => @logger,
-      :Port => Port,
-      :AccessLog => [],
-      :DocumentRoot => File.dirname(File.expand_path(__FILE__))
-    )
-    @server.mount(
-      '/',
-      WEBrick::HTTPServlet::ProcHandler.new(method(:do_server_proc).to_proc)
-    )
-    htpasswd = File.join(File.dirname(__FILE__), 'htpasswd')
-    htpasswd_userdb = WEBrick::HTTPAuth::Htpasswd.new(htpasswd)
-    @basic_auth = WEBrick::HTTPAuth::BasicAuth.new(
-      :Logger => @logger,
-      :Realm => 'auth',
-      :UserDB => htpasswd_userdb
-    )
-    @server.mount(
-      '/basic_auth',
-      WEBrick::HTTPServlet::ProcHandler.new(method(:do_server_proc_basic_auth).to_proc)
-    )
-    @server_thread = TestUtil.start_server_thread(@server)
-  end
-
-  def setup_proxyserver
-    @proxyserver = WEBrick::HTTPProxyServer.new(
-      :BindAddress => "0.0.0.0",
-      :Logger => @logger,
-      :Port => ProxyPort,
-      :AccessLog => []
-    )
-    @proxyserver_thread = TestUtil.start_server_thread(@proxyserver)
-  end
-
-  def setup_client
-    @client = SOAP::RPC::Driver.new(@url, '')
-    @client.add_method("do_server_proc")
-    @client.add_method("do_server_proc_basic_auth")
-  end
-
-  def teardown_server
-    @server.shutdown
-    @server_thread.kill
-    @server_thread.join
-  end
-
-  def teardown_proxyserver
-    @proxyserver.shutdown
-    @proxyserver_thread.kill
-    @proxyserver_thread.join
-  end
-
-  def teardown_client
-    @client.reset_stream
-  end
-
-  def do_server_proc(req, res)
-    res['content-type'] = 'text/xml'
-    res.body = <<__EOX__
-<?xml version="1.0" encoding="utf-8" ?>
-<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <env:Body>
-    <n1:do_server_proc xmlns:n1="urn:foo" env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
-      <return xsi:nil="true"/>
-    </n1:do_server_proc>
-  </env:Body>
-</env:Envelope>
-__EOX__
-  end
-
-  def do_server_proc_basic_auth(req, res)
-    @basic_auth.authenticate(req, res)
-    do_server_proc(req, res)
-  end
-
-  def parse_req_header(str)
-    parse_req_header_http_access2(str)
-  end
-
-  def parse_req_header_http_access2(str)
-    headerp = false
-    headers = {}
-    req = nil
-    str.split(/(?:\r?\n)/).each do |line|
-      if headerp and /^$/ =~line
-	headerp = false
-	break
-      end
-      if headerp
-	k, v = line.scan(/^([^:]+):\s*(.*)$/)[0]
-	headers[k.downcase] = v
-      end
-      if /^POST/ =~ line
-	req = line
-	headerp = true
-      end
-    end
-    return req, headers
-  end
-
-  def test_normal
-    str = ""
-    @client.wiredump_dev = str
-    assert_nil(@client.do_server_proc)
-    r, h = parse_req_header(str)
-    assert_match(%r"POST / HTTP/1.", r)
-    assert(/^text\/xml;/ =~ h["content-type"])
-  end
-
-  def test_uri
-    # initialize client with URI object
-    @client = SOAP::RPC::Driver.new(URI.parse(@url), '')
-    @client.add_method("do_server_proc")
-    # same as test_normal
-    str = ""
-    @client.wiredump_dev = str
-    assert_nil(@client.do_server_proc)
-    r, h = parse_req_header(str)
-    assert_match(%r"POST / HTTP/1.", r)
-    assert(/^text\/xml;/ =~ h["content-type"])
-  end
-
-  def test_basic_auth
-    unless Object.const_defined?('HTTPClient')
-      # soap4r + net/http + basic_auth is not supported.
-      # use httpclient instead.
-      assert(true)
-      return
-    end
-    @client.endpoint_url = @url + 'basic_auth'
-    str = ""
-    @client.wiredump_dev = str
-    @client.options['protocol.http.basic_auth']['0'] = [@url, "admin", "admin"]
-    assert_nil(@client.do_server_proc_basic_auth)
-    @client.options["protocol.http.basic_auth"] << [@url, "admin", "admin"]
-    assert_nil(@client.do_server_proc_basic_auth)
-  end
-
-  def test_proxy
-    if Object.const_defined?('HTTPClient')
-      backup = HTTPClient::NO_PROXY_HOSTS.dup
-      HTTPClient::NO_PROXY_HOSTS.clear
-    else
-      backup = SOAP::NetHttpClient::NO_PROXY_HOSTS.dup
-      SOAP::NetHttpClient::NO_PROXY_HOSTS.clear
-    end
-    setup_proxyserver
-    str = ""
-    @client.wiredump_dev = str
-    @client.options["protocol.http.proxy"] = @proxyurl
-    assert_nil(@client.do_server_proc)
-    r, h = parse_req_header(str)
-    assert_match(%r"POST http://localhost:17171/ HTTP/1.", r)
-    # illegal proxy uri
-    assert_raise(ArgumentError) do
-      @client.options["protocol.http.proxy"] = 'ftp://foo:8080'
-    end
-  ensure
-    if Object.const_defined?('HTTPClient')
-      HTTPClient::NO_PROXY_HOSTS.replace(backup)
-    else
-      SOAP::NetHttpClient::NO_PROXY_HOSTS.replace(backup)
-    end
-  end
-
-  def test_charset
-    str = ""
-    @client.wiredump_dev = str
-    @client.options["protocol.http.charset"] = "iso-8859-8"
-    assert_nil(@client.do_server_proc)
-    r, h = parse_req_header(str)
-    assert_equal("text/xml; charset=iso-8859-8", h["content-type"])
-    #
-    str.replace("")
-    @client.options["protocol.http.charset"] = "iso-8859-3"
-    assert_nil(@client.do_server_proc)
-    r, h = parse_req_header(str)
-    assert_equal("text/xml; charset=iso-8859-3", h["content-type"])
-  end
-
-  def test_custom_streamhandler
-    @client.options["protocol.streamhandler"] = MyStreamHandler
-    assert_equal("hello", @client.do_server_proc)
-    @client.options["protocol.streamhandler"] = ::SOAP::HTTPStreamHandler
-    assert_nil(@client.do_server_proc)
-    @client.options["protocol.streamhandler"] = MyStreamHandler
-    assert_equal("hello", @client.do_server_proc)
-    @client.options["protocol.streamhandler"] = ::SOAP::HTTPStreamHandler
-    assert_nil(@client.do_server_proc)
-  end
-
-  class MyStreamHandler < SOAP::StreamHandler
-    def self.create(options)
-      new
-    end
-
-    def send(endpoint_url, conn_data, soapaction = nil, charset = nil)
-      conn_data.receive_string = %q[<?xml version="1.0" encoding="utf-8" ?>
-<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <env:Body>
-    <n1:do_server_proc xmlns:n1="urn:foo" env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
-      <return xsi:type="xsd:string">hello</return>
-    </n1:do_server_proc>
-  </env:Body>
-</env:Envelope>]
-      conn_data
-    end
-
-    def reset(endpoint_url = nil)
-      # nothing to do
-    end
-  end
-
-  # not used
-  class ExternalProcessStreamHandler < SOAP::StreamHandler
-    def self.create(options)
-      new
-    end
-
-    def send(endpoint_url, conn_data, soapaction = nil, charset = nil)
-      cmd = "cat" # !!
-      IO.popen(cmd, "w+") do |io|
-        io.write(conn_data.send_string)
-        io.close_write
-        conn_data.receive_string = io.read
-      end
-      conn_data
-    end
-
-    def reset(endpoint_url = nil)
-    end
-  end
-end
-
-
-end

data/test/soap/test_styleuse.rb

@@ -1,327 +0,0 @@
-# encoding: ASCII-8BIT
-require 'helper'
-require 'testutil'
-require 'soap/rpc/httpserver'
-require 'soap/rpc/driver'
-
-
-module SOAP
-
-
-class TestStyleUse < Test::Unit::TestCase
-  # rpc driver: obj in(Hash allowed for literal), obj out
-  # 
-  #   style: not visible from user
-  #     rpc: wrapped element
-  #     document: unwrappted element
-  #
-  #   use:
-  #     encoding: a graph (SOAP Data Model)
-  #     literal: not a graph (SOAPElement)
-  #
-  # rpc stub: obj in, obj out(Hash is allowed for literal)
-  #
-  #   style: not visible from user
-  #     rpc: wrapped element
-  #     document: unwrappted element
-  #
-  #   use:
-  #     encoding: a graph (SOAP Data Model)
-  #     literal: not a graph (SOAPElement)
-  #
-  # document driver: SOAPElement in, SOAPElement out? [not implemented]
-  #
-  #   style: ditto
-  #   use: ditto
-  #
-  #
-  # document stub: SOAPElement in, SOAPElement out? [not implemented]
-  #
-  #   style: ditto
-  #   use: ditto
-  #
-  class GenericServant
-    # method name style: requeststyle_requestuse_responsestyle_responseuse
-
-    # 2 params -> array
-    def rpc_enc_rpc_enc(obj1, obj2)
-      [obj1, [obj1, obj2]]
-    end
-
-    # 2 objs -> array
-    def rpc_lit_rpc_enc(obj1, obj2)
-      [obj2, obj1]
-    end
-
-    # 2 params -> 2 params
-    def rpc_enc_rpc_lit(obj1, obj2)
-      klass = [obj1.class.name, obj2.class.name]
-      [obj2, obj1]
-    end
-
-    # 2 objs -> 2 objs
-    def rpc_lit_rpc_lit(obj1, obj2)
-      [obj1, obj2]
-    end
-
-    # 2 params -> array
-    def doc_enc_doc_enc(obj1, obj2)
-      [obj1, [obj1, obj2]]
-    end
-
-    # 2 objs -> array
-    def doc_lit_doc_enc(obj1, obj2)
-      [obj2, obj1]
-    end
-
-    # 2 params -> 2 hashes
-    def doc_enc_doc_lit(obj1, obj2)
-      klass = [obj1.class.name, obj2.class.name]
-      return {'obj1' => {'klass' => klass}, 'misc' => 'hash does not have an order'},
-        {'obj2' => {'klass' => klass}}
-    end
-
-    # 2 objs -> 2 objs
-    def doc_lit_doc_lit(obj1, obj2)
-      return obj1, obj2
-    end
-  end
-
-  Namespace = "urn:styleuse"
-
-  module Op
-    def self.opt(request_style, request_use, response_style, response_use)
-      {
-        :request_style => request_style,
-        :request_use => request_use,
-        :response_style => response_style,
-        :response_use => response_use
-      }
-    end
-
-    Op_rpc_enc_rpc_enc = [
-      XSD::QName.new(Namespace, 'rpc_enc_rpc_enc'),
-      nil,
-      'rpc_enc_rpc_enc', [
-        [:in, 'obj1', nil],
-        [:in, 'obj2', nil],
-        [:retval, 'return', nil]],
-      opt(:rpc, :encoded, :rpc, :encoded)
-    ]
-
-    Op_rpc_lit_rpc_enc = [
-      XSD::QName.new(Namespace, 'rpc_lit_rpc_enc'),
-      nil,
-      'rpc_lit_rpc_enc', [
-        [:in, 'obj1', nil],
-        [:in, 'obj2', nil],
-        [:retval, 'return', nil]],
-      opt(:rpc, :literal, :rpc, :encoded)
-    ]
-
-    Op_rpc_enc_rpc_lit = [
-      XSD::QName.new(Namespace, 'rpc_enc_rpc_lit'),
-      nil,
-      'rpc_enc_rpc_lit', [
-        [:in, 'obj1', nil],
-        [:in, 'obj2', nil],
-        [:retval, 'ret1', nil],
-        [:out, 'ret2', nil]],
-      opt(:rpc, :encoded, :rpc, :literal)
-    ]
-
-    Op_rpc_lit_rpc_lit = [
-      XSD::QName.new(Namespace, 'rpc_lit_rpc_lit'),
-      nil,
-      'rpc_lit_rpc_lit', [
-        [:in, 'obj1', nil],
-        [:in, 'obj2', nil],
-        [:retval, 'ret1', nil],
-        [:out, 'ret2', nil]],
-      opt(:rpc, :literal, :rpc, :literal)
-    ]
-
-    Op_doc_enc_doc_enc = [
-      Namespace + 'doc_enc_doc_enc',
-      'doc_enc_doc_enc', [
-        [:in, 'obj1', [nil, Namespace, 'obj1']],
-        [:in, 'obj2', [nil, Namespace, 'obj2']],
-        [:out, 'ret1', [nil, Namespace, 'ret1']],
-        [:out, 'ret2', [nil, Namespace, 'ret2']]],
-      opt(:document, :encoded, :document, :encoded)
-    ]
-
-    Op_doc_lit_doc_enc = [
-      Namespace + 'doc_lit_doc_enc',
-      'doc_lit_doc_enc', [
-        [:in, 'obj1', [nil, Namespace, 'obj1']],
-        [:in, 'obj2', [nil, Namespace, 'obj2']],
-        [:out, 'ret1', [nil, Namespace, 'ret1']],
-        [:out, 'ret2', [nil, Namespace, 'ret2']]],
-      opt(:document, :literal, :document, :encoded)
-    ]
-
-    Op_doc_enc_doc_lit = [
-      Namespace + 'doc_enc_doc_lit',
-      'doc_enc_doc_lit', [
-        [:in, 'obj1', [nil, Namespace, 'obj1']],
-        [:in, 'obj2', [nil, Namespace, 'obj2']],
-        [:out, 'ret1', [nil, Namespace, 'ret1']],
-        [:out, 'ret2', [nil, Namespace, 'ret2']]],
-      opt(:document, :encoded, :document, :literal)
-    ]
-
-    Op_doc_lit_doc_lit = [
-      Namespace + 'doc_lit_doc_lit',
-      'doc_lit_doc_lit', [
-        [:in, 'obj1', [nil, Namespace, 'obj1']],
-        [:in, 'obj2', [nil, Namespace, 'obj2']],
-        [:out, 'ret1', [nil, Namespace, 'ret1']],
-        [:out, 'ret2', [nil, Namespace, 'ret2']]],
-      opt(:document, :literal, :document, :literal)
-    ]
-  end
-
-  include Op
-
-  class Server < ::SOAP::RPC::HTTPServer
-    include Op
-
-    def on_init
-      @servant = GenericServant.new
-      add_rpc_operation(@servant, *Op_rpc_enc_rpc_enc)
-      add_rpc_operation(@servant, *Op_rpc_lit_rpc_enc)
-      add_rpc_operation(@servant, *Op_rpc_enc_rpc_lit)
-      add_rpc_operation(@servant, *Op_rpc_lit_rpc_lit)
-      add_document_operation(@servant, *Op_doc_enc_doc_enc)
-      add_document_operation(@servant, *Op_doc_lit_doc_enc)
-      add_document_operation(@servant, *Op_doc_enc_doc_lit)
-      add_document_operation(@servant, *Op_doc_lit_doc_lit)
-    end
-  end
-
-  Port = 17171
-
-  def setup
-    setup_server
-    setup_client
-  end
-
-  def setup_server
-    @server = Server.new(
-      :BindAddress => "0.0.0.0",
-      :Port => Port,
-      :AccessLog => [],
-      :SOAPDefaultNamespace => Namespace
-    )
-    @server.level = Logger::Severity::ERROR
-    @server_thread = TestUtil.start_server_thread(@server)
-  end
-
-  def setup_client
-    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/", Namespace)
-    @client.wiredump_dev = STDERR if $DEBUG
-    @client.add_rpc_operation(*Op_rpc_enc_rpc_enc)
-    @client.add_rpc_operation(*Op_rpc_lit_rpc_enc)
-    @client.add_rpc_operation(*Op_rpc_enc_rpc_lit)
-    @client.add_rpc_operation(*Op_rpc_lit_rpc_lit)
-    @client.add_document_operation(*Op_doc_enc_doc_enc)
-    @client.add_document_operation(*Op_doc_lit_doc_enc)
-    @client.add_document_operation(*Op_doc_enc_doc_lit)
-    @client.add_document_operation(*Op_doc_lit_doc_lit)
-  end
-
-  def teardown
-    teardown_server if @server
-    teardown_client if @client
-  end
-
-  def teardown_server
-    @server.shutdown
-    @server_thread.kill
-    @server_thread.join
-  end
-
-  def teardown_client
-    @client.reset_stream
-  end
-
-  def test_rpc_enc_rpc_enc
-    o = "hello"
-    obj1 = o
-    obj2 = [1]
-    ret = @client.rpc_enc_rpc_enc(obj1, obj2)
-    # server returns [obj1, [obj1, obj2]]
-    assert_equal([obj1, [obj1, obj2]], ret)
-    assert_same(ret[0], ret[1][0])
-  end
-
-  S1 = ::Struct.new(:a)
-  S2 = ::Struct.new(:c)
-  def test_rpc_lit_rpc_enc
-    ret1, ret2 = @client.rpc_lit_rpc_enc(S1.new('b'), S2.new('d'))
-    assert_equal('d', ret1.c)
-    assert_equal('b', ret2.a)
-    # Hash is allowed for literal
-    ret1, ret2 = @client.rpc_lit_rpc_enc({'a' => 'b'}, {'c' => 'd'})
-    assert_equal('d', ret1.c)
-    assert_equal('b', ret2.a)
-    # simple value
-    assert_equal(
-      ['1', 'a'],
-      @client.rpc_lit_rpc_enc('a', 1)
-    )
-  end
-
-  def test_rpc_enc_rpc_lit
-    assert_equal(
-      ['1', 'a'],
-      @client.rpc_enc_rpc_lit('a', '1')
-    )
-  end
-
-  def test_rpc_lit_rpc_lit
-    ret1, ret2 = @client.rpc_lit_rpc_lit({'a' => 'b'}, {'c' => 'd'})
-    assert_equal('b', ret1["a"])
-    assert_equal('d', ret2["c"])
-  end
-
-  def test_doc_enc_doc_enc
-    o = "hello"
-    obj1 = o
-    obj2 = [1]
-    ret = @client.rpc_enc_rpc_enc(obj1, obj2)
-    # server returns [obj1, [obj1, obj2]]
-    assert_equal([obj1, [obj1, obj2]], ret)
-    assert_same(ret[0], ret[1][0])
-  end
-
-  def test_doc_lit_doc_enc
-    ret1, ret2 = @client.doc_lit_doc_enc({'a' => 'b'}, {'c' => 'd'})
-    assert_equal('d', ret1.c)
-    assert_equal('b', ret2.a)
-    assert_equal(
-      ['a', '1'],
-      @client.doc_lit_doc_enc(1, 'a')
-    )
-  end
-
-  def test_doc_enc_doc_lit
-    ret1, ret2 = @client.doc_enc_doc_lit('a', 1)
-    # literal Array
-    assert_equal(['String', 'Fixnum'], ret1['obj1']['klass'])
-    # same value
-    assert_equal(ret1['obj1']['klass'], ret2['obj2']['klass'])
-    # not the same object (not encoded)
-    assert_not_same(ret1['obj1']['klass'], ret2['obj2']['klass'])
-  end
-
-  def test_doc_lit_doc_lit
-    ret1, ret2 = @client.doc_lit_doc_lit({'a' => 'b'}, {'c' => 'd'})
-    assert_equal('b', ret1["a"])
-    assert_equal('d', ret2["c"])
-  end
-end
-
-
-end