Welcome to the "trac"-ing site of soap4r!
[soap4r] [httpclient] [openpgp4u] [pkcs1] [logger] [csv] [vtr]

Changeset 1979

Show
Ignore:
Timestamp:
09/21/07 18:25:43 (8 months ago)
Author:
nahi
Message:
  • when there are 2 unqualified anonymous elements which have the same name in a SOAP message, mapper cannot decode it to the correct object. introduced :is_anonymous in mapping_registry and do not search registry with anonymous element. closes #355.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/mapping/mapping.rb

    r1972 r1979  
    438438      :schema_name => schema_name, 
    439439      :schema_type => schema_type, 
     440      :is_anonymous => false, 
    440441      :schema_qualified => qualified, 
    441442      :schema_element => elements, 
    …… 
    450451    schema_name = definition[:schema_name] 
    451452    schema_type = definition[:schema_type] 
     453    is_anonymous = definition[:is_anonymous] 
    452454    schema_basetype = definition[:schema_basetype] 
    453455    # wrap if needed for backward compatibility 
    …… 
    460462    schema_element = definition[:schema_element] 
    461463    schema_attributes = definition[:schema_attribute] 
    462     definition = SchemaDefinition.new(klass, schema_name, schema_type, schema_qualified) 
     464    definition = SchemaDefinition.new(klass, schema_name, schema_type, is_anonymous, schema_qualified) 
    463465    definition.basetype = schema_basetype 
    464466    definition.attributes = schema_attributes 

  • trunk/lib/soap/mapping/registry.rb

    r1972 r1979  
    187187      @class_schema_definition[obj_class] = definition 
    188188    end 
    189     if definition.elename 
     189    if definition.elename and !definition.is_anonymous? 
    190190      @class_elename_schema_definition[obj_class] = definition 
    191191      @elename_schema_definition[definition.elename] = definition 

  • trunk/lib/soap/mapping/schemadefinition.rb

    r1924 r1979  
    146146  attr_accessor :elements 
    147147 
    148   def initialize(class_for, elename, type, qualified) 
     148  def initialize(class_for, elename, type, anonymous, qualified) 
    149149    @class_for = class_for 
    150150    @elename = elename 
    151151    @type = type 
     152    @anonymous = anonymous 
    152153    @qualified = qualified 
    153154    @basetype = nil 
    154155    @elements = EMPTY 
    155156    @attributes = nil 
     157  end 
     158 
     159  def is_anonymous? 
     160    @anonymous 
    156161  end 
    157162 

  • trunk/lib/wsdl/soap/encodedMappingRegistryCreator.rb

    r1969 r1979  
    5252  def dump_complextype 
    5353    @complextypes.collect { |type| 
    54       dump_complextypedef(@modulepath, type.name, type) unless type.abstract 
     54      unless type.abstract 
     55        dump_with_inner { 
     56          dump_complextypedef(@modulepath, type.name, type, nil, :encoded => true) 
     57        } 
     58      end 
    5559    }.compact.join("\n") 
    5660  end 
    …… 
    5862  def dump_simpletype 
    5963    @simpletypes.collect { |type| 
    60       dump_simpletypedef(@modulepath, type.name, type) 
     64      dump_with_inner { 
     65        dump_simpletypedef(@modulepath, type.name, type, nil, :encoded => true) 
     66      } 
    6167    }.compact.join("\n") 
    62   end 
    63  
    64   def dump_complextypedef(mpath, qname, typedef) 
    65     case typedef.compoundtype 
    66     when :TYPE_STRUCT, :TYPE_EMPTY 
    67       dump_struct_typemap(mpath, qname, typedef) 
    68     when :TYPE_ARRAY 
    69       dump_array_typemap(mpath, qname, typedef, :encoded => true) 
    70     when :TYPE_SIMPLE 
    71       dump_simple_typemap(mpath, qname, typedef) 
    72     when :TYPE_MAP 
    73       # mapped as a general Hash 
    74       nil 
    75     else 
    76       raise RuntimeError.new( 
    77         "unknown kind of complexContent: #{typedef.compoundtype}") 
    78     end 
    7968  end 
    8069end 

  • trunk/lib/wsdl/soap/literalMappingRegistryCreator.rb

    r1964 r1979  
    6666      # has the definition different from the complexType of the same name 
    6767      next if ele.type.nil? and @complextypes[ele.name] 
    68       qualified = (ele.elementform == 'qualified') 
    69       if ele.local_complextype 
    70         dump_complextypedef(@modulepath, ele.name, ele.local_complextype, nil, qualified) 
    71       elsif ele.local_simpletype 
    72         dump_simpletypedef(@modulepath, ele.name, ele.local_simpletype, nil, qualified) 
    73       elsif ele.type 
    74         if typedef = @complextypes[ele.type] 
    75           dump_complextypedef(@modulepath, ele.type, typedef, ele.name, qualified) 
    76         elsif typedef = @simpletypes[ele.type] 
    77           dump_simpletypedef(@modulepath, ele.type, typedef, ele.name, qualified) 
    78         else 
    79           nil 
     68      dump_with_inner { 
     69        if typedef = ele.local_complextype 
     70          dump_complextypedef(@modulepath, ele.name, typedef) 
     71        elsif typedef = ele.local_simpletype 
     72          dump_simpletypedef(@modulepath, ele.name, typedef) 
     73        elsif ele.type 
     74          if typedef = @complextypes[ele.type] 
     75            dump_complextypedef(@modulepath, ele.type, typedef, ele.name) 
     76          elsif typedef = @simpletypes[ele.type] 
     77            dump_simpletypedef(@modulepath, ele.type, typedef, ele.name) 
     78          end 
    8079        end 
    81       else 
    82         nil 
    83       end 
     80      } 
    8481    }.compact.join("\n") 
    8582  end 
    …… 
    8885    @attributes.collect { |attr| 
    8986      if attr.local_simpletype 
    90         dump_simpletypedef(@modulepath, attr.name, attr.local_simpletype) 
     87        dump_with_inner { 
     88          dump_simpletypedef(@modulepath, attr.name, attr.local_simpletype) 
     89        } 
    9190      end 
    9291    }.compact.join("\n") 
    …… 
    9594  def dump_simpletype 
    9695    @simpletypes.collect { |type| 
    97       dump_simpletypedef(@modulepath, type.name, type) 
     96      dump_with_inner { 
     97        dump_simpletypedef(@modulepath, type.name, type) 
     98      } 
    9899    }.compact.join("\n") 
    99100  end 
    …… 
    101102  def dump_complextype 
    102103    @complextypes.collect { |type| 
    103       dump_complextypedef(@modulepath, type.name, type) unless type.abstract 
     104      unless type.abstract 
     105        dump_with_inner { 
     106          dump_complextypedef(@modulepath, type.name, type) 
     107        } 
     108      end 
    104109    }.compact.join("\n") 
    105   end 
    106  
    107   def dump_complextypedef(mpath, qname, typedef, as_element = nil, qualified = false) 
    108     case typedef.compoundtype 
    109     when :TYPE_STRUCT, :TYPE_EMPTY 
    110       dump_struct_typemap(mpath, qname, typedef, as_element, qualified) 
    111     when :TYPE_ARRAY 
    112       dump_array_typemap(mpath, qname, typedef) 
    113     when :TYPE_SIMPLE 
    114       dump_simple_typemap(mpath, qname, typedef, as_element, qualified) 
    115     when :TYPE_MAP 
    116       # mapped as a general Hash 
    117       nil 
    118     else 
    119       raise RuntimeError.new( 
    120         "unknown kind of complexContent: #{typedef.compoundtype}") 
    121     end 
    122110  end 
    123111end 

  • trunk/lib/wsdl/soap/mappingRegistryCreatorSupport.rb

    r1969 r1979  
    1919  include XSD::CodeGen 
    2020 
    21   def dump_struct_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
    22     dump_with_inner { 
    23       dump_complex_typemap(mpath, qname, typedef, as_element, qualified) 
    24     } 
    25   end 
    26  
    27   def dump_array_typemap(mpath, qname, typedef, opt = {}) 
    28     dump_with_inner { 
    29       if typedef.find_soapenc_arytype 
    30         if opt[:encoded] 
    31           dump_encoded_array_typemap(mpath, qname, typedef) 
    32         end 
    33       else 
    34         dump_literal_array_typemap(mpath, qname, typedef) 
    35       end 
    36     } 
    37   end 
    38  
    3921  def dump_with_inner 
    4022    @dump_with_inner = [] 
    …… 
    4325  end 
    4426 
    45   def dump_complex_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
     27  def dump_complextypedef(mpath, qname, typedef, as_element = nil, opt = {}) 
     28    case typedef.compoundtype 
     29    when :TYPE_STRUCT, :TYPE_EMPTY 
     30      dump_complex_typemap(mpath, qname, typedef, as_element, opt) 
     31    when :TYPE_ARRAY 
     32      dump_array_typemap(mpath, qname, typedef, opt) 
     33    when :TYPE_SIMPLE 
     34      dump_simple_typemap(mpath, qname, typedef, as_element, opt) 
     35    when :TYPE_MAP 
     36      # mapped as a general Hash 
     37      nil 
     38    else 
     39      raise RuntimeError.new( 
     40        "unknown kind of complexContent: #{typedef.compoundtype}") 
     41    end 
     42  end 
     43 
     44  def dump_array_typemap(mpath, qname, typedef, opt) 
     45    if typedef.find_soapenc_arytype 
     46      if opt[:encoded] 
     47        dump_encoded_array_typemap(mpath, qname, typedef, opt) 
     48      end 
     49    else 
     50      dump_literal_array_typemap(mpath, qname, typedef, opt) 
     51    end 
     52  end 
     53 
     54  def dump_complex_typemap(mpath, qname, typedef, as_element, opt) 
    4655    var = {} 
    4756    var[:class] = mapped_class_name(qname, mpath) 
    …… 
    5766      schema_ns = qname.namespace 
    5867    end 
     68    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous) 
    5969    # true, false, or nil 
    60     unless qualified.nil? 
    61       var[:schema_qualified] = qualified.to_s 
     70    if opt.key?(:qualified) 
     71      var[:schema_qualified] = opt[:qualified].to_s 
    6272    end 
    6373    parentmodule = var[:class] 
    6474    parsed_element = 
    65       parse_elements(typedef.elements, qname.namespace, parentmodule, qualified) 
     75      parse_elements(typedef.elements, qname.namespace, parentmodule, opt) 
    6676    if typedef.choice? 
    6777      parsed_element.unshift(:choice) 
    …… 
    7585  end 
    7686 
    77   def dump_simple_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
     87  def dump_simple_typemap(mpath, qname, typedef, as_element, opt) 
    7888    var = {} 
    7989    var[:class] = mapped_class_name(qname, mpath) 
    …… 
    8898      schema_ns = qname.namespace 
    8999    end 
     100    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous) 
    90101    unless typedef.attributes.empty? 
    91102      var[:schema_attribute] = define_attribute(typedef.attributes) 
    …… 
    140151  end 
    141152 
    142   def parse_elements(elements, base_namespace, mpath, qualified = false) 
     153  def parse_elements(elements, base_namespace, mpath, opt) 
    143154    schema_element = [] 
    144155    any = false 
    …… 
    158169        typebase = @modulepath 
    159170        if element.anonymous_type? 
    160           @dump_with_inner << dump_complex_typemap(mpath, element.name, 
    161             element.local_complextype, nil, qualified) 
     171          child_opt = { 
     172            :qualified => (element.elementform == 'qualified'), 
     173            :is_anonymous => true 
     174          } 
     175          @dump_with_inner << dump_complextypedef(mpath, element.name, element.local_complextype, nil, child_opt) 
    162176          typebase = mpath 
    163177        end 
    …… 
    181195      when WSDL::XMLSchema::Sequence 
    182196        child_schema_element = 
    183           parse_elements(element.elements, base_namespace, mpath, qualified) 
     197          parse_elements(element.elements, base_namespace, mpath, opt) 
    184198        schema_element << child_schema_element 
    185199      when WSDL::XMLSchema::Choice 
    186200        child_schema_element = 
    187           parse_elements(element.elements, base_namespace, mpath, qualified) 
     201          parse_elements(element.elements, base_namespace, mpath, opt) 
    188202        if !element.map_as_array? 
    189203          # choice + maxOccurs="unbounded" is treated just as 'all' now. 
    …… 
    197211        end 
    198212        child_schema_element = 
    199           parse_elements(element.content.elements, base_namespace, mpath, qualified) 
     213          parse_elements(element.content.elements, base_namespace, mpath, opt) 
    200214        schema_element.concat(child_schema_element) 
    201215      else 
    …… 
    233247        dump_entry_item(var, :schema_name, :qname), 
    234248        dump_entry_item(var, :schema_type, :qname), 
     249        dump_entry_item(var, :is_anonymous), 
    235250        dump_entry_item(var, :schema_basetype, :qname), 
    236251        dump_entry_item(var, :schema_qualified), 
    …… 
    266281  end 
    267282 
    268   def dump_simpletypedef(mpath, qname, simpletype, as_element = nil, qualified = false) 
     283  def dump_simpletypedef(mpath, qname, simpletype, as_element = nil, opt = {}) 
    269284    if simpletype.restriction 
    270       dump_simpletypedef_restriction(mpath, qname, simpletype, as_element, qualified) 
     285      dump_simpletypedef_restriction(mpath, qname, simpletype, as_element, opt) 
    271286    elsif simpletype.list 
    272       dump_simpletypedef_list(mpath, qname, simpletype, as_element, qualified) 
     287      dump_simpletypedef_list(mpath, qname, simpletype, as_element, opt) 
    273288    elsif simpletype.union 
    274       dump_simpletypedef_union(mpath, qname, simpletype, as_element, qualified) 
     289      dump_simpletypedef_union(mpath, qname, simpletype, as_element, opt) 
    275290    else 
    276291      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    278293  end 
    279294 
    280   def dump_simpletypedef_restriction(mpath, qname, typedef, as_element, qualified) 
     295  def dump_simpletypedef_restriction(mpath, qname, typedef, as_element, opt) 
    281296    restriction = typedef.restriction 
    282297    unless restriction.enumeration? 
    …… 
    296311      schema_ns = qname.namespace 
    297312    end 
     313    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous) 
    298314    assign_const(schema_ns, 'Ns') 
    299315    dump_entry(@varname, var) 
    300316  end 
    301317 
    302   def dump_simpletypedef_list(mpath, qname, typedef, as_element, qualified) 
     318  def dump_simpletypedef_list(mpath, qname, typedef, as_element, opt) 
    303319    nil 
    304320  end 
    305321 
    306   def dump_simpletypedef_union(mpath, qname, typedef, as_element, qualified) 
     322  def dump_simpletypedef_union(mpath, qname, typedef, as_element, opt) 
    307323    nil 
    308324  end 
    …… 
    310326  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item') 
    311327 
    312   def dump_literal_array_typemap(mpath, qname, typedef) 
     328  def dump_literal_array_typemap(mpath, qname, typedef, opt) 
    313329    var = {} 
    314330    var[:class] = mapped_class_name(qname, mpath) 
    …… 
    321337      var[:schema_type] = qname 
    322338    end 
     339    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous) 
    323340    parsed_element = 
    324       parse_elements(typedef.elements, qname.namespace, var[:class], nil) 
     341      parse_elements(typedef.elements, qname.namespace, var[:class], opt) 
    325342    if parsed_element.empty? 
    326343      parsed_element = [create_array_element_definition(typedef, mpath)] 
    …… 
    331348  end 
    332349 
    333   def dump_encoded_array_typemap(mpath, qname, typedef) 
     350  def dump_encoded_array_typemap(mpath, qname, typedef, opt) 
    334351    arytype = typedef.find_arytype || XSD::AnyTypeName 
    335352    type = XSD::QName.new(arytype.namespace, arytype.name.sub(/\[(?:,)*\]$/, '')) 

  • trunk/test/wsdl/anonymous/expectedDriver.rb

    r1915 r1979  
    1313      [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:lp", "login"]], 
    1414        ["out", "parameters", ["::SOAP::SOAPElement", "urn:lp", "loginResponse"]] ], 
     15      { :request_style =>  :document, :request_use =>  :literal, 
     16        :response_style => :document, :response_use => :literal, 
     17        :faults => {} } 
     18    ], 
     19    [ "urn:lp:echo", 
     20      "echo", 
     21      [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:lp", "Pack"]], 
     22        ["out", "parameters", ["::SOAP::SOAPElement", "urn:lp", "Envelope"]] ], 
    1523      { :request_style =>  :document, :request_use =>  :literal, 
    1624        :response_style => :document, :response_use => :literal, 

  • trunk/test/wsdl/anonymous/expectedMappingRegistry.rb

    r1964 r1979  
    2828    :class => WSDL::Anonymous::ExtraInfo::Entry, 
    2929    :schema_name => XSD::QName.new(nil, "Entry"), 
     30    :is_anonymous => true, 
     31    :schema_qualified => false, 
    3032    :schema_element => [ 
    3133      ["key", ["SOAP::SOAPString", XSD::QName.new(nil, "Key")]], 
    …… 
    4547    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    4648    :schema_name => XSD::QName.new(nil, "loginResult"), 
     49    :is_anonymous => true, 
     50    :schema_qualified => false, 
    4751    :schema_element => [ 
    4852      ["sessionID", "SOAP::SOAPString"] 
    …… 
    5357    :class => WSDL::Anonymous::Header, 
    5458    :schema_type => XSD::QName.new(NsLp, "Header"), 
    55     :schema_qualified => false, 
    5659    :schema_element => [ 
    5760      ["header3", ["SOAP::SOAPString", XSD::QName.new(nil, "Header3")]] 
    …… 
    7073    :class => WSDL::Anonymous::ExtraInfo::Entry, 
    7174    :schema_name => XSD::QName.new(nil, "Entry"), 
     75    :is_anonymous => true, 
     76    :schema_qualified => false, 
    7277    :schema_element => [ 
    7378      ["key", ["SOAP::SOAPString", XSD::QName.new(nil, "Key")]], 
    …… 
    7984    :class => WSDL::Anonymous::LoginResponse, 
    8085    :schema_type => XSD::QName.new(NsLp, "loginResponse"), 
    81     :schema_qualified => false, 
    8286    :schema_element => [ 
    8387      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]] 
    …… 
    8892    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    8993    :schema_name => XSD::QName.new(nil, "loginResult"), 
     94    :is_anonymous => true, 
    9095    :schema_qualified => false, 
    9196    :schema_element => [ 
    …… 
    97102    :class => WSDL::Anonymous::Pack, 
    98103    :schema_name => XSD::QName.new(NsLp, "Pack"), 
    99     :schema_qualified => true, 
    100104    :schema_element => [ 
    101105      ["header", ["WSDL::Anonymous::Pack::Header", XSD::QName.new(nil, "Header")]] 
    …… 
    106110    :class => WSDL::Anonymous::Pack::Header, 
    107111    :schema_name => XSD::QName.new(nil, "Header"), 
    108     :schema_qualified => true, 
     112    :is_anonymous => true, 
     113    :schema_qualified => false, 
    109114    :schema_element => [ 
    110115      ["header1", ["SOAP::SOAPString", XSD::QName.new(nil, "Header1")]] 
    …… 
    115120    :class => WSDL::Anonymous::Envelope, 
    116121    :schema_name => XSD::QName.new(NsLp, "Envelope"), 
    117     :schema_qualified => true, 
    118122    :schema_element => [ 
    119123      ["header", ["WSDL::Anonymous::Envelope::Header", XSD::QName.new(nil, "Header")]] 
    …… 
    124128    :class => WSDL::Anonymous::Envelope::Header, 
    125129    :schema_name => XSD::QName.new(nil, "Header"), 
    126     :schema_qualified => true, 
     130    :is_anonymous => true, 
     131    :schema_qualified => false, 
    127132    :schema_element => [ 
    128133      ["header2", ["SOAP::SOAPString", XSD::QName.new(nil, "Header2")]] 
    …… 
    133138    :class => WSDL::Anonymous::Login, 
    134139    :schema_name => XSD::QName.new(NsLp, "login"), 
    135     :schema_qualified => true, 
    136140    :schema_element => [ 
    137141      ["loginRequest", ["WSDL::Anonymous::Login::LoginRequest", XSD::QName.new(nil, "loginRequest")]] 
    …… 
    142146    :class => WSDL::Anonymous::Login::LoginRequest, 
    143147    :schema_name => XSD::QName.new(nil, "loginRequest"), 
    144     :schema_qualified => true, 
     148    :is_anonymous => true, 
     149    :schema_qualified => false, 
    145150    :schema_element => [ 
    146151      ["username", "SOAP::SOAPString"], 
    …… 
    153158    :class => WSDL::Anonymous::LoginResponse, 
    154159    :schema_name => XSD::QName.new(NsLp, "loginResponse"), 
    155     :schema_qualified => true, 
    156160    :schema_element => [ 
    157161      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]] 
    …… 
    162166    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    163167    :schema_name => XSD::QName.new(nil, "loginResult"), 
    164     :schema_qualified => true, 
     168    :is_anonymous => true, 
     169    :schema_qualified => false, 
    165170    :schema_element => [ 
    166171      ["sessionID", "SOAP::SOAPString"] 

  • trunk/test/wsdl/anonymous/lp.wsdl

    r1954 r1979  
    9898  </message> 
    9999 
     100  <message name="echo_in"> 
     101    <part name="parameters" element="tns:Pack" /> 
     102  </message> 
     103  <message name="echo_out"> 
     104    <part name="parameters" element="tns:Envelope" /> 
     105  </message> 
     106 
    100107  <portType name="lp_porttype"> 
    101108    <operation name="login"> 
    102109      <input message="tns:login_in" /> 
    103110      <output message="tns:login_out" /> 
     111    </operation> 
     112 
     113    <operation name="echo"> 
     114      <input message="tns:echo_in" /> 
     115      <output message="tns:echo_out" /> 
    104116    </operation> 
    105117  </portType> 
    …… 
    109121    <operation name="login"> 
    110122      <soap:operation soapAction="urn:lp:login" style="document" /> 
     123      <input> 
     124        <soap:body use="literal" /> 
     125      </input> 
     126      <output> 
     127        <soap:body use="literal" /> 
     128      </output> 
     129    </operation> 
     130 
     131    <operation name="echo"> 
     132      <soap:operation soapAction="urn:lp:echo" style="document" /> 
    111133      <input> 
    112134        <soap:body use="literal" /> 

  • trunk/test/wsdl/anonymous/test_anonymous.rb

    r1963 r1979  
    2323        XSD::QName.new(Namespace, 'loginResponse') 
    2424      ) 
     25      add_document_method( 
     26        self, 
     27        Namespace + ':echo', 
     28        'echo', 
     29        XSD::QName.new(Namespace, 'Pack'), 
     30        XSD::QName.new(Namespace, 'Envelope') 
     31      ) 
     32      self.literal_mapping_registry = LpMappingRegistry::LiteralRegistry 
    2533    end 
    2634   
    …… 
    3038      LoginResponse.new(LoginResponse::LoginResult.new(sess)) 
    3139    end 
     40 
     41    def echo(pack) 
     42      raise unless pack.class == Pack 
     43      raise unless pack.header.class == Pack::Header 
     44      Envelope.new(Envelope::Header.new(pack.header.header1)) 
     45    end 
    3246  end 
    3347 
    …… 
    3650 
    3751  def setup 
     52    setup_clientdef 
    3853    setup_server 
    39     setup_clientdef 
    4054    @client = nil 
    4155  end 
    …… 
    99113    assert_equal("usernamepasswordtz", response.loginResult.sessionID) 
    100114  end 
     115 
     116  def test_anonymous_mapping 
     117    @client = Lp_porttype.new("http://localhost:#{Port}/") 
     118    @client.wiredump_dev = STDERR if $DEBUG 
     119    request = Pack.new(Pack::Header.new("pack_header")) 
     120    response = @client.echo(request) 
     121    assert_equal(Envelope, response.class) 
     122    assert_equal(Envelope::Header, response.header.class) 
     123    assert_equal("pack_header", response.header.header2) 
     124  end 
    101125end 
    102126 

  • trunk/test/wsdl/any/expectedMappingRegistry.rb

    r1964 r1979  
    2323    :class => WSDL::Any::FooBar, 
    2424    :schema_type => XSD::QName.new(NsEchoType, "foo.bar"), 
    25     :schema_qualified => false, 
    2625    :schema_element => [ 
    2726      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]], 
    …… 
    3433    :class => WSDL::Any::FooBar, 
    3534    :schema_name => XSD::QName.new(NsEchoType, "foo.bar"), 
    36     :schema_qualified => true, 
    3735    :schema_element => [ 
    3836      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]], 
    …… 
    4543    :class => WSDL::Any::SetOutputAndCompleteRequest, 
    4644    :schema_name => XSD::QName.new(NsEchoType, "setOutputAndCompleteRequest"), 
    47     :schema_qualified => true, 
    4845    :schema_element => [ 
    4946      ["taskId", ["SOAP::SOAPString", XSD::QName.new(nil, "taskId")]], 
    …… 
    5653    :class => WSDL::Any::SetOutputAndCompleteRequest::C_Data, 
    5754    :schema_name => XSD::QName.new(nil, "data"), 
    58     :schema_qualified => true, 
     55    :is_anonymous => true, 
     56    :schema_qualified => false, 
    5957    :schema_element => [ 
    6058      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]] 

  • trunk/test/wsdl/group/expectedMappingRegistry.rb

    r1923 r1979  
    3131    :class => WSDL::Group::Groupele_type, 
    3232    :schema_type => XSD::QName.new(NsGrouptype, "groupele_type"), 
    33     :schema_qualified => false, 
    3433    :schema_element => [ 
    3534      ["comment", "SOAP::SOAPString", [0, 1]], 
    …… 
    5049    :class => WSDL::Group::Groupele_type, 
    5150    :schema_name => XSD::QName.new(NsGrouptype, "groupele"), 
    52     :schema_qualified => true, 
    5351    :schema_element => [ 
    5452      ["comment", "SOAP::SOAPString", [0, 1]], 

  • trunk/test/wsdl/raa/expectedMappingRegistry.rb

    r1969 r1979  
    7373    :class => WSDL::RAA::Category, 
    7474    :schema_type => XSD::QName.new(NsC_002, "Category"), 
    75     :schema_qualified => false, 
    7675    :schema_element => [ 
    7776      ["major", ["SOAP::SOAPString", XSD::QName.new(nil, "major")]], 
    …… 
    8382    :class => WSDL::RAA::Product, 
    8483    :schema_type => XSD::QName.new(NsC_002, "Product"), 
    85     :schema_qualified => false, 
    8684    :schema_element => [ 
    8785      ["id", ["SOAP::SOAPInt", XSD::QName.new(nil, "id")]], 
    …… 
    10098    :class => WSDL::RAA::Owner, 
    10199    :schema_type => XSD::QName.new(NsC_002, "Owner"), 
    102     :schema_qualified => false, 
    103100    :schema_element => [ 
    104101      ["id", ["SOAP::SOAPInt", XSD::QName.new(nil, "id")]], 
    …… 
    111108    :class => WSDL::RAA::Info, 
    112109    :schema_type => XSD::QName.new(NsC_002, "Info"), 
    113     :schema_qualified => false, 
    114110    :schema_element => [ 
    115111      ["category", ["WSDL::RAA::Category", XSD::QName.new(nil, "category")]], 

  • trunk/test/wsdl/simpletype/rpc/expectedMappingRegistry.rb

    r1923 r1979  
    3434    :class => Version_struct, 
    3535    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    36     :schema_qualified => false, 
    3736    :schema_element => [ 
    3837      ["version", ["Version", XSD::QName.new(nil, "version")]], 
    …… 
    5554    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "zipIntType") 
    5655  ) 
     56 
    5757end 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedMappingRegistry.rb

    r1923 r1979  
    2424    :class => Version_struct, 
    2525    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    26     :schema_qualified => false, 
    2726    :schema_element => [ 
    2827      ["version", ["Version", XSD::QName.new(nil, "version")]], 

  • trunk/test/xsd/xsd2ruby/expected_mysample_mapping_registry.rb

    r1923 r1979  
    1111    :class => XSD::XSD2Ruby::Question, 
    1212    :schema_type => XSD::QName.new(NsMysample, "question"), 
    13     :schema_qualified => false, 
    1413    :schema_element => [ 
    1514      ["something", ["SOAP::SOAPString", XSD::QName.new(nil, "something")]] 
    …… 
    2019    :class => XSD::XSD2Ruby::Section, 
    2120    :schema_type => XSD::QName.new(NsMysample, "section"), 
    22     :schema_qualified => false, 
    2321    :schema_element => [ 
    2422      ["sectionID", ["SOAP::SOAPInt", XSD::QName.new(nil, "sectionID")]], 
    …… 
    4139    :class => XSD::XSD2Ruby::SectionElement, 
    4240    :schema_name => XSD::QName.new(NsMysample, "sectionElement"), 
    43     :schema_qualified => true, 
    4441    :schema_element => [ 
    4542      ["sectionID", ["SOAP::SOAPInt", XSD::QName.new(nil, "sectionID")]],