soap4r-sgonyea 1.5.9

data/test/soap/test_soapelement.rb

@@ -0,0 +1,139 @@
+# 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

@@ -0,0 +1,271 @@
+# 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

@@ -0,0 +1,327 @@
+# 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