import SOAP-WSDL 2.00_14 from CPAN

git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_14 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_14.tar.gz
import SOAP-WSDL 2.00_13 from CPAN
2009-12-12 19:47:53 -08:00 · 2009-12-12 19:47:52 -08:00 · 2009-12-12 19:47:49 -08:00 · 2009-12-12 19:47:49 -08:00
192 changed files with 13575 additions and 7868 deletions
@@ -1,43 +1,41 @@
 use Module::Build;
 Module::Build->new(
-        create_makefile_pl => 'passthrough',
+	create_makefile_pl => 'passthrough',
-	dist_abstract => 'SOAP with WSDL support',
+	dist_abstract      => 'SOAP with WSDL support',
-	dist_name => 'SOAP-WSDL',
+	dist_name          => 'SOAP-WSDL',
-	dist_version => '2.00_10',
+	dist_version       => '2.00_14',
-	module_name   => 'SOAP::WSDL',
+	module_name        => 'SOAP::WSDL',
-	license       => 'artistic',
+	license            => 'artistic',
-	requires      => {
+	requires           => {
-	    'Class::Std' => q/v0.0.8/,
+		'Class::Std'              => q/v0.0.8/,
-	    'Class::Std::Storable' => 0,
+		'Class::Std::Storable'    => 0,
-	    'Date::Parse' => 0,
+		'Date::Parse'             => 0,
-	    'Date::Format' => 0,
+		'Date::Format'            => 0,
-            'LWP::UserAgent' => 0,
+		'LWP::UserAgent'          => 0,
-            'List::Util' => 0,
+		'List::Util'              => 0,
-            'File::Basename' => 0,
+		'File::Basename'          => 0,
-            'File::Path' => 0,
+		'File::Path'              => 0,
-            'XML::LibXML' => 0,
+		'XML::Parser::Expat'      => 0,
-            'XML::SAX::Base' => 0,
+		'Template'                => 0,
-            'XML::SAX::ParserFactory' => 0,
+		'Getopt::Long'            => 0,
            'XML::Parser::Expat' => 0,
 	},
 	buildrequires => {
-	    'Date::Parse' => 0,
+		'Date::Parse'             => 0,
-	    'Date::Format' => 0,
+		'Date::Format'            => 0,
-	    'Benchmark' => 0, 
+		'Test::More'              => 0,
-	    'Cwd' => 0,    
+		'Class::Std'              => q/v0.0.8/,
-	    'Test::More' => 0,
+		'Class::Std::Storable'    => 0,
-	    'Class::Std' => 0.0.8,
+		'List::Util'              => 0,
-	    'Class::Std::Storable' => 0,        
+		'LWP::UserAgent'          => 0,
-            'List::Util' => 0,
+		'File::Basename'          => 0,
-            'LWP::UserAgent' => 0,
+		'File::Path'              => 0,
-            'File::Basename' => 0,
+		'XML::Parser::Expat'      => 0,
-            'File::Path' => 0,
+		'Template'                => 0,	
-            'XML::Simple' => 0,
+		'Getopt::Long'            => 0,
-            'XML::LibXML' => 0,
+		'Cwd'                     => 0,
-            'XML::Parser::Expat' => 0,
+		'File::Find'              => 0,
-            'XML::SAX::Base' => 0,
+		'Storable'                => 0,
            'XML::SAX::ParserFactory' => 0,
            'Pod::Simple::Text' => 0,
 	},
 	recursive_test_files => 1,
 )->create_build_script;
@@ -1,639 +1,198 @@
------------------------------------------------------------------------
+Release notes for SOAP::WSDL 2.00_14
-r142 | kutterma | 2007-08-13 15:55:45 +0200 (Mo, 13 Aug 2007) | 1 line
+-------
-
+
-typo
+I'm very happy to present a new pre-release version of SOAP::WSDL.
------------------------------------------------------------------------
+
-r141 | kutterma | 2007-08-12 21:45:51 +0200 (So, 12 Aug 2007) | 2 lines
+SOAP::WSDL is a toolkit for creating SOAP interfaces in perl.
-
+
- corrected POD error
+Features:
- little speedup in add_FOO methods
+
------------------------------------------------------------------------
+    * WSDL based SOAP client
-r140 | kutterma | 2007-08-12 21:27:58 +0200 (So, 12 Aug 2007) | 1 line
+          o SOAP1.1 support
-
+          o Supports document/literal message style/encoding
- corrected POD error
+    * Code generator for generating WSDL-based interface classes
------------------------------------------------------------------------
+          o Generated code includes usage documentation for the web service interface
-r139 | kutterma | 2007-08-12 21:15:59 +0200 (So, 12 Aug 2007) | 1 line
+    * Easy-to use API. SOAP::WSDL is much easier to use than SOAP::Lite.
-
+          o Automatically encodes perl data structures as message data
- adder repository information
+          o Automatically sets HTTP headers right
------------------------------------------------------------------------
+    * SOAP::Lite like look and feel.
-r138 | kutterma | 2007-08-12 21:13:08 +0200 (So, 12 Aug 2007) | 1 line
+          o Where possible, SOAP::WSDL mimics SOAP::Lite's API to allow easy migrations
-
+    * XML schema based class library for creating data objects
- typo
+    * High-performance XML parser
------------------------------------------------------------------------
+    * Plugin support. SOAP::WSDL can be extended through plugins in various aspects. 
-r137 | kutterma | 2007-08-12 21:12:20 +0200 (So, 12 Aug 2007) | 3 lines
+      The following plugins are supported:
-
+          o Transport plugins via SOAP::WSDL::Factory::Transport
- updated docs
+          o Serializer plugins via SOAP::WSDL::Factory::Serializer
- added svn information
+          o Deserializer plugins via SOAP::WSDL::Factory::Serializer
- cosmetics
+
------------------------------------------------------------------------
+
-r136 | kutterma | 2007-08-12 15:11:50 +0200 (So, 12 Aug 2007) | 2 lines
+The following changes have been made:
-
+
- fixed element ref="" top level- elements in code generator
+2.00_14
- prepared 2.00_09 pre-release
+----
------------------------------------------------------------------------
+
-r135 | kutterma | 2007-08-12 14:44:06 +0200 (So, 12 Aug 2007) | 1 line
+The following bugs have been fixed (the numbers in square brackets are the 
-
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660921):
- prepared 2.00_09 pre-release
+
------------------------------------------------------------------------
+   * [ 1792235 ] SOAP::WSDL::Transport::Test missing from 2.00_13
-r134 | kutterma | 2007-08-12 14:30:33 +0200 (So, 12 Aug 2007) | 2 lines
+   The package has been re-added
-
+
- updated README
+   * [ 1792221 ] class_resolver not set from ::Client in 2.00_13
- bumped up version
+   Changed to set class_resolver correctly.
------------------------------------------------------------------------
+   
-r133 | kutterma | 2007-08-12 14:27:17 +0200 (So, 12 Aug 2007) | 1 line
+The following uncategorized improvements have been made:
-
+
- fixed Build.PL to leave Makefile.PL untouched.
+   * The ::SOM deserializer has been simplified to be just a subclass 
------------------------------------------------------------------------
+   of SOAP::Deserializer from SOAP::Lite
-r132 | kutterma | 2007-08-12 14:21:24 +0200 (So, 12 Aug 2007) | 1 line
+   * Factories now emit more useful error messages when no class is registered
-
+   for the protocol/soap_version requested
- now really added Makefile.PL
+   * Documentation has been improved
------------------------------------------------------------------------
+      - refined ::Factory:: modules' documentation
-r131 | kutterma | 2007-08-12 14:18:59 +0200 (So, 12 Aug 2007) | 3 lines
+   * Several tests have been added
-
+   * XSD classes have been improved for testability
- fixed documentation for generated code with element ref="" declarations
+
- fixed element ref="" test for generated code
+2.00_13
- added (generated) Makefile.PL to make CPAN testers happy
+----
------------------------------------------------------------------------
+The following features were added (the numbers in square brackets are the 
-r130 | kutterma | 2007-08-10 15:57:12 +0200 (Fr, 10 Aug 2007) | 1 line
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660924):
-
+
- first try at truely callback-based parser (inspired by XML::Compile)
+   * [ 1790619 ] Test transport backend
------------------------------------------------------------------------
+   A test transport backend has been implemented (SOAP::WSDL::Transport::Test).
-r129 | kutterma | 2007-08-07 17:53:40 +0200 (Di, 07 Aug 2007) | 1 line
+   It returns the contents from a file and discards the response.
-
+   The filename is determined from the soap_action field.
- moved duplicate sub generation out of loop
+   
------------------------------------------------------------------------
+   * [ 1785196 ] Replace outputsom(1) by deserializer plugin
-r128 | kutterma | 2007-08-07 14:16:28 +0200 (Di, 07 Aug 2007) | 1 line
+   outputsom(1) in SOAP::WSDL is now implemented via using the deserializer 
-
+   plugin SOAP::WSDL::Deserializer::SOM.
- bool now returns numerical value in bool context, not "true" or "false" (always true...)
+
------------------------------------------------------------------------
+   * [1785195] Support deserializer plugins
-r127 | kutterma | 2007-08-07 11:45:23 +0200 (Di, 07 Aug 2007) | 1 line
+   Deserializer plugin API added via SOAP::WSDL::Factory::Deserializer.
-
+  
- fixed test to be timezone sensitive
+The following bugs have been fixed (the numbers in square brackets are the 
------------------------------------------------------------------------
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660921):
-r126 | kutterma | 2007-08-07 11:09:51 +0200 (Di, 07 Aug 2007) | 1 line
+
-
+   * [1789581] Support ComplexType mixed
- made test timezone-sensitive
+   WSDL parser now supports using the mixed="true" attribute in complexType 
------------------------------------------------------------------------
+   definitions. Mixed content in messages is only supported via SOAP::SOM yet.
-r125 | kutterma | 2007-08-07 11:09:16 +0200 (Di, 07 Aug 2007) | 1 line
+
-
+   * [1787975] 016_client_object.t fails due to testing XML as string
- made test timezone-sensitive
+   Removed string test.
------------------------------------------------------------------------
+  
-r124 | kutterma | 2007-08-06 18:05:02 +0200 (Mo, 06 Aug 2007) | 2 lines
+   * [1787959] Test wsdl seems to be broken
-
+   Corrected typo.
- fixed element ref handling in code generator in ComplexType. 
+  
- top-level element ref still not supported/tested
+   * [1787955] ::XSD::Typelib::date is broken
------------------------------------------------------------------------
+   SOAP::WSDL::XSD::Typelib::Builtin::date now converts time-zoned dates properly, 
-r123 | kutterma | 2007-08-06 17:48:57 +0200 (Mo, 06 Aug 2007) | 1 line
+   and adds the local time zone if none is given.
-
+
- test now dies and outputs code to eval on eval errors
+   * [1785646] SOAPAction header not set from soap:operation soapAction
------------------------------------------------------------------------
+   SOAP::WSDL now sets the SOAPAction header correctly.
-r122 | kutterma | 2007-08-06 17:29:46 +0200 (Mo, 06 Aug 2007) | 1 line
+
-
+The following uncategorized improvements have been made:
- fixed element ref="" handling in complexType
+
------------------------------------------------------------------------
+   * Documentation improvements
-r121 | kutterma | 2007-08-06 17:29:14 +0200 (Mo, 06 Aug 2007) | 1 line
+
-
+2.00_12
- added test data for element ref inside complexType
+----
------------------------------------------------------------------------
+  
-r120 | kutterma | 2007-08-06 17:28:54 +0200 (Mo, 06 Aug 2007) | 1 line
+The following bugs have been fixed (the numbers in square brackets are the 
-
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660921):
- added test for element ref inside complexType
+
------------------------------------------------------------------------
+   * [1787146] SOAP::WSDL still uses XML::LibXML
-r119 | kutterma | 2007-08-06 17:13:03 +0200 (Mo, 06 Aug 2007) | 1 line
+   The superficious usage of XML::LibXML has been removed. XML::LibXML with 
-
+   sax filter has been replaced by SOAP::WSDL::Expat::WSDLParser.
- fixed element ref handling
+   
------------------------------------------------------------------------
+   * [1787054] Test suite requires XML::LibXML in 2.00_11
-r118 | kutterma | 2007-08-06 17:12:47 +0200 (Mo, 06 Aug 2007) | 1 line
+   The test suite no longer requires XML::LibXML to pass.
-
+
- added element ref test data
+   * [1785678] SOAP envelope not checked for namespace
------------------------------------------------------------------------
+   The SOAP envelope is now checked for the correct namespace.
-r117 | kutterma | 2007-08-06 17:12:36 +0200 (Mo, 06 Aug 2007) | 1 line
+   
-
+   * [1786644] SOAP::WSDL::Manual - doc error
- added element ref test
+   Documentation improvements
------------------------------------------------------------------------
+    
-r116 | kutterma | 2007-08-06 15:47:30 +0200 (Mo, 06 Aug 2007) | 1 line
+The following uncategorized improvements have been made
-
+
- refined docs
+   * The SOAPAction header is now alway quoted (R1109 in WS-I BP 1.0).
------------------------------------------------------------------------
+   
-r115 | kutterma | 2007-08-06 15:39:39 +0200 (Mo, 06 Aug 2007) | 1 line
+2.00_11
-
+----
- updated docs. Hope the CPAN indexer ignores "=for developers"...
+
------------------------------------------------------------------------
+The following features were added (the numbers in square brackets are the 
-r114 | kutterma | 2007-08-06 14:12:28 +0200 (Mo, 06 Aug 2007) | 1 line
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660924):
-
+
- removed annoying pod 
+  * [1767963] Transport plugins via SOAP::WSDL::Factory::Transport.
------------------------------------------------------------------------
+    SOAP::WSDL uses SOAP::Lite's tranport modules as default, with a 
-r113 | kutterma | 2007-08-05 18:42:09 +0200 (So, 05 Aug 2007) | 5 lines
+    lightweight HTTP(S) transport plugin as fallback.
-
+    Custom transport modules can be registered via SOAP::WSDL::Factory::Transport.
- removed SOAP::Lite dependency
+
- updated docs
+  * [ 1772730 ] Serializer plugins via SOAP::WSDL::Factory::Serializer 
- changed SOAP::WSDL::XSD::Typelib::ComplexType to require the actuall class for element data, not just the base class (good for finding errors earlier)
+    The default serializer for SOAP1.1 is SOAP::WSDL::Serializer::SOAP11.
- implemented returning SOAP::SOM objects in SOAP::WSDL
+    Custom serializers classes can be registered via 
- added SOAP::WSDL example(weather_wsdl.pl)
+    SOAP::WSDL::Factory::Serializer or set via SOAP::WSDL's set_serializer 
------------------------------------------------------------------------
+    method.
-r112 | kutterma | 2007-08-03 16:12:57 +0200 (Fr, 03 Aug 2007) | 1 line
+
-
+The following bugs have been fixed (the numbers in square brackets are the 
-updated docs
+tracker IDs from https://sourceforge.net/tracker/?group_id=111978&atid=660921):
------------------------------------------------------------------------
+
-r111 | kutterma | 2007-08-03 16:12:04 +0200 (Fr, 03 Aug 2007) | 1 line
+   * [ 1764854 ] Port WSDL parser to expat and remove XML::LibXML dependency
-
+     SOAP::WSDL now requires only XML::Parser to be installed.
- added "skip"
+     XML::LibXML is not required any more, though XML::LibXML based modules still 
------------------------------------------------------------------------
+     exist.
-r110 | kutterma | 2007-07-31 22:27:25 +0200 (Di, 31 Jul 2007) | 2 lines
+
-
+The following uncategorized improvements have been made
- further work on removing SOAP::Lite dependency
+
- Note: SOAP::WSDL may be broken !
+   * The number of dependencies has been reduced. SOAP::WSDL no longer requires the 
------------------------------------------------------------------------
+     following modules to be installed:
-r109 | kutterma | 2007-07-31 21:10:40 +0200 (Di, 31 Jul 2007) | 3 lines
+        - XML::SAX::Base
-
+        - XML::SAX::ParserFactory
- finished move from XSD::Primitive to Builtin
+        - Pod::Simple::Text
- fixed a few tests
+        - XML::LibXML
- removed typo namespace from TypeLookupt
+
------------------------------------------------------------------------
+   * The missing prerequisite Template has been added.
-r108 | kutterma | 2007-07-31 21:02:43 +0200 (Di, 31 Jul 2007) | 1 line
+   * Documentation has been improved:
-
+        - WS-I Compliance document added.
- removed unneeded example stuff
+
------------------------------------------------------------------------
+
-r107 | kutterma | 2007-07-31 20:32:43 +0200 (Di, 31 Jul 2007) | 1 line
+2.00_10
-
+----
- rename to Builtin
+   * Changed Makefile.PL to use Module::Build (passthrough mode)
------------------------------------------------------------------------
+   * fixed element ref="" handling
-r106 | kutterma | 2007-07-31 20:32:11 +0200 (Di, 31 Jul 2007) | 1 line
+
-
+2.00_09
- prepared rename to Builtin
+----
------------------------------------------------------------------------
+   * SOAP::WSDL::XSD::Typelib::Builtin::boolean objects now return their numerical 
-r105 | kutterma | 2007-07-31 13:17:52 +0200 (Di, 31 Jul 2007) | 2 lines
+     value in bool context, not "true" or "false" (always true...)
-
+   * date/time test are now timezone-sensitive
- added configurable ContentType / charset 
+   * examples added
- maybe split up charset and content type into two methods ?
+
------------------------------------------------------------------------
+2.00_08
-r104 | kutterma | 2007-07-31 00:16:15 +0200 (Di, 31 Jul 2007) | 3 lines
+---
-
+   * SOAP::WSDL::XSD::Typelib::ComplexType objects now check the class of their 
- removed optional nanoseconds from dateTime conversions
+     child objects.
- added conversion to date objects
+     This provides early feedback to developers.
- removed fetching WSDL via SOAP::Schema in SOAP::WSDL. SOAP::Lite is still used as base class.
+   * SOAP message parser can skip unwanted parts of the message to improve parsing 
------------------------------------------------------------------------
+     speed - see SOAP::WSDL::Expat::MessageParser for details.
-r103 | kutterma | 2007-07-30 13:25:06 +0200 (Mo, 30 Jul 2007) | 1 line
+   * HTTP Content-Type is configurable
-
+   * SOAP::WSDL::XSD::Typelib::ComplexType based objects accept any combination of 
- updated TODO
+     hash refs, list refs and objects as parameter to set_value() and new().
------------------------------------------------------------------------
+   * SOAP::WSDL::XSD::Typelib::Builtin::dateTime and ::date convert date 
-r102 | kutterma | 2007-07-30 13:23:09 +0200 (Mo, 30 Jul 2007) | 2 lines
+      strings into XML date strings
-
+   * SOAP::WSDL::Definitions::create now
- updated Build.PL dependencies
+      - converts '.' in service names to '::' (.NET class separator to perl class 
- update TODO
+      separator)
------------------------------------------------------------------------
+      - outputs Typemaps and Interface classes in UTF8 to allow proper inclusion 
-r101 | kutterma | 2007-07-30 13:22:05 +0200 (Mo, 30 Jul 2007) | 2 lines
+      of UTF8 documentation from WSDL
-
+   * SOAP::WSDL::Definitions::create() includes doc in generated interface classes
- added dateTime test
+   * WSDLHandler now handles <wsdl:documentation> tags
- fixed pod test
+   * fixed explain in SimpleType, ComplexType and Element
------------------------------------------------------------------------
+
-r100 | kutterma | 2007-07-27 16:03:15 +0200 (Fr, 27 Jul 2007) | 2 lines
+2.00_07 and below
-
+---
- allow passing list refs of hash refs to set_value.
+   * Implemented a Code generator for creating SOAP interfaces based on WSDL definitions
-I hope I got all combinations by now - start getting ugly...
+   * Implemented a high-speed stream based SOAP message parser
------------------------------------------------------------------------
+     SOAP message parser returns a objects based on XML schema based class library
-r99 | kutterma | 2007-07-26 23:18:35 +0200 (Do, 26 Jul 2007) | 1 line
+   * Implemented a XML schema based class library 
-
+   * Implemented a stream based WSDL parser.
- added SOAP::Lite usage (to be removed later)
+     Parses WSDL into objects. Objects can serialize data, and explain how to use the 
------------------------------------------------------------------------
+     service(s) they make up (output documentation).
 r98 | kutterma | 2007-07-26 23:16:30 +0200 (Do, 26 Jul 2007) | 3 lines
 - removed SOAP::Lite dependency
 - added set_trace and tracing facility support via callback in call()
 - added fault_class property to allow different Fault classes (somewhen later on)
 ------------------------------------------------------------------------
 r97 | kutterma | 2007-07-25 16:59:49 +0200 (Mi, 25 Jul 2007) | 3 lines
 - dateTime now converts date strings into XML date strings
 - updated docs
 ------------------------------------------------------------------------
 r96 | kutterma | 2007-07-23 11:17:36 +0200 (Mo, 23 Jul 2007) | 3 lines
 - SOAP::WSDL::Definitions::create now
   - converts '.' in service names to '::' (.NET class separator to perl class separator)
   - outputs Typemaps and Interface classes in UTF8 to allow proper inclusion of UTF8 documentation from WSDL
 ------------------------------------------------------------------------
 r95 | kutterma | 2007-07-23 10:26:59 +0200 (Mo, 23 Jul 2007) | 1 line
 - typo
 ------------------------------------------------------------------------
 r94 | kutterma | 2007-07-23 10:11:46 +0200 (Mo, 23 Jul 2007) | 1 line
 - typo
 ------------------------------------------------------------------------
 r93 | kutterma | 2007-07-22 23:24:12 +0200 (So, 22 Jul 2007) | 1 line
 updated TODO
 ------------------------------------------------------------------------
 r92 | kutterma | 2007-07-22 23:19:15 +0200 (So, 22 Jul 2007) | 3 lines
 - WSDLHandler now handles <wsdl:documentation> tags
 - SOAP::WSDL::Definitions now includes some usable doc in generated interface classes
 - fixed explain in SimpleType, ComplexType and Element (someway)
 ------------------------------------------------------------------------
 r91 | kutterma | 2007-07-22 21:18:21 +0200 (So, 22 Jul 2007) | 1 line
 - updated docs
 ------------------------------------------------------------------------
 r90 | kutterma | 2007-07-22 15:42:23 +0200 (So, 22 Jul 2007) | 1 line
 - updated docs
 ------------------------------------------------------------------------
 r89 | kutterma | 2007-07-22 15:38:25 +0200 (So, 22 Jul 2007) | 2 lines
 - updated docs
 - removed useless docs from "internally used only" - modules
 ------------------------------------------------------------------------
 r88 | kutterma | 2007-07-22 09:17:57 +0200 (So, 22 Jul 2007) | 1 line
 typo
 ------------------------------------------------------------------------
 r87 | kutterma | 2007-07-21 23:57:46 +0200 (Sa, 21 Jul 2007) | 1 line
 - updated docs
 ------------------------------------------------------------------------
 r86 | kutterma | 2007-07-21 23:24:24 +0200 (Sa, 21 Jul 2007) | 5 lines
 - removed irritating pod from SOAP::WSDL::XSD::Typelib::Builtin::* classes and put int into SOAP::WSDL::XSD::Typelib::Builtin
 - added fast constructor creation BEGIN block to all SOAP::WSDL::XSD::Typelib::Builtin::* classes
 - added examples
 - updated docs
 - prepared 2.00_07 pre-release
 ------------------------------------------------------------------------
 r85 | kutterma | 2007-07-21 18:12:49 +0200 (Sa, 21 Jul 2007) | 4 lines
 - added wsdl2perl code generation script - works against FortuneCookie web service at fullerdata.com
 - fixed SOAP::WSDL::Client::Base to work as base class for generated classes
 - added interface generation facility to SOAP::WSDL::Definitions
 - updated docs (a few)
 ------------------------------------------------------------------------
 r84 | kutterma | 2007-07-20 15:37:40 +0200 (Fr, 20 Jul 2007) | 9 lines
 - added Expat-based parser
 - made Expat-based parser the default
 - added fast "new" method to most important "Builtin" types 
 - added Parser POD
 - fixed propagating element names in complex types to element elements - element ref="element" should work on 
 class level now (don't know whether typelib supports it yet)
 - updated tests
 - updated HACKING
 - prepared 2.00_06 release
 ------------------------------------------------------------------------
 r83 | kutterma | 2007-07-19 13:09:33 +0200 (Do, 19 Jul 2007) | 1 line
 - fixed element class generation (removed additional ::)
 ------------------------------------------------------------------------
 r82 | kutterma | 2007-07-17 22:17:02 +0200 (Di, 17 Jul 2007) | 1 line
 - updated README and HACKING
 ------------------------------------------------------------------------
 r81 | kutterma | 2007-07-17 22:00:14 +0200 (Di, 17 Jul 2007) | 5 lines
 - added parent ref in SOAP::WSDL::Base - now we have a real tree, and maybe can completely support namespaces some day
 - replaced grep by List::Util::first where appropriate
 - code cleanup
 - fixed test for Code Generation
 - updated a few tests
 ------------------------------------------------------------------------
 r80 | kutterma | 2007-07-17 17:00:48 +0200 (Di, 17 Jul 2007) | 1 line
 - improved pod in generated classes
 ------------------------------------------------------------------------
 r79 | kutterma | 2007-07-17 14:41:44 +0200 (Di, 17 Jul 2007) | 1 line
 - made explain look nicer
 ------------------------------------------------------------------------
 r78 | kutterma | 2007-07-15 12:25:03 +0200 (So, 15 Jul 2007) | 7 lines
 - SOAP::WSDL::Definitions can now generate
   - Typemaps
   - Type and Element classes
 - fixed SOAP::WSDL::XSD::Typelib::ComplexType to support elements with type="ComplexType" definitions
 - moved toClass method in SOAP::WSDL::XSD::ComplexType, Element and SimpleType to to_class and added compatibility wrapper with warning for toClass calls
 - added generator test
 - updated docs
 ------------------------------------------------------------------------
 r77 | kutterma | 2007-07-14 10:46:54 +0200 (Sa, 14 Jul 2007) | 1 line
 - started working on high-level code generator
 ------------------------------------------------------------------------
 r76 | kutterma | 2007-07-13 09:21:33 +0200 (Fr, 13 Jul 2007) | 1 line
 - fixed handling of complex data (hashes with lists embedded lists of objects)
 ------------------------------------------------------------------------
 r75 | kutterma | 2007-07-10 12:08:39 +0200 (Di, 10 Jul 2007) | 1 line
 - removed unneeded SOAP::Lite calls
 ------------------------------------------------------------------------
 r74 | kutterma | 2007-07-10 12:08:10 +0200 (Di, 10 Jul 2007) | 1 line
 - updated to new SOAP::Lite API
 ------------------------------------------------------------------------
 r73 | kutterma | 2007-07-10 12:00:25 +0200 (Di, 10 Jul 2007) | 6 lines
 - re-integrated old SOAP::WSDL tests
 - updated docs
 - SOAP::WSDL::XSD::Typelib::Builtin::string now escapes XML builtin entities on serialization
 - SOAP::WSDL::XSD::Element now supports generating classes for elements and types into different namespaces
 - SOAP::WSDL::Definitions now supports different namespaces for elements and types when generating typmaps
 - 2.00_05 release preparation
 ------------------------------------------------------------------------
 r72 | kutterma | 2007-07-06 11:20:56 +0200 (Fr, 06 Jul 2007) | 1 line
 - fixed detail (typo)
 ------------------------------------------------------------------------
 r71 | kutterma | 2007-07-05 16:13:28 +0200 (Do, 05 Jul 2007) | 1 line
 - TODO comments added
 ------------------------------------------------------------------------
 r70 | kutterma | 2007-07-04 16:14:50 +0200 (Mi, 04 Jul 2007) | 2 lines
 - updated docs
 - prepared 2.00_04 release
 ------------------------------------------------------------------------
 r69 | kutterma | 2007-07-04 16:07:54 +0200 (Mi, 04 Jul 2007) | 1 line
 - ComplexType now ignores xmlns - TODO: check xmlns, don't ignore...
 ------------------------------------------------------------------------
 r68 | kutterma | 2007-07-04 11:25:31 +0200 (Mi, 04 Jul 2007) | 1 line
 - made builtin types with overloads serializable
 ------------------------------------------------------------------------
 r67 | kutterma | 2007-07-04 09:51:06 +0200 (Mi, 04 Jul 2007) | 4 lines
 - updated docs
 - removed unneeded uses from test
 - added Build requirements from tests
 - prepared 2.00_03 release
 ------------------------------------------------------------------------
 r66 | kutterma | 2007-07-04 00:06:29 +0200 (Mi, 04 Jul 2007) | 3 lines
 - split up builtin type lib into single files for Class::Std::Storable
 - fixed more tests
 - fixed complexType serialization for non-objecs
 ------------------------------------------------------------------------
 r65 | kutterma | 2007-07-03 16:52:54 +0200 (Di, 03 Jul 2007) | 2 lines
 - fixed a few tests
 - added performance improvements
 ------------------------------------------------------------------------
 r64 | kutterma | 2007-07-03 15:09:27 +0200 (Di, 03 Jul 2007) | 1 line
 - small performance improvements
 ------------------------------------------------------------------------
 r63 | kutterma | 2007-07-03 14:37:28 +0200 (Di, 03 Jul 2007) | 3 lines
 - fixed serializing complextypes correctly
 - fixed handling has attribute refs in new
 - fixed performance problems in MessageHandler
 ------------------------------------------------------------------------
 r62 | kutterma | 2007-07-03 14:37:14 +0200 (Di, 03 Jul 2007) | 1 line
 - re-added
 ------------------------------------------------------------------------
 r61 | kutterma | 2007-07-03 14:36:59 +0200 (Di, 03 Jul 2007) | 1 line
 ------------------------------------------------------------------------
 r60 | kutterma | 2007-07-01 09:52:41 +0200 (So, 01 Jul 2007) | 2 lines
 - fixed lots of tests
 - attic tests may be re-integrated now...
 ------------------------------------------------------------------------
 r59 | kutterma | 2007-06-28 13:07:35 +0200 (Do, 28 Jun 2007) | 1 line
 - added ignore for dist tar.gz
 ------------------------------------------------------------------------
 r58 | kutterma | 2007-06-28 13:06:25 +0200 (Do, 28 Jun 2007) | 1 line
 - updated buildrequires
 ------------------------------------------------------------------------
 r57 | kutterma | 2007-06-28 13:05:03 +0200 (Do, 28 Jun 2007) | 1 line
 - typo
 ------------------------------------------------------------------------
 r56 | kutterma | 2007-06-28 11:15:24 +0200 (Do, 28 Jun 2007) | 1 line
 - pre-release 2.00_01
 ------------------------------------------------------------------------
 r55 | kutterma | 2007-06-28 10:23:20 +0200 (Do, 28 Jun 2007) | 1 line
 - moved old tests to attic
 ------------------------------------------------------------------------
 r54 | kutterma | 2007-06-28 10:15:41 +0200 (Do, 28 Jun 2007) | 1 line
 - fixed a few typos
 ------------------------------------------------------------------------
 r53 | kutterma | 2007-06-28 10:10:41 +0200 (Do, 28 Jun 2007) | 3 lines
 - fixed MessageHandler to support deserializing into objects which return false in boolean context
 - updated docs
 - fixed Fault11 (named detail correctly)
 ------------------------------------------------------------------------
 r52 | kutterma | 2007-06-27 17:36:01 +0200 (Mi, 27 Jun 2007) | 3 lines
 - added Fault for SOAP 1.1 implementation
 - fixed ComplexType - though it doesn't work quite for faults yet...
 ------------------------------------------------------------------------
 r51 | kutterma | 2007-06-27 13:27:59 +0200 (Mi, 27 Jun 2007) | 13 lines
 - added test for sending objects via call()
 - modified Client to accept objects of type SOAP::WSDL::XSD::Typelib::Builtin::anyType as message content 
 without checking the WSDL objects
 Note: 
 - SOAPAction is just guessed - needs to be replaced by something better
 - The method should be looked up from the typelib, too, and serialized according to the rules specified in the WSDL 
 and dumped into the typelib.
 - updated to_typelib to include top element
 - fixed element and complextype templates for toClass
 ------------------------------------------------------------------------
 r50 | kutterma | 2007-06-27 00:01:32 +0200 (Mi, 27 Jun 2007) | 1 line
 - added xsi xmlns to envelope
 ------------------------------------------------------------------------
 r49 | kutterma | 2007-06-26 23:52:18 +0200 (Di, 26 Jun 2007) | 1 line
 - cosmetics and a few doc updates
 ------------------------------------------------------------------------
 r48 | kutterma | 2007-06-26 22:47:52 +0200 (Di, 26 Jun 2007) | 2 lines
 - refactored element serializing to make it somewhat more consistent
 - added nillable implementation for Elements
 ------------------------------------------------------------------------
 r47 | kutterma | 2007-06-26 18:06:59 +0200 (Di, 26 Jun 2007) | 1 line
 - removed shebang
 ------------------------------------------------------------------------
 r46 | kutterma | 2007-06-26 18:06:33 +0200 (Di, 26 Jun 2007) | 1 line
 - added warnings
 ------------------------------------------------------------------------
 r45 | kutterma | 2007-06-26 17:39:09 +0200 (Di, 26 Jun 2007) | 3 lines
 - got toClass working for generating WSDL based type libraries.
 - changed typelib base class behavior to qualify first element called.
 TODO (a bigger one): Fully support namespaces...
 ------------------------------------------------------------------------
 r44 | kutterma | 2007-06-26 12:10:33 +0200 (Di, 26 Jun 2007) | 14 lines
 - changed Typelib::Element to work as attribute of a type (serialize serializes start_tag and end_tag provided by Typelib::Element around it's vontent, if present)
 - worked on toClass functionality with embedded templates.
 There's much to do - current impl should support:
   * <element name="name" type="type"
   * <element name="name"><simpleType>
   * <element name="name"><complexType>
   * <simpleType ...><list>
   * <simpleType ...><restriction>
   * <complexType ...><all>
   * <complexType ...><sequence>
 All other variants are not completely supported yet.
 ------------------------------------------------------------------------
 r43 | kutterma | 2007-06-25 18:58:56 +0200 (Mo, 25 Jun 2007) | 1 line
 - broke element again...
 ------------------------------------------------------------------------
 r42 | kutterma | 2007-06-25 17:30:34 +0200 (Mo, 25 Jun 2007) | 3 lines
 - fixed to_typemap to report atomic simple and complex types correctly
 - update tests
 - renamed WSDLFilter to WSDLHandler
 ------------------------------------------------------------------------
 r41 | kutterma | 2007-06-25 17:29:41 +0200 (Mo, 25 Jun 2007) | 1 line
 ------------------------------------------------------------------------
 r40 | kutterma | 2007-06-25 14:15:40 +0200 (Mo, 25 Jun 2007) | 2 lines
 - Client.pm now uses XML::LibXML as default and falls back on XML::SAX::ParserFactory if not present
 - fixed tests
 ------------------------------------------------------------------------
 r39 | kutterma | 2007-06-25 14:07:28 +0200 (Mo, 25 Jun 2007) | 2 lines
 - typo in Element
 - fixed tests
 ------------------------------------------------------------------------
 r38 | kutterma | 2007-06-25 10:31:20 +0200 (Mo, 25 Jun 2007) | 2 lines
 - made WSDLFilter.pm a inside out class and let it run without XML::SAX::Base (This probably breaks a lot of tests - we need to implement XML::LibXML semantics in all tests / classes which use it)
 - first swag at to_typemap Typemap generation. to_typemap implemented throughout the WSDL:: modules. Some implementations (Elenenet.pm, ComplexType.pm) need further work for correctly handling atomic simpleType / complexType definitions.
 ------------------------------------------------------------------------
 r37 | kutterma | 2007-06-24 09:15:22 +0200 (So, 24 Jun 2007) | 3 lines
 - added test for on-the-fly created ComplexType
 - fixed ComplexType factory to really work
 - startet working on Element facets
 ------------------------------------------------------------------------
 r36 | kutterma | 2007-06-24 09:14:46 +0200 (So, 24 Jun 2007) | 2 lines
 - added test for on-the-fly created ComplexType
 - startet working on Element facets
 ------------------------------------------------------------------------
 r35 | kutterma | 2007-06-24 08:13:32 +0200 (So, 24 Jun 2007) | 1 line
 - implemented ComplexType as class factory to get rid of the annoying START every subclass had to implement.
 ------------------------------------------------------------------------
 r34 | kutterma | 2007-06-23 23:22:35 +0200 (Sa, 23 Jun 2007) | 2 lines
 - added XSD Typelib SimpleType, Element and ComplexType base classes (stereotypes).
 ComplexType's not yet complete (no restriction / extension etc. handling).
 ------------------------------------------------------------------------
 r33 | kutterma | 2007-06-23 11:04:56 +0200 (Sa, 23 Jun 2007) | 2 lines
 - added SOAP::WSDL::XSD::Typelib::Builtin implementation of builtin XML Schema datatypes with built-in stringification, boolification and numerification.
 - SAX::MessageHandler now deserializes simple types in SOAP messages into SOAP::WSDL::XSD::Typelib::Builtin (provided these are named in the ClassResolver...)
 ------------------------------------------------------------------------
 r32 | kutterma | 2007-06-23 02:14:16 +0200 (Sa, 23 Jun 2007) | 4 lines
 - added pod
 - added ref handling for elements
 - added abstract handling for elements (easy...)
 - added storing of content model (simpleContent/complexContent) to simpleType and complexType, though the attribute is still ignored in serializing
 ------------------------------------------------------------------------
 r31 | kutterma | 2007-06-23 00:37:18 +0200 (Sa, 23 Jun 2007) | 1 line
 - renamed MessageFilter to MessageHandler
 ------------------------------------------------------------------------
 r30 | kutterma | 2007-06-23 00:35:54 +0200 (Sa, 23 Jun 2007) | 1 line
 - renamed MessageFilter to MessageHandler
 ------------------------------------------------------------------------
 r29 | kutterma | 2007-06-23 00:35:16 +0200 (Sa, 23 Jun 2007) | 2 lines
 - switched to Class::Std::Storable
 - renamed MessageFilter to MessageHandler
 ------------------------------------------------------------------------
 r28 | kutterma | 2007-06-22 18:56:28 +0200 (Fr, 22 Jun 2007) | 3 lines
 - optimised SOAP::WSDL::SAX::MessageFilter for performance
 - moved Typelob into own directory and load it dynamically from test script
 - added some pod
 ------------------------------------------------------------------------
 r27 | kutterma | 2007-06-22 15:34:28 +0200 (Fr, 22 Jun 2007) | 5 lines
 - modified SOAP::WSDL::XSD lib to allow serializing of object hierarchies
 - added SOAP::WSDL::SAX::MessageFilter for creating object hierarchies from SOAP messages
 - moved Builtin XML Schema types to SOAP::WSDL:XSD::Schema::Builtin
 - added test + benchmark for serializing /deserializing SOAP messages into object trees
 - fixed Client to use SOAP::WSDL::Types as typelib, not first SOAP::WSDL::XSD::Schema
 ------------------------------------------------------------------------
 r26 | kutterma | 2007-06-21 23:35:30 +0200 (Do, 21 Jun 2007) | 2 lines
 - first swag at a typed SOAP Message parser.
 Typelib is still to be implemented...
 ------------------------------------------------------------------------
 r25 | kutterma | 2007-06-21 18:14:49 +0200 (Do, 21 Jun 2007) | 1 line
 - added missing files from last commit
 ------------------------------------------------------------------------
 r24 | kutterma | 2007-06-19 00:29:36 +0200 (Di, 19 Jun 2007) | 3 lines
 - worked a bit on explain
 - introduced handling of multiple schema definitions in one WSDL file
 - fixed propagating targetNamespace to child elements in WSDLFilter
 ------------------------------------------------------------------------
 r23 | kutterma | 2007-06-16 14:48:30 +0200 (Sa, 16 Jun 2007) | 1 line
 - updated new SOAP::WSDL framework to use inside out classes based on Class::Std (not yet complete)
 ------------------------------------------------------------------------
 r22 | kutterma | 2007-06-12 23:19:41 +0200 (Di, 12 Jun 2007) | 4 lines
 - updated a few tests
 - fixed a few WSDLs
 - fixed handling of elements with minOccurs 0
 - fixed setting of minOccurs/maxOccurs for all/sequence complexTypes
 ------------------------------------------------------------------------
 r21 | kutterma | 2007-06-08 21:38:41 +0200 (Fr, 08 Jun 2007) | 2 lines
 - updated a few tests
 - fixed namespaces in tests
 ------------------------------------------------------------------------
 r19 | kutterma | 2007-05-31 16:58:18 +0200 (Do, 31 Mai 2007) | 10 lines
 - first swag at a WSDL-generated Object-tree based SOAP client.
 Works as following: 
 a) a sax filter transforms the sax stream from a wsdl into a perl object tree
 b) the perl object tree has methods for performing the following tasks:
   a) explain: Tell what services and methods are there, and how to use them
   b) serialize: Serialize data structures to the XML defined in the WSDL & schema
 c) The client uses the generated XML to call the SOAP Server. Unfortunately, SOAP::Lite 
 does not allow custom XML to be rendered as a method's "value", so we have to replace 
 call() completely and generate the envelope on our own (which is not complete yet).
 ------------------------------------------------------------------------
 r9 | kutterma | 2007-05-28 17:08:41 +0200 (Mo, 28 Mai 2007) | 1 line
 - first try at bindings support - see t/12/bindings on how we could find out bindings and portname from a target URL
 ------------------------------------------------------------------------
 r4 | kutterma | 2007-05-28 15:15:03 +0200 (Mo, 28 Mai 2007) | 1 line
 - move from private repository to sourceforge
 ------------------------------------------------------------------------
@@ -1,3 +1,7 @@
 benchmark/01_expat.t
 benchmark/XSD/01_anyType.t
 benchmark/XSD/02_anySimpleType.t
 benchmark/XSD/03_string.t
 bin/wsdl2perl.pl
 Build.PL
 CHANGES
@@ -32,11 +36,19 @@ lib/SOAP/WSDL/Binding.pm
 lib/SOAP/WSDL/Client.pm
 lib/SOAP/WSDL/Client/Base.pm
 lib/SOAP/WSDL/Definitions.pm
-lib/SOAP/WSDL/Envelope.pm
+lib/SOAP/WSDL/Deserializer/SOAP11.pm
 lib/SOAP/WSDL/Deserializer/SOM.pm
 lib/SOAP/WSDL/Expat/MessageParser.pm
 lib/SOAP/WSDL/Expat/MessageStreamParser.pm
 lib/SOAP/WSDL/Expat/MessageSubParser.pm
 lib/SOAP/WSDL/Expat/SubParser.pm
 lib/SOAP/WSDL/Expat/WSDLParser.pm
 lib/SOAP/WSDL/Factory/Deserializer.pm
 lib/SOAP/WSDL/Factory/Serializer.pm
 lib/SOAP/WSDL/Factory/Transport.pm
 lib/SOAP/WSDL/Manual.pod
 lib/SOAP/WSDL/Manual/Glossary.pod
 lib/SOAP/WSDL/Manual/WS_I.pod
 lib/SOAP/WSDL/Message.pm
 lib/SOAP/WSDL/Operation.pm
 lib/SOAP/WSDL/OpMessage.pm
@@ -46,9 +58,12 @@ lib/SOAP/WSDL/Port.pm
 lib/SOAP/WSDL/PortType.pm
 lib/SOAP/WSDL/SAX/MessageHandler.pm
 lib/SOAP/WSDL/SAX/WSDLHandler.pm
 lib/SOAP/WSDL/Serializer/SOAP11.pm
 lib/SOAP/WSDL/Service.pm
 lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
 lib/SOAP/WSDL/SoapOperation.pm
 lib/SOAP/WSDL/Transport/HTTP.pm
 lib/SOAP/WSDL/Transport/Test.pm
 lib/SOAP/WSDL/TypeLookup.pm
 lib/SOAP/WSDL/Types.pm
 lib/SOAP/WSDL/XSD/Builtin.pm
@@ -108,13 +123,18 @@ lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm
 lib/SOAP/WSDL/XSD/Typelib/Element.pm
 lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
 LICENSE
-MANIFEST			This list of files
+Makefile.PL
 MANIFEST
 META.yml
 README
 t/001_use.t
 t/002_parse_wsdl.t
 t/002_sax.t
 t/003_sax_serializer.t
 t/003_wsdl_based_serializer.t
 t/004_parse_wsdl.t
 t/004_sax_wsdl.t
 t/005_parse_contributed.t
 t/005_sax_contributed_wsdl.t
 t/006_client.t
 t/007_envelope.t
@@ -126,9 +146,13 @@ t/013_complexType.t
 t/014_sax_typelib.t
 t/015_to_typemap.t
 t/016_client_object.t
-t/017_generator.t
+t/017_generator_expat.t
-t/018_generator.t
+t/017_generator_libxml.t
 t/018_generator_expat.t
 t/018_generator_libxml.t
 t/020_storable.t
 t/021_generator_element_ref_expat.t
 t/021_generator_element_ref_libxml.t
 t/098_pod.t
 t/acceptance/results/03_complexType-all.xml
 t/acceptance/results/03_complexType-sequence.xml
@@ -142,6 +166,7 @@ t/acceptance/wsdl/006_sax_client.wsdl
 t/acceptance/wsdl/008_complexType.wsdl
 t/acceptance/wsdl/02_port.wsdl
 t/acceptance/wsdl/03_complexType-all.wsdl
 t/acceptance/wsdl/03_complexType-element-ref.wsdl
 t/acceptance/wsdl/03_complexType-sequence.wsdl
 t/acceptance/wsdl/04_element-simpleType.wsdl
 t/acceptance/wsdl/04_element.wsdl
@@ -156,6 +181,8 @@ t/acceptance/wsdl/contributed/OITest.wsdl
 t/acceptance/wsdl/contributed/tools.wsdl
 t/acceptance/wsdl/email_account.wsdl
 t/Expat/01_expat.t
 t/Expat/02_sub_parser.t
 t/Expat/03_wsdl.t
 t/lib/MyComplexType.pm
 t/lib/MyElement.pm
 t/lib/MySimpleType.pm
@@ -168,6 +195,7 @@ t/SOAP/WSDL/02_port.t
 t/SOAP/WSDL/03_complexType-all.t
 t/SOAP/WSDL/03_complexType-choice.t
 t/SOAP/WSDL/03_complexType-complexContent.t
 t/SOAP/WSDL/03_complexType-element-ref.t
 t/SOAP/WSDL/03_complexType-group.t
 t/SOAP/WSDL/03_complexType-sequence.t
 t/SOAP/WSDL/03_complexType-simpleContent.t
@@ -177,12 +205,16 @@ t/SOAP/WSDL/04_element.t
 t/SOAP/WSDL/05_simpleType-list.t
 t/SOAP/WSDL/05_simpleType-restriction.t
 t/SOAP/WSDL/05_simpleType-union.t
 t/SOAP/WSDL/10_performance.t
 t/SOAP/WSDL/11_helloworld.NET.t
 t/SOAP/WSDL/12_binding.pl
-t/SOAP/WSDL/XSD/Typelib/Builtin/001_string.t
+t/SOAP/WSDL/Transport/01_Test.t
-t/SOAP/WSDL/XSD/Typelib/Builtin/002_dateTime.t
+t/SOAP/WSDL/Transport/acceptance/test2.xml
-t/SOAP/WSDL/XSD/Typelib/Builtin/002_time.t
+t/SOAP/WSDL/Transport/acceptance/test3.xml
 t/SOAP/WSDL/XSD/Typelib/Builtin/001_anyType.t
 t/SOAP/WSDL/XSD/Typelib/Builtin/002_anySimpleType.t
 t/SOAP/WSDL/XSD/Typelib/Builtin/003_date.t
 t/SOAP/WSDL/XSD/Typelib/Builtin/004_time.t
 t/SOAP/WSDL/XSD/Typelib/Builtin/005_dateTime.t
 t/SOAP/WSDL/XSD/Typelib/Builtin/006_string.t
 t/test.pl
 TODO
 Makefile.PL
@@ -1,6 +1,6 @@
 ---
 name: SOAP-WSDL
-version: 2.00_10
+version: 2.00_14
 author:
 abstract: SOAP with WSDL support
 license: artistic
@@ -11,12 +11,11 @@ requires:
  Date::Parse: 0
  File::Basename: 0
  File::Path: 0
  Getopt::Long: 0
  LWP::UserAgent: 0
  List::Util: 0
-  XML::LibXML: 0
+  Template: 0
  XML::Parser::Expat: 0
  XML::SAX::Base: 0
  XML::SAX::ParserFactory: 0
 generated_by: Module::Build version 0.2808
 meta-spec:
  url: http://module-build.sourceforge.net/META-spec-v1.2.html
@@ -24,23 +23,36 @@ meta-spec:
 provides:
  SOAP::WSDL:
    file: lib/SOAP/WSDL.pm
-    version: 2.00_10
+    version: 2.00_13
  SOAP::WSDL::Base:
    file: lib/SOAP/WSDL/Base.pm
  SOAP::WSDL::Binding:
    file: lib/SOAP/WSDL/Binding.pm
  SOAP::WSDL::Client:
    file: lib/SOAP/WSDL/Client.pm
    version: 2.00_14
  SOAP::WSDL::Client::Base:
    file: lib/SOAP/WSDL/Client/Base.pm
  SOAP::WSDL::Definitions:
    file: lib/SOAP/WSDL/Definitions.pm
-  SOAP::WSDL::Envelope:
+  SOAP::WSDL::Deserializer::SOAP11:
-    file: lib/SOAP/WSDL/Envelope.pm
+    file: lib/SOAP/WSDL/Deserializer/SOAP11.pm
    version: 2.00_13
  SOAP::WSDL::Deserializer::SOM:
    file: lib/SOAP/WSDL/Deserializer/SOM.pm
    version: 2.00_14
  SOAP::WSDL::Expat::MessageParser:
    file: lib/SOAP/WSDL/Expat/MessageParser.pm
  SOAP::WSDL::Expat::MessageStreamParser:
    file: lib/SOAP/WSDL/Expat/MessageStreamParser.pm
  SOAP::WSDL::Expat::MessageSubParser:
    file: lib/SOAP/WSDL/Expat/MessageSubParser.pm
  SOAP::WSDL::Factory::Deserializer:
    file: lib/SOAP/WSDL/Factory/Deserializer.pm
  SOAP::WSDL::Factory::Serializer:
    file: lib/SOAP/WSDL/Factory/Serializer.pm
  SOAP::WSDL::Factory::Transport:
    file: lib/SOAP/WSDL/Factory/Transport.pm
  SOAP::WSDL::Message:
    file: lib/SOAP/WSDL/Message.pm
  SOAP::WSDL::OpMessage:
@@ -57,10 +69,18 @@ provides:
    file: lib/SOAP/WSDL/SAX/MessageHandler.pm
  SOAP::WSDL::SOAP::Typelib::Fault11:
    file: lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
  SOAP::WSDL::Serializer::SOAP11:
    file: lib/SOAP/WSDL/Serializer/SOAP11.pm
    version: 2.00_13
  SOAP::WSDL::Service:
    file: lib/SOAP/WSDL/Service.pm
  SOAP::WSDL::SoapOperation:
    file: lib/SOAP/WSDL/SoapOperation.pm
  SOAP::WSDL::Transport::HTTP:
    file: lib/SOAP/WSDL/Transport/HTTP.pm
  SOAP::WSDL::Transport::Test:
    file: lib/SOAP/WSDL/Transport/Test.pm
    version: 2.00_14
  SOAP::WSDL::TypeLookup:
    file: lib/SOAP/WSDL/TypeLookup.pm
  SOAP::WSDL::Types:
@@ -1,36 +1,36 @@
- support embedded atomic types by including a second (and third and fourth) 
+TODO list for SOAP::WSDL
-package type_prefix::complex_type::element_name element package.
+
-Allow unlimited depth (though this is rather wicked).
+2.00 Pre-releases
- fixup generated pod so it looks nice in SOAP::WSDL::Definitions.
+--------
- remove benchmarks from tests. Create benchmark/ directory and store benchmarks in.
+* SOAP Header support (#1764845)
- add tests for SOAP::WSDL::Definitions::create 
+
-   - test for correct creation
+* Implement a interface similar to SOAP::Schema (#1783639)
-   - test against web service (fullerdata.com?)
+
- Improve docs
+* Check & probably fix simpleType support. 
-   - Partially DONE
+The WS at http://www.webservicex.net/genericbarcode.asmx?wsdl should 
- Remove SOAP::Lite dependency - for now, just support HTTP(s) via LWP::UserAgent.
+make up a good example for simpleType definitions.
-   - Partially DONE. SOAP::WSDL still uses SOAP::Schema
+
- write inheritance Test for all XSD::Typelib::Builtin::* classes
+* Remove benchmarks from test. Create benchmark/ directory to store benchmarks.
- Check & probably fix simpleType support. 
+
-The WS at http://www.webservicex.net/genericbarcode.asmx?wsdl should make up a good example for simpleType 
+* write inheritance Test for all XSD::Typelib::Builtin::* classes
-definitions.
+
- add default Fault11 typemap to generated typemaps
+* support embedded atomic types (#1761532) 
-  - DONE
+Implement by including a second (and third and fourth) 
- SOAP::WSDL::Definitions::create creates bad interface docs. Fix it.
+
-   - DONE
+package type_prefix::complex_type::element_name;
- update all Builtin Types to new constructor BEGIN block (Class::Std unfortunately is way slow)
+
-   - DONE.
+element package.
- Remove useless (but on CPAN annoying) doc from Builtin::* classes
+Maybe even allow unlimited depth? What does the specs say?
-   - DONE
+
- add example WS scripts
+2.1 release
-   - DONE.
+--------
 - SOAP::WSDL::XSD::Typelib::Builtin::string does not unescape XML builtin entities on get_value()
   - WONTFIX. 
   Entities are unescaped by XML parser. 
   If you want the plain value, you have to use get_value, as XML conversion is overloaded on stringification.
 - Make callin WS easier: implent WS-I-based SOAP::WSDL::Client::WSI
   - WONTFIX - SOAP::WSDL::Base should behave equal
 - add capability to create request objects based on input part definitions to SOAP::WSDL::Client::Base
   - DONE.
 2.2 release
 --------
 * XML schema support ("minimal conformant") (#1764845)
 * Support SOAP attachments
 3.0 release
 --------
 We're not thinking that far ahead right now.
@@ -0,0 +1,68 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use lib '../lib';
 use lib 'lib';
 use lib '../t/lib';
 use SOAP::WSDL::SAX::MessageHandler;
 use Benchmark;
 use SOAP::WSDL::Expat::MessageParser;
 use XML::Simple;
 use XML::LibXML;
 use MyComplexType;
 use MyElement;
 use MySimpleType;
 my $xml = q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
    <SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >
    <test>Test</test>
    <test2 >Test2</test2>
    </MyAtomicComplexTypeElement></SOAP-ENV:Body></SOAP-ENV:Envelope>};
 my $parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'FakeResolver'
 });
 $XML::Simple::PREFERRED_PARSER = 'XML::Parser';
 my $libxml = XML::LibXML->new();
 timethese 1000, 
 {
  'SOAP::WSDL' => sub { $parser->parse( $xml ) },
  #'XML::Simple (Hash)' => sub { XMLin $xml },
  'XML::LibXML (DOM)' => sub { my $dom = $libxml->parse_string( $xml ) },
 };
 use Test::More tests => 1;
 is $parser->get_data(), q{<MyAtomicComplexTypeElement xmlns="urn:Test" >}
    . q{<test >Test</test><test2 >Test2</test2></MyAtomicComplexTypeElement>}
    , 'Content comparison';
 $parser->class_resolver( 'FakeResolver2' );
 # data classes reside in t/lib/Typelib/
 BEGIN {
    package FakeResolver;
    {
        my %class_list = (
            'MyAtomicComplexTypeElement' => 'MyAtomicComplexTypeElement',
            'MyAtomicComplexTypeElement/test' => 'MyTestElement',
            'MyAtomicComplexTypeElement/test2' => 'MyTestElement2',
        );
        sub get_map { return \%class_list };
        sub new { return bless {}, 'FakeResolver' };
        sub get_class {
            my $name = join('/', @{ $_[1] });
            return ($class_list{ $name }) ? $class_list{ $name }
                : warn "no class found for $name";
        };
    };
 };
@@ -0,0 +1,21 @@
 use strict;
 use warnings;
 use Benchmark;
 use lib '../../lib';
 use SOAP::WSDL::XSD::Typelib::Builtin::anyType;
 my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anyType->new();
 timethese 10000, {
    'new' => sub { SOAP::WSDL::XSD::Typelib::Builtin::anyType->new() },
    'new with params' => sub { SOAP::WSDL::XSD::Typelib::Builtin::anyType->new({
        xmlns => 'urn:Test'
    }) },
    'set_FOO' => sub { $obj->set_xmlns('Test') },
 };
 my $data;
 timethese 1000000, {
    'set_FOO' => sub { $obj->set_xmlns('Test') },
    'get_FOO' => sub { $data = $obj->get_xmlns() },
 };
@@ -0,0 +1,22 @@
 use strict;
 use warnings;
 use Benchmark;
 use lib '../../lib';
 use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
 my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new();
 timethese 10000, {
    'new' => sub { SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new() },
    'new + params' => sub { SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({
        xmlns => 'urn:Test',
        value => 'Teststring'
    }) },
    'set_FOO' => sub { $obj->set_xmlns('Test') },
 };
 my $data;
 timethese 1000000, {
    'set_FOO' => sub { $obj->set_xmlns('Test') },
    'get_FOO' => sub { $data = $obj->get_xmlns() },
 };
@@ -0,0 +1,22 @@
 use strict;
 use warnings;
 use Benchmark;
 use lib '../../lib';
 use SOAP::WSDL::XSD::Typelib::Builtin::string;
 my $obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new();
 timethese 10000, {
    'new' => sub { SOAP::WSDL::XSD::Typelib::Builtin::string->new() },
    'new + params' => sub { SOAP::WSDL::XSD::Typelib::Builtin::string->new({
        xmlns => 'urn:Test',
        value => 'Teststring'
    }) },
    'set_FOO' => sub { $obj->set_xmlns('Test') },
 };
 my $data;
 timethese 1000000, {
    'set_FOO' => sub { $obj->set_xmlns('Test') },
    'get_FOO' => sub { $data = $obj->get_xmlns() },
 };
@@ -1,13 +1,10 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Fcntl;
 use IO::File;
 use Pod::Usage;
 use Getopt::Long;
 use LWP::UserAgent;
-use SOAP::WSDL::SAX::WSDLHandler;
+use SOAP::WSDL::Expat::WSDLParser;
 use XML::LibXML;
 my %opt = (
  url => '',
@@ -39,8 +36,7 @@ my $url = $ARGV[0];
 pod2usage( -exit => 1 , verbose => 2 ) if ($opt{help});
 pod2usage( -exit => 1 , verbose => 1 ) if not ($url);
-my $handler = SOAP::WSDL::SAX::WSDLHandler->new();
+my $parser = SOAP::WSDL::Expat::WSDLParser->new();
 my $parser = XML::LibXML->new();
 local $ENV{HTTP_PROXY} = $opt{proxy} if $opt{proxy};
 my $lwp = LWP::UserAgent->new();
@@ -49,16 +45,13 @@ die $response->message(), "\n" if $response->code != 200;
 my $xml = $response->content();
-$parser->set_handler( $handler );
+my $wsdl = $parser->parse_string( $xml );
 $parser->parse_string( $xml );
 my $wsdl = $handler->get_data();
 if ($opt{typemap_include}) {
-  my $fh = IO::File->new($opt{typemap_include} , O_RDONLY)
+  open my $fh , $opt{typemap_include}
    or die "cannot open typemap_include file $opt{typemap_include}\n";
-  $opt{custom_types} = join q{}, $fh->getlines();
+  $opt{custom_types} .= join q{}, <$fh>;
-  $fh->close();
+  close $fh;
  delete $opt{typemap_include};
 }
@@ -3,6 +3,7 @@ use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 # atomic complexType
 # <element name="GetCitiesByCountry"><complexType> definition
 use SOAP::WSDL::XSD::Typelib::ComplexType;
@@ -46,9 +47,16 @@ __PACKAGE__->__set_ref('');
 __END__
 =pod
-=head1 NAME MyElements::GetCitiesByCountry
+=head1 NAME 
 MyElements::GetCitiesByCountry
 =head1 SYNOPSIS
@@ -3,6 +3,7 @@ use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 # atomic complexType
 # <element name="GetCitiesByCountryResponse"><complexType> definition
 use SOAP::WSDL::XSD::Typelib::ComplexType;
@@ -46,9 +47,16 @@ __PACKAGE__->__set_ref('');
 __END__
 =pod
-=head1 NAME MyElements::GetCitiesByCountryResponse
+=head1 NAME 
 MyElements::GetCitiesByCountryResponse
 =head1 SYNOPSIS
@@ -3,6 +3,7 @@ use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 # atomic complexType
 # <element name="GetWeather"><complexType> definition
 use SOAP::WSDL::XSD::Typelib::ComplexType;
@@ -54,9 +55,16 @@ __PACKAGE__->__set_ref('');
 __END__
 =pod
-=head1 NAME MyElements::GetWeather
+=head1 NAME 
 MyElements::GetWeather
 =head1 SYNOPSIS
@@ -3,6 +3,7 @@ use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 # atomic complexType
 # <element name="GetWeatherResponse"><complexType> definition
 use SOAP::WSDL::XSD::Typelib::ComplexType;
@@ -27,6 +28,7 @@ __PACKAGE__->_factory(
        GetWeatherResult => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
    }
 );
@@ -45,9 +47,16 @@ __PACKAGE__->__set_ref('');
 __END__
 =pod
-=head1 NAME MyElements::GetWeatherResponse
+=head1 NAME 
 MyElements::GetWeatherResponse
 =head1 SYNOPSIS
@@ -3,6 +3,7 @@ use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 #
 # <element name="string" type="s:string"/> definition
 #
@@ -26,9 +27,16 @@ __PACKAGE__->__set_ref('');
 __END__
 =pod
-=head1 NAME MyElements::string
+=head1 NAME 
 MyElements::string
 =head1 SYNOPSIS
@@ -1,4 +1,5 @@
 package MyInterfaces::GlobalWeather;
 use strict;
 use warnings;
 use MyTypemaps::GlobalWeather;
@@ -16,8 +17,18 @@ sub new {
 }
 __PACKAGE__->__create_methods(
-              GetWeather => [ 'MyElements::GetWeather', ],
+        GetWeather => {
-              GetCitiesByCountry => [ 'MyElements::GetCitiesByCountry', ],
+            parts => [ 'MyElements::GetWeather', ],
            soap_action => 'http://www.webserviceX.NET/GetWeather',
            style => 'document',
            # use => '', # use not implemented yet 
        },
        GetCitiesByCountry => {
            parts => [ 'MyElements::GetCitiesByCountry', ],
            soap_action => 'http://www.webserviceX.NET/GetCitiesByCountry',
            style => 'document',
            # use => '', # use not implemented yet 
        },
 );
@@ -25,6 +36,10 @@ __PACKAGE__->__create_methods(
 __END__
 =pod
 =head1 NAME 
@@ -64,5 +79,5 @@ SYNOPSIS:
-=cut
+=pod
@@ -14,6 +14,7 @@ use MyInterfaces::GlobalWeather;
 my $weather = MyInterfaces::GlobalWeather->new();
 my $result = $weather->GetWeather({ CountryName => 'Germany', CityName => 'Munich' });
-die $result->get_faultstring()->get_value() if not ($result);   # boolean comparison overloaded
+# boolean comparison overloaded
 die $result->get_faultstring()->get_value() if not ($result);   
 print $result->get_GetWeatherResult()->get_value() , "\n";
@@ -11,15 +11,33 @@
 use lib 'lib/';
 use lib '../lib';
 use SOAP::WSDL;
 use File::Basename qw(dirname);
 use File::Spec;
 my $path = File::Spec->rel2abs( dirname __FILE__);
 # SOAP::WSDL variant
 use SOAP::WSDL;
 my $soap = SOAP::WSDL->new();
 my $som = $soap->wsdl("file:///$path/wsdl/globalweather.xml")
-  ->call('GetWeather', GetWeather => { CountryName => 'Germany', CityName => 'Munich' });
+  ->call('GetWeather', GetWeather => 
-
+    { CountryName => 'Germany', CityName => 'Munich' }
-die $som->message() if $som->fault();
+);
 die "Error" if $som->fault();
 print $som->result();
 # SOAP::Lite variant:
 # Note that you have to look both the proxy and the xmlns attribute 
 # set on the GetWeather SOAP::Data object from the WSDL.
 use SOAP::Lite; # +trace;
 $soap = SOAP::Lite->new()->on_action( sub { join'/', @_ } )
  ->proxy("http://www.webservicex.net/globalweather.asmx");     # from WSDL
 $som = $soap->call(
    SOAP::Data->name('GetWeather')
        ->attr({ xmlns => 'http://www.webserviceX.NET' }),      # from WSDL
    SOAP::Data->name('CountryName')->value('Germany'), 
    SOAP::Data->name('CityName')->value('Munich') 
 );
 die "Error" if $som->fault();
 print $som->result();
@@ -5,20 +5,19 @@ use vars qw($AUTOLOAD);
 use Carp;
 use Scalar::Util qw(blessed);
 use SOAP::WSDL::Client;
-use SOAP::WSDL::Envelope;
+use SOAP::WSDL::Expat::WSDLParser;
 use SOAP::WSDL::SAX::WSDLHandler;
 use Class::Std;
-use XML::LibXML;
+use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
 use LWP::UserAgent;
-our $VERSION='2.00_10';
+our $VERSION='2.00_13';
 my %no_dispatch_of      :ATTR(:name<no_dispatch>);
 my %wsdl_of             :ATTR(:name<wsdl>);
 my %proxy_of            :ATTR(:name<proxy>);
 my %readable_of         :ATTR(:name<readable>);
 my %autotype_of         :ATTR(:name<autotype>);
-my %outputxml_of        :ATTR(:name<outputxml>);
+my %outputxml_of        :ATTR(:name<outputxml> :default<0>);
 my %outputtree_of       :ATTR(:name<outputtree>);
 my %outputhash_of       :ATTR(:name<outputhash>);
 my %servicename_of      :ATTR(:name<servicename>);
@@ -98,13 +97,11 @@ sub wsdlinit {
    croak $response->message() if ($response->code != 200);
    # TODO: Port parser to expat and remove XML::LibXML dependency
-    my $parser = XML::LibXML->new();
+    my $parser = SOAP::WSDL::Expat::WSDLParser->new();
    my $filter = SOAP::WSDL::SAX::WSDLHandler->new();
    $parser->set_handler( $filter );
    $parser->parse_string( $response->content() );
    # sanity checks
-    my $wsdl_definitions = $filter->get_data() or die "unable to parse WSDL";
+    my $wsdl_definitions = $parser->get_data() or die "unable to parse WSDL";
    my $types = $wsdl_definitions->first_types()
        or die "unable to extract schema from WSDL";
    my $ns = $wsdl_definitions->get_xmlns()
@@ -222,10 +219,14 @@ sub _wsdl_init_methods :PRIVATE {
 }
 sub call {
-    my $self = shift;
+    my ($self, $method, @data_from) = @_;
    my $ident = ident $self;
-    my $method = shift;
+
-    my $data = ref $_[0] ? $_[0] : { @_ };
+    my ($data, $header) = ref $data_from[0] 
      ? ($data_from[0], $data_from[1] ) 
      : (@data_from>1) 
          ? ( { @data_from }, undef )
          : ( $data_from[0], undef );
    $self->wsdlinit() if not ($definitions_of{ $ident });
    $self->_wsdl_init_methods() if not ($method_info_of{ $ident });
@@ -233,34 +234,54 @@ sub call {
    my $client = $client_of{ $ident };
    $client->set_proxy( $proxy_of{ $ident } || $port_of{ $ident }->get_location() );
    $client->set_no_dispatch( $no_dispatch_of{ $ident } );
    $client->set_outputxml( $outputtree_of{ $ident } ? 0 : 1 );
    $client->set_outputxml( $outputxml_of{ $ident } ? 1 : 0 );
    # maybe we should introduce something like $output{ $ident } with a fixed 
    # set of values - m{^(TREE|HASH|XML|SOM)$}xms ?
    if ( ( ! $outputtree_of{ $ident } )
      && ( ! $outputhash_of{ $ident } ) 
      && ( ! $outputxml_of{ $ident } ) ) {
        require SOAP::WSDL::Deserializer::SOM;
        $client->set_deserializer( SOAP::WSDL::Deserializer::SOM->new() );
    };
    my $method_info = $method_info_of{ $ident }->{ $method };
    # TODO serialize both header and body, not only header
    my $response = (blessed $data) 
-        ? $client->call( $method, $data )
+        ? $client->call( {
            operation => $method,
            soap_action => $method_info->{ soap_action },
          }, $data )
        : do {
            my $content = '';
            # TODO support RPC-encoding: Top-Level element + namespace...
-            foreach my $part ( @{ $method_info_of{ $ident }->{ $method }->{ parts } } ) {
+            foreach my $part ( @{ $method_info->{ parts } } ) {
                $client->set_on_action( sub { $part->get_targetNamespace() . '/' . $_[1] } );
                $content .= $part->serialize( $method, $data, 
                  {
                    %{ $serialize_options_of{ $ident } },
                    readable => $readable_of{ $ident },
                  }  );
            }
-            $client->call($method, $content);
+            $client->call(
                {
                    operation => $method,
                    soap_action => $method_info->{ soap_action }
                },
                # absolutely stupid, but we need a reference which 
                # serializes to XML on stringification...
                SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({
                    value => $content
                }), 
                SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({
                    value => $header
                })
            );
        };
-    return $response if ( 
+    return unless defined $response;    # nothing to do for one-ways
-      $outputxml_of{ $ident } 
+    return $response;
 #      || $outputhash_of{ $ident }
      || $outputtree_of{ $ident } 
      || $no_dispatch_of{ $ident } );
    return unless $response;    # nothing to do for one-ways
    # now convert into SOAP::SOM - bah !
    require SOAP::Lite;
    return SOAP::Deserializer->new()->deserialize( $response );
 } 
 sub explain {
@@ -318,8 +339,25 @@ Performs a SOAP call. The result is either an object tree (with outputtree),
 a hash reference (with outputhash), plain XML (with outputxml) or a SOAP::SOM 
 object (with neither of the above set).
 call() can be called in different ways:
 =over
 =item * Old-style idiom
 my $result = $soap->call('method', %data);
 Does not support SOAP header data.
 =item * New-style idiom
 my $result = $soap->call('method', $body_ref, $header_ref );
 Does support SOAP header data. $body_ref and $header ref may either be 
 hash refs or SOAP::WSDL::XSD::Typelib::* derived objects.
 =back
 =head2 wsdlinit
 Reads the WSDL file and initializes SOAP::WSDL for working with it.
@@ -598,9 +636,7 @@ The following facets have no influence yet:
 =head1 SEE ALSO
-There are lots of SOAP Clients on CPAN, lately.
+=head2 Related projects
 You may wish to look at the following:
 =over
@@ -608,17 +644,6 @@ You may wish to look at the following:
 Full featured SOAP-library, little WSDL support. Supports rpc-encoded style only. Many protocols supported.
 =item * L<SOAP::Message|SOAP::Message>
 A very basic SOAP library without transport facilities.
 Handy if you got your XML message ready and just need an envelope around it.
 =item * L<SOAP::MySOAP|SOAP::MySOAP>
 An extremely basic SOAP client module - just HTTP support, no encoding / decoding, 
 HTTP headers have to be set as arguments to 'new'
 =item * <XML::Compile::WSDL|XML::Compile::WSDL>
 A promising-looking approach derived from a cool functional DOM-based XML schema parser.
@@ -630,6 +655,20 @@ if you need to adhere very closely to the XML Schema / WSDL specs.
 =back
 =head2 Sources of documentation
 =over 
 =item * SOAP::WSDL homepage at sourceforge.net
 L<http://soap-wsdl.sourceforge.net>
 =item * SOAP::WSDL forum at CPAN::Forum
 L<http://www.cpanforum.com/dist/SOAP-WSDL>
 =back
 =head1 ACKNOWLEDGMENTS
 There are many people out there who fostered SOAP::WSDL's developement. 
@@ -661,9 +700,9 @@ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
- $Rev: 143 $
+ $Rev: 218 $
 $LastChangedBy: kutterma $
- $Id: WSDL.pm 143 2007-08-13 18:43:20Z kutterma $
+ $Id: WSDL.pm 218 2007-09-10 16:19:23Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL.pm $
 =cut
@@ -78,12 +78,15 @@ sub init {
    my @args = @_;
    foreach my $value (@args)
    {
-        die $value if (not defined ($value->{ Name }));
+        die @args if (not defined ($value->{ Name }));
        if ($value->{ Name } =~m{^xmlns\:}xms) {
            die $xmlns_of{ ident $self }
                if ref $xmlns_of{ ident $self } ne 'HASH';
            # add namespaces
            $xmlns_of{ ident $self }->{ $value->{ Value } } =
                $value->{ LocalName };
            next;
        }
        elsif ($value->{ Name } =~m{^xmlns$}xms) {
@@ -8,29 +8,45 @@ use LWP::UserAgent;
 use HTTP::Request;
 use Scalar::Util qw(blessed);
-use SOAP::WSDL::Envelope;
+use SOAP::WSDL::Factory::Deserializer;
 use SOAP::WSDL::Factory::Serializer;
 use SOAP::WSDL::Factory::Transport;
 use SOAP::WSDL::Expat::MessageParser;
 use SOAP::WSDL::SOAP::Typelib::Fault11;
-# Package globals for speed...
+our $VERSION = '2.00_14';
 # Package global for speed and memory savings.
 # But should be factored out into serializer/deserializer...
 my $PARSER;
 my %class_resolver_of   :ATTR(:name<class_resolver> :default<()>);
 my %no_dispatch_of      :ATTR(:name<no_dispatch>    :default<()>);
 my %outputxml_of        :ATTR(:name<outputxml>      :default<()>);
-my %proxy_of            :ATTR(:name<proxy>          :default<()>);
+my %transport_of        :ATTR(:name<transport>      :default<()>);
 my %endpoint_of         :ATTR(:name<endpoint>       :default<()>);
 my %soap_version_of     :ATTR(:get<soap_version>    :init_attr<soap_version> :default<'1.1'>);
 my %fault_class_of      :ATTR(:name<fault_class>    :default<SOAP::WSDL::SOAP::Typelib::Fault11>);
 my %trace_of            :ATTR(:set<trace>           :init_arg<trace>    :default<()> );
 my %on_action_of        :ATTR(:name<on_action>      :default<()>);
-my %content_type_of     :ATTR(:name<content_type>   :default<text/xml; charset=utf8>);  
+my %content_type_of     :ATTR(:name<content_type>   :default<text/xml; charset=utf8>);  #/#trick editors
-
+my %serializer_of       :ATTR(:name<serializer>     :default<()>);
-#/#trick editors
+my %deserializer_of     :ATTR(:name<deserializer>   :default<()>);
 # TODO remove when preparing 2.01
 sub outputtree { warn 'outputtree is deprecated and'
    . 'will be removed before reaching v2.01 !' }
 sub BUILD {
    my ($self, $ident, $attrs_of_ref) = @_;
    if (exists $attrs_of_ref->{ proxy }) {
        $self->set_proxy( $attrs_of_ref->{ proxy } );
        delete $attrs_of_ref->{ proxy };
    }
 }
 sub get_trace {
    my $ident = ident $_[0];
    return $trace_of{ $ident } 
@@ -40,6 +56,47 @@ sub get_trace {
    : ()
 }
 sub get_proxy {
    return $_[0]->get_transport();
 }
 sub set_proxy {
    my ($self, @args_from) = @_; 
    my $ident = ident $self;
    # remember old value to return it later - Class::Std does so, too
    my $old_value = $transport_of{ $ident };
    # accept both list and list ref args
    @args_from =  @{ $args_from[0] } if ref $args_from[0];
    # remember endpoint
    $endpoint_of{ $ident } = $args_from[0];
    # set transport - SOAP::Lite works similar...
    $transport_of{ $ident } =  SOAP::WSDL::Factory::Transport
      ->get_transport( @args_from );
    return $old_value;
 }
 sub set_soap_version {
    my $ident = ident shift;
    # remember old value to return it later - Class::Std does so, too
    my $soap_version = $soap_version_of{ $ident };
    # re-setting the soap version invalidates the 
    # serializer object
    delete $serializer_of{ $ident };
    delete $deserializer_of{ $ident };
    delete $transport_of{ $ident };
    $soap_version_of{ $ident } = shift;   
    return $soap_version;
 }
 # Mimic SOAP::Lite's behaviour for getter/setter routines
 SUBFACTORY: {
    no strict qw(refs);
@@ -56,98 +113,105 @@ SUBFACTORY: {
    }
 }
 BEGIN {
    $PARSER = SOAP::WSDL::Expat::MessageParser->new();
 }
 sub call {
-    my $self = shift;
+    my ($self, $method, @data_from) = @_;
    my $method = shift;
    my $ident = ident $self;
    my $data = ref $_[0] 
      ? $_[0] 
      : (@_>1) 
          ? { @_ }
          : $_[0];
-    my $soap_action;
+    # the only valid idiom for calling a method with both a header and a body 
-    my $trace_sub = $self->get_trace();
+    # is
-    my $envelope = SOAP::WSDL::Envelope->serialize( $method, $data );
+    # ->call($method, $body_ref, $header_ref);
    #
    # These other idioms all assume an empty header:
    # ->call($method, %body_of);    # %body_of is a hash
    # ->call($method, $body);       # $body is a scalar
    my ($data, $header) = ref $data_from[0] 
      ? ($data_from[0], $data_from[1] ) 
      : (@data_from>1) 
          ? ( { @data_from }, undef )
          : ( $data_from[0], undef );
-    if (blessed $data
+    # get operation name and soap_action
-        && $data->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType'))
+    my ($operation, $soap_action) = (ref $method eq 'HASH') 
-    {
+        ? ( $method->{ operation }, $method->{ soap_action } )
-        # TODO replace by something derived from binding - this is just a
+        : (blessed $data 
-        # workaround...
+            && $data->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType'))
-        $soap_action = join '/', $data->get_xmlns(), $method;
+            ? ( $method , (join '/', $data->get_xmlns(), $method) )
-    }
+            : ( $method, q{} );
-    else {
+    
-        $envelope = SOAP::WSDL::Envelope->serialize( $method, $data );
+    $serializer_of{ $ident } ||= SOAP::WSDL::Factory::Serializer->get_serializer({
-        # TODO add something like SOAP::Lite's on_action mechanism
+        soap_version => $self->get_soap_version(),
-        $soap_action = $on_action_of{$ident}->( $self, $method ) if ($on_action_of{$ident});
+    });
-    }   
+
    my $envelope = $serializer_of{ $ident }->serialize({
        method => $operation, 
        body => $data,
        header => $header,
    });
    return $envelope if $self->no_dispatch();
-    # get response via transport layer
+    # always quote SOAPAction header.
-    # maybe we should return a result with the following methods:
+    # WS-I BP 1.0 R1109
-    # - result: returns the result of the call (like SOAP::Lite, but as
+    if ($soap_action) { 
-    #           object tree)
+        $soap_action =~s{\A(:?"|')?}{"}xms;
-    # - header: returns the content of the SOAP header
+        $soap_action =~s{(:?"|')?\Z}{"}xms;
-    # - fault:  returns the result of the call if a SOAP fault is sent back
+    }
-    #           by the server. Retuns undef (nothing) if the call has been
+    else {
-    #           processed without errors.
+        $soap_action = q{""};
-    my $ua = LWP::UserAgent->new();
+    }
    my $request = HTTP::Request->new( 'POST',
        $self->get_proxy(),
        [   'Content-Type', $content_type_of{ $ident },
            'Content-Length', length($envelope),
            'SOAPAction', $soap_action,
        ],
        $envelope );
    # get response via transport layer.
    # Normally, SOAP::Lite's transport layer is used, though users 
    # may provide their own.
    my $transport = $self->get_transport(); 
    my $response = $transport->send_receive(
       endpoint => $self->get_endpoint(),
       content_type => $content_type_of{ $ident },
       envelope => $envelope,
       action => $soap_action,
       on_receive_chunk => sub {}     # optional, may be used for parsing large responses as they arrive.
                                      # might not be supported by all transport layers...
                                      # and, of course, only is of interest for chunk parsers - 
                                      # namely ExpatNB and XML::LibXML's Push parser interface...
    );
-    $trace_sub->( $request->as_string() ) if $trace_of{ $ident };       # if for speed
+    return $response if ($outputxml_of{ $ident } );
    my $response = $ua->request( $request );
    $trace_sub->( $response->as_string() ) if $trace_of{ $ident };      # if for speed
-    return $response->content() if ($self->outputxml() );
+    # get deserializer
    $deserializer_of{ $ident } ||= SOAP::WSDL::Factory::Deserializer->get_deserializer({
        soap_version => $soap_version_of{ $ident },
    });
-    $PARSER->class_resolver( $self->get_class_resolver() );
+    # set class resolver if serializer supports it
    $deserializer_of{ $ident }->set_class_resolver( $class_resolver_of{ $ident } )
        if ( $deserializer_of{ $ident }->can('set_class_resolver') );
    # Try deserializing response - there may be some,
    # even if transport did not succeed (got a 500 response)
    if ( $response ) {
        my $result = eval { $deserializer_of{ $ident }->deserialize( $response ); };
        return $result if (not $@);       
        return $deserializer_of{ $ident }->generate_fault({
            code => 'soap:Server',
            role => 'urn:localhost',
            message => "Error deserializing message: $@. \n"
                . "Message was: \n$response"
        });
    };
    # if we had no success (Transport layer error status code)
    # or if transport layer failed
-    if ($response->code() != 200) {
+    if ( ! $transport->is_success() ) {
        # Try deserializing response - there may be some
        if ($response->content) {
            eval { $PARSER->parse( $response->content() ); };           
            return $PARSER->get_data() if (not $@);       
            warn "could not deserialize response: $@";                    
        };
        # generate & return fault if we cannot serialize response
        # or have none...
-        return $fault_class_of{$ident}->new({
+        return $deserializer_of{ $ident }->generate_fault({
-            faultcode => 'soap:Server',
+            code => 'soap:Server',
-            faultactor => 'urn:localhost',
+            role => 'urn:localhost',
-            faultstring => 'Error sending / receiving message: '
+            message => 'Error sending / receiving message: '
-                . $response->message()
+                . $transport->message()
                #$soap->transport->message()
        });
    }
    eval { $PARSER->parse( $response->content() ) };
    # return fault if we cannot deserialize response
    if ($@) {
        return $fault_class_of{$ident}->new({
            faultcode => 'soap:Server',
            faultactor => 'urn:localhost',
            faultstring => "Error deserializing message: $@. \n"
                . "Message was: \n$response"
        });
    }
    return $PARSER->get_data();
 } ## end sub call
 1;
@@ -162,6 +226,31 @@ SOAP::WSDL::Client - SOAP::WSDL's SOAP Client
 =head2 call
 $soap->call( \%method, \@parts );
 %method is a hash with the following keys:
 Name           Description
 ----------------------------------------------------
 operation      operation name
 soap_action    SOAPAction HTTP header to use
 style          Operation style. One of (document|rpc)
 use            SOAP body encoding. One of (literal|encoded) 
 The style and use keys have no influence yet.
@parts is a list containing the elements of the message parts.
 For backward compatibility, call may also be called as below:
 $soap->call( $method, \@parts );
 In this case, $method is the SOAP operation name, and the SOAPAction header 
 is guessed from the first part's namespace and the operation name (which is 
 mostly correct, but may fail). Operation style and body encoding are assumed to 
 be document/literal
 =head2 Configuration methods
 =head3 outputxml
@@ -286,9 +375,9 @@ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
- $Rev: 139 $
+ $Rev: 239 $
 $LastChangedBy: kutterma $
- $Id: Client.pm 139 2007-08-12 19:15:59Z kutterma $
+ $Id: Client.pm 239 2007-09-11 09:45:42Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Client.pm $
 =cut
@@ -21,20 +21,35 @@ sub __create_new {
 }
 sub __create_methods {
-  my ($package, %parts_of) = @_;
+  my ($package, %info_of) = @_;
  no strict qw(refs);
-  for my $method (keys %parts_of){
+  for my $method (keys %info_of){
      my ($soap_action, @parts); 
      # up to 2.00_10 we had list refs...
      if (ref $info_of{ $method }eq 'HASH') {
          @parts = @{ $info_of{ $method }->{ parts } };
          $soap_action = $info_of{ $method }->{ soap_action };
      }
      else {
          @parts = @{ $info_of{ $method } };
          $soap_action = ();          
      }
      *{ "$package\::$method" } = sub {
          my $self = shift;
          my @param = map { 
            my $data = shift || {};
            eval "require $_";
            $_->new( $data );
-          } @{ $parts_of{ $method } };
+          } @parts;
-          return $self->SUPER::call( $method, @param );          
+          return $self->SUPER::call( { 
              operation => $method, 
              soap_action => $soap_action,
          }, @param );          
      }
  }
 }
@@ -47,13 +62,40 @@ __END__
 =head1 NAME
-SOAP::WSDL::Client::Base - Base client for WSDL-based SOAP access
+SOAP::WSDL::Client::Base - Factory class for WSDL-based SOAP access
 =head1 SYNOPSIS
- package MySoapClient;
+ package MySoapInterface;
 use SOAP::WSDL::Client::Base;
 __PACKAGE__->__create_new( 
        proxy => 'http://somewhere.over.the.rainbow',
        class_resolver => 'Typemap::MySoapInterface'
 );
 __PACKAGE__->__create_methods( qw(one two three) );
 1;
 =head1 DESCRIPTION
 Factory class for creating interface classes. Should probably be renamed to 
 SOAP::WSDL::Factory::Interface...
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 214 $
 $LastChangedBy: kutterma $
 $Id: Base.pm 214 2007-09-10 15:54:52Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Client/Base.pm $
 =cut
@@ -117,6 +117,16 @@ sub _create_interface {
    my %operations = ();
    for my $operation ( @{ $operation_ref } ) {
        my $operation_name = $operation->get_name();
        my $soap_operation = $operation->first_operation();
        $operations{ $operation_name }->{ style } = $soap_operation 
            ? $soap_operation->get_style()
            : undef;
        $operations{ $operation_name }->{ soap_action } = $soap_operation 
            ? $soap_operation->get_soapAction()
            : undef; 
        my $port_op = first { $_->get_name() eq $operation_name } @{ $port_operation_ref };
        $operations{ $operation_name }->{ documentation } = $port_op->get_documentation();
@@ -151,9 +161,6 @@ sub _create_interface {
        }
    }
 #    use Data::Dumper;
 #    die Dumper \%operations;
    my $template = <<'EOT';
 package [% interface_prefix %][% service.get_name.replace('\.', '::') %];
@@ -174,9 +181,14 @@ sub new {
 }
 __PACKAGE__->__create_methods(
-      [% FOREACH name = operations.keys -%]
+[% FOREACH name = operations.keys -%]
-        [% name %] => [ [% FOREACH class = operations.$name.input.class %]'[% class %]', [% END %]],
+        [% name %] => {
-      [% END %]
+            parts => [ [% FOREACH class = operations.$name.input.class %]'[% class %]', [% END %]],
            soap_action => '[% operations.$name.soap_action %]',
            style => '[% operations.$name.style %]',
            # use => '', # use not implemented yet 
        },
 [% END %]
 );
 1;
@@ -0,0 +1,49 @@
 package SOAP::WSDL::Deserializer::SOAP11;
 use strict;
 use warnings;
 use Class::Std::Storable;
 use SOAP::WSDL::SOAP::Typelib::Fault11;
 our $VERSION='2.00_13';
 my %class_resolver_of :ATTR(:name<class_resolver> :default<()>);
 sub BUILD {
    my ($self, $ident, $args_of_ref) = @_;
    # ignore all options except 'class_resolver'
    for (keys %{ $args_of_ref }) {
        delete $args_of_ref->{ $_ } if $_ ne 'class_resolver';
    }
 }
 sub deserialize {
    my ($self, $content) = @_;
    my $parser = SOAP::WSDL::Expat::MessageParser->new({
        class_resolver => $class_resolver_of{ ident $self },
    });
    eval { $parser->parse_string( $content ) };
    if ($@) {
        return $self->generate_fault({
            code => 'soap:Server',
            role => 'urn:localhost',
            message => "Error deserializing message: $@. \n"
                . "Message was: \n$content"
        });
    }
    return $parser->get_data();
 }
 sub generate_fault {
    my ($self, $args_from_ref) = @_;
    return SOAP::WSDL::SOAP::Typelib::Fault11->new({
            faultcode => $args_from_ref->{ code } || 'soap:Client',
            faultactor => $args_from_ref->{ role } || 'urn:localhost',
            faultstring => $args_from_ref->{ message } || "Unknown error"
    }); 
 }
 1;
@@ -0,0 +1,127 @@
 package SOAP::WSDL::Deserializer::SOM;
 use strict;
 use warnings;
 our $VERSION = '2.00_14';
 our @ISA = qw(SOAP::Deserializer);
 my $HAVE_SOAP_LITE = eval { require SOAP::Lite };
 sub deserialize {
    my $self = shift;
    die 'Cannot deserialize to SOM object without SOAP::Lite. 
 Please install SOAP::Lite.
 '
        if not $HAVE_SOAP_LITE;
    $self->SUPER::deserialize(@_);
 }
 sub generate_fault {
    my ($self, $args_from_ref) = @_;
    # code, message, detail, actor
    die SOAP::Fault->new(
        faultcode => $args_from_ref->{ code },
        faultstring => $args_from_ref->{ message },
        faultactor => $args_from_ref->{ role },
    );
 }
 1;
 __END__
 =head1 NAME
 SOAP::WSDL::Deserializer::SOM - Deserializer SOAP messages into SOM objects
 =head1 SYNOPSIS
 use SOAP::WSDL;
 use SOAP::WSDL::Deserializer::SOM;
 use SOAP::WSDL::Factory::Deserializer;
 SOAP::WSDL::Factory::Deserializer->register( '1.1', __PACKAGE__ );
 =head1 DESCRIPTION
 Deserializer for creating SOAP::Lite's SOM object as result of a SOAP call.
 This package is here for two reasons:
 =over
 =item * Compatibility
 You don't have to change the rest of your SOAP::Lite based app when switching 
 to SOAP::WSDL, but can just use SOAP::WSDL::Deserializer::SOM to get back the 
 same objects as you were used to.
 =item * Completeness
 SOAP::Lite covers much more of the SOAP specification than SOAP::WSDL. 
 SOAP::WSDL::Deserializer::SOM can be used for content which cannot be 
 deserialized by L<SOAP::WSDL::Deserializer::SOAP11|SOAP::WSDL::Deserializer::SOAP11>. 
 This may be XML including mixed content, attachements and other XML data not 
 (yet) handled by L<SOAP::WSDL::Deserializer::SOAP11|SOAP::WSDL::Deserializer::SOAP11>. 
 =back
 SOAP::WSDL::Deserializer::SOM is a subclass of L<SOAP::Deserializer|SOAP::Deserializer> 
 from the L<SOAP::Lite|SOAP::Lite> package. 
 You may 
 =head1 USAGE
 SOAP::WSDL::Deserializer will not auroregister itself - to use it for a particular 
 SOAP version just use the following lines:
 my $soap_version = '1.1'; # or '1.2', further versions may appear.
 use SOAP::WSDL::Deserializer::SOM;
 use SOAP::WSDL::Factory::Deserializer;
 SOAP::WSDL::Factory::Deserializer->register( $soap_version, __PACKAGE__ );
 =head1 DIFFERENCES FROM OTHER CLASSES
 =head2 Differences from SOAP::Lite
 =over
 =item * No on_fault handler
 You cannot specify what to do when an error occurs - SOAP::WSDL will die 
 with a SOAP::Fault object on transport errors.
 =back
 =head2 Differences from other SOAP::WSDL::Deserializer classes
 =over
 =item * generate_fault
 SOAP::WSDL::Deserializer::SOM will die with a SOAP::Fault object on calls 
 to generate_fault.
 =back
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 176 $
 $LastChangedBy: kutterma $
 $Id: Serializer.pm 176 2007-08-31 15:28:29Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Factory/Serializer.pm $
 =cut
@@ -8,7 +8,7 @@ use XML::Parser::Expat;
 sub new {
    my ($class, $args) = @_;
    my $self = {
-        class_resolver => $args->{ class_resolver }
+        class_resolver => $args->{ class_resolver },
    };
    bless $self, $class;
    return $self;
@@ -20,16 +20,15 @@ sub class_resolver {
 }
 sub _initialize {
-	my ($self, $parser) = @_;
+    my ($self, $parser) = @_;
-	delete $self->{ data };
+    delete $self->{ data };                     # remove potential old results
    my $characters;
    my $current = undef;
    my $ignore = [ 'Envelope', 'Body' ];        # top level elements to ignore
    my $list = [];                              # node list
-    my $path = [];                              # current path (without 
+    my $path = [];                              # current path 
                                                # number)     
    my $skip = 0;                               # skip elements
    # use "globals" for speed
@@ -46,6 +45,14 @@ sub _initialize {
            # ignore top level elements
            if (@{ $ignore } && $_localname eq $ignore->[0]) {
                CHECK_ENVELOPE: {
                    last CHECK_ENVELOPE if $_localname ne 'Envelope';
                    last CHECK_ENVELOPE if exists $_attrs{ 'xmlns' } 
                      && $_attrs{ 'xmlns' } eq 'http://schemas.xmlsoap.org/soap/envelope/';
                    last CHECK_ENVELOPE if $_attrs{ "xmlns:$_prefix"} 
                      eq 'http://schemas.xmlsoap.org/soap/envelope/';
                    die "Bad namespace for SOAP envelope: " . $parser->recognized_string();
                }
                shift @{ $ignore };
                return;
            }
@@ -56,7 +63,7 @@ sub _initialize {
            # resolve class of this element
            $_class = $self->{ class_resolver }->get_class( $path )
                or die "Cannot resolve class for "
-                    . join('/', @{ $path }) . " via $self->{ class_resolver }";
+                    . join('/', @{ $path }) . " via " . $self->{ class_resolver };
            # maybe write as "return $skip = join ... if (...)" ?
            # would save a BLOCK...
@@ -72,19 +79,21 @@ sub _initialize {
            # if $class matches...
            if (index $_class, 'SOAP::WSDL::XSD::Typelib::Builtin', 0 < 0) {           
-                # check wheter there is a CODE reference for $class::new.
+                # check wheter there is a non-empty ARRAY reference for $_class::ISA
                # or a "new" method
                # If not, require it - all classes required here MUST
                # define new()
-                # This is the same as $class->can('new'), but it's way faster  
+                # This is not exactly the same as $class->can('new'), but it's way faster  
-                *{ "$_class\::new" }{ CODE } 
+                defined *{ "$_class\::new" }{ CODE }
                  or scalar @{ *{ "$_class\::ISA" }{ ARRAY } }
                    or eval "require $_class"   ## no critic qw(ProhibitStringyEval)
-                        or die $@;                        
+                      or die $@;                        
            }
            $current = $_class->new({ %_attrs });   # set new current object
            # remember top level element
-            defined $self->{ data } 
+            exists $self->{ data } 
                or ($self->{ data } = $current); 
        },
@@ -143,6 +152,13 @@ sub parsefile {
    return $_[0]->{ data };     
 }
 # SAX-like aliases
 sub parse_string;
 *parse_string = \&parse;
 sub parse_file;
 *parse_file = \&parsefile;
 sub get_data {
    return $_[0]->{ data };
 }
@@ -202,9 +218,9 @@ This module may be used under the same terms as perl itself.
 $ID: $
- $LastChangedDate: $
+ $LastChangedDate: 2007-09-10 18:19:23 +0200 (Mo, 10 Sep 2007) $
- $LastChangedRevision: $
+ $LastChangedRevision: 218 $
- $LastChangedBy: $
+ $LastChangedBy: kutterma $
- $HeadURL: $
+ $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Expat/MessageParser.pm $
@@ -67,9 +67,9 @@ This module may be used under the same terms as perl itself.
 $ID: $
- $LastChangedDate: $
+ $LastChangedDate: 2007-09-10 17:54:52 +0200 (Mo, 10 Sep 2007) $
- $LastChangedRevision: $
+ $LastChangedRevision: 214 $
- $LastChangedBy: $
+ $LastChangedBy: kutterma $
- $HeadURL: $
+ $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Expat/MessageStreamParser.pm $
@@ -0,0 +1,213 @@
 #!/usr/bin/perl
 package SOAP::WSDL::Expat::MessageSubParser;
 use strict;
 use warnings;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use XML::Parser::Expat;
 sub new {
    my ($class, $args) = @_;
    my $self = {};
    bless $self, $class;
    return $self;
 }
 # create handlers via currying - XML::Compiled is a good teacher...
 #
 # A handler has to know
 # - the order of it's child elements
 # - the classes for these child elements
 # - the handlers for these child elements (sub refs)
 # order is checked if provided
 sub start_tag {
    my $self = shift;
    my $arg_ref = shift;
    my $CHILD_ORDER = $arg_ref->{ order } || [];
    my $CHILD_CLASS = $arg_ref->{ class_of } || {};
    my $CHILD_HANDLER = $arg_ref->{ handler_of };
    my $CHILD_OCCURS = $arg_ref->{ occurs_of } || {};
    my $CHILD_INDEX = 0;
    return sub {
        # parser, element, attrs
        my ($prefix, $localname) = split m{:}xms , $_[1];
        $localname ||= $_[1];
 =pod
 #       # implement better checks...
 #        if (@{ $CHILD_ORDER }) {
 #            if ($CHILD_ORDER->[$CHILD_INDEX] ne $localname) {
 #                if (! $CHILD_ORDER->[++$CHILD_INDEX] 
 #                    ||  $CHILD_ORDER->[$CHILD_INDEX] ne $localname) {
 #                die "misplaced xml element " . $parser->recognized_string() 
 #                    . " at line "
 #                    . $parser->current_line()
 #                    . " column " . $parser->current_column() , "\n"
 #                    , "Element order: " . join(',' , @{ $CHILD_ORDER }), "\n"
 #                    }                        
 #            }
 #        }
 #
 #        if (%{ $CHILD_OCCURS }) {
 #            die "too many occurances of $localname at line "
 #                    . $parser->current_line()
 #                    . " column " . $parser->current_column() , "\n"
 #                if (not --$CHILD_OCCURS->{ $localname }->{ max });
 #
 #            # min must be checked in end_element !
 #            $CHILD_OCCURS->{ $localname }->{ min }-- 
 #                if ($CHILD_OCCURS->{ $localname }->{ min }); 
 #        }
 =cut
        # remove this some day
        return if ($localname eq 'Envelope');
        return if ($localname eq 'Body');
        # step down in tree (remember current)
        push @{ $self->{ list } }, $self->{ current };              
        $self->{ current } = $CHILD_CLASS->{ $localname }->new({ @_[2..$#_] });
        # Set (and remember) next state
        push @{ $self->{ handlers } }, $CHILD_HANDLER->{ $localname };
        $_[0]->setHandlers( %{ $CHILD_HANDLER->{ $localname } } ); 
    };
 }
 # characters is a good candidate for replacement when not needed -  
 # expat calls it for those whitespaces in non-mixed-content-elements, too
 sub characters {
    my $self = shift;    
    return sub { $self->{ characters } .= $_[1] };
 }
 # end_tag is a somewhat generic thingy - don't know whether we should 
 # curry it, and whether this will speed us up...
 sub end_tag {
    my $self = shift;
    return sub {
        # step down handler hierarchy
        pop @{ $self->{ handlers } };
        # restore state: set handler to last handler
        $_[0]->setHandlers( %{ $self->{ handlers }->[ -1 ] } );
        my ($prefix, $localname) = split m{:}xms , $_[1];          
        $localname ||= $_[1];          # for non-prefixed elements            
        # we only have characters if we need them - if not Char handler 
        # has to be set to undef       
        $self->{ current }->set_value( $self->{ characters } ) 
            if ($self->{ characters });
        # empty temp characters
        undef $self->{ characters };
        # return if we're top node
        # This one easily handles ignores for us, too...
        #
        # Hmm... could be replaced by something else, maybe ???
        # Maybe by defining an empty end_tag handler for the top node ?
        # Can we do this ???
        return if not defined $self->{ list }->[-1];
        # set appropriate attribute in last element
        # multiple values must be implemented in base class
        my $method = "add_$localname";
        $self->{ list }->[-1]->$method( $self->{ current } );
        # step up in object hierarchy...
        $self->{ current } = pop @{ $self->{ list } };                
    };
 }
 sub end_top_tag {
    my $self = shift;
    return sub {};   
 }
 sub initialize {   
    my ($self, $handler_of_ref, $parser ) = @_;
    $parser ||= XML::Parser::Expat->new();
    $self->{ list } = undef;   
    $self->{ current } = undef;
    $self->{ characters } = q{};      # empty characters
    $self->{ handlers } = [ $handler_of_ref ];
    $parser->setHandlers( %$handler_of_ref );
    return $parser;
 }
 sub get_data {
    return $_[0]->{ current };
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Expat::MessageParser - Convert SOAP messages to custom object trees
 =head1 SYNOPSIS
 my $parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'My::Resolver'   
 });
 $parser->parse( $xml );
 my $obj = $parser->get_data();
 =head1 DESCRIPTION
 Real fast expat based SOAP message parser.
 See L<SOAP::WSDL::Parser> for details.
 =head2 Skipping unwanted items
 Sometimes there's unneccessary information transported in SOAP messages.
 To skip XML nodes (including all child nodes), just edit the type map for 
 the message and set the type map entry to '__SKIP__'. 
 =head1 Bugs and Limitations
 =over
 =item * Ignores all namespaces
 =item * Does not handle mixed content
 =item * The SOAP header is ignored
 =back
 =head1 AUTHOR
 Replace the whitespace by @ for E-Mail Address.
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 COPYING
 This module may be used under the same terms as perl itself.
 =head1 Repository information
 $ID: $
 $LastChangedDate: 2007-09-10 17:54:52 +0200 (Mo, 10 Sep 2007) $
 $LastChangedRevision: 214 $
 $LastChangedBy: kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Expat/MessageSubParser.pm $
@@ -0,0 +1,219 @@
 #!/usr/bin/perl
 package SOAP::WSDL::Expat::MessageSubParser;
 use strict;
 use warnings;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use XML::Parser::Expat;
 sub new {
    my ($class, $args) = @_;
    my $self = {
        class_resolver => $args->{ class_resolver }
    };
    bless $self, $class;
    return $self;
 }
 sub class_resolver {
    my $self = shift;
    $self->{ class_resolver } = shift;
 }
 sub _start;
 sub _initialize {
 	my ($self, $parser) = @_;
 	delete $self->{ data };
    my $characters;
    my $current = undef;
    my $ignore = [ 'Envelope', 'Body' ];        # top level elements to ignore
    my $list = [];                              # node list
    my $path = [];                              # current path (without 
                                                # number)     
    my $skip = 0;                               # skip elements
    # use "globals" for speed
    my ($_prefix, $_localname, $_element, $_method, 
        $_class, $_parser, %_attrs) = ();
    no strict qw(refs);  
    my $start_sub = sub {
            ($_parser, $_element, %_attrs) = @_;
            ($_prefix, $_localname) = split m{:}xms , $_element;
            # $parser->setHandlers( Start => \&_start );
            $_localname ||= $_element;          # for non-prefixed elements
            # ignore top level elements
            if (@{ $ignore } && $_localname eq $ignore->[0]) {
                shift @{ $ignore };
                return;
            }
            push @{ $path }, $_localname;       # step down in path
            return if $skip;                    # skip inside __SKIP__
            # resolve class of this element
            $_class = $self->{ class_resolver }->get_class( $path )
                or die "Cannot resolve class for "
                    . join('/', @{ $path }) . " via $self->{ class_resolver }";
            # maybe write as "return $skip = join ... if (...)" ?
            # would save a BLOCK...
            return $skip = join('/', @{ $path }) if ($_class eq '__SKIP__');
            push @$list, $current;   # step down in tree ()remember current)
            $characters = q{};      # empty characters
            # Check whether we have a primitive - we implement them as classes
            # We could replace this with UNIVERSAL->isa() - but it's slow...
            # match is a bit faster if the string does not match, but WAY slower 
            # if $class matches...
            if (index $_class, 'SOAP::WSDL::XSD::Typelib::Builtin', 0 < 0) {           
                # check wheter there is a CODE reference for $class::new.
                # If not, require it - all classes required here MUST
                # define new()
                # This is the same as $class->can('new'), but it's way faster  
                *{ "$_class\::new" }{ CODE } 
                    or eval "require $_class"   ## no critic qw(ProhibitStringyEval)
                        or die $@;                        
            }
            $current = $_class->new({ %_attrs });   # set new current object
            # remember top level element
            defined $self->{ data } 
                or ($self->{ data } = $current); 
        };
    my $char_sub = sub {
            return if $skip;
            $characters .= $_[1];       
    };
    my $end_sub = sub {
            $_element = $_[1];
            ($_prefix, $_localname) = split m{:}xms , $_element;          
            $_localname ||= $_element;          # for non-prefixed elements            
            pop @{ $path };                     # step up in path
            if ($skip) {
                return if $skip ne join '/', @{ $path }, $_localname;
                $skip = 0;
                return;
            }
            # This one easily handles ignores for us, too...
            return if not ref $$list[-1];
            # set characters in current if we are a simple type
            # we may have characters in complexTypes with simpleContent,
            # too - maybe we should rely on the presence of characters ?
            # may get a speedup by defining a ident method in anySimpleType 
            # and looking it up via exists &$class::ident;
            if ( $current->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType') ) {
                $current->set_value( $characters );
            }
            # set appropriate attribute in last element
            # multiple values must be implemented in base class
            $_method = "add_$_localname";
            $$list[-1]->$_method( $current );
            $current = pop @$list;           # step up in object hierarchy...       
    };
    $parser->setHandlers(
        Start => sub { 
            $_[0]->setHandlers( Start => $start_sub );
            $start_sub->(@_) },
        Char => $char_sub,
        End => $end_sub,
    );
    return $parser;
 }
 sub parse {
    $_[0]->_initialize( XML::Parser::Expat->new() )->parse( $_[1] );
    return $_[0]->{ data };     
 }
 sub parsefile {
    $_[0]->_initialize( XML::Parser::Expat->new() )->parsefile( $_[1] );
    return $_[0]->{ data };     
 }
 sub get_data {
    return $_[0]->{ data };
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Expat::MessageParser - Convert SOAP messages to custom object trees
 =head1 SYNOPSIS
 my $parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'My::Resolver'   
 });
 $parser->parse( $xml );
 my $obj = $parser->get_data();
 =head1 DESCRIPTION
 Real fast expat based SOAP message parser.
 See L<SOAP::WSDL::Parser> for details.
 =head2 Skipping unwanted items
 Sometimes there's unneccessary information transported in SOAP messages.
 To skip XML nodes (including all child nodes), just edit the type map for 
 the message and set the type map entry to '__SKIP__'. 
 =head1 Bugs and Limitations
 =over
 =item * Ignores all namespaces
 =item * Does not handle mixed content
 =item * The SOAP header is ignored
 =back
 =head1 AUTHOR
 Replace the whitespace by @ for E-Mail Address.
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 COPYING
 This module may be used under the same terms as perl itself.
 =head1 Repository information
 $ID: $
 $LastChangedDate: 2007-09-10 17:54:52 +0200 (Mo, 10 Sep 2007) $
 $LastChangedRevision: 214 $
 $LastChangedBy: kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Expat/SubParser.pm $
@@ -0,0 +1,175 @@
 package SOAP::WSDL::Expat::WSDLParser;
 use strict;
 use warnings;
 use Carp;
 use SOAP::WSDL::TypeLookup;
 use XML::Parser::Expat;
 sub new {
    my ($class, $args) = @_;
    my $self = {};
    bless $self, $class;
    return $self;
 }
 sub _initialize {
    my ($self, $parser) = @_;
    # init object data
    $self->{ parser } = $parser;
    delete $self->{ data };
    # setup local variables for keeping temp data
    my $characters = undef;
    my $current = undef;
    my $list = [];        # node list
    # TODO skip non-XML Schema namespace tags
    $parser->setHandlers(
        Start => sub {
            my ($parser, $localname, %attrs) = @_;
            $characters = q{};
            my $action = SOAP::WSDL::TypeLookup->lookup(
                $parser->namespace($localname),
                $localname
            );
            return if not $action;
            if ($action->{ type } eq 'CLASS') {
                eval "require $action->{ class }";
                croak $@ if ($@);
                my $obj = $action->{ class }->new({ parent => $current })
                  ->init( _fixup_attrs( $parser, %attrs ) );
                if ($current) {
                    # inherit namespace, but don't override
                    $obj->set_targetNamespace( $current->get_targetNamespace() )
                        if not $obj->get_targetNamespace();
                    # push on parent's element/type list
                    my $method = "push_$localname";
                    no strict qw(refs);
                    $current->$method( $obj );
                    # remember element for stepping back
                    push @{ $list }, $current;
                }
                else {
                    $self->{ data } = $obj;
                }
                # set new element (step down)
                $current = $obj;
            }
            elsif ($action->{ type } eq 'PARENT') {
                $current->init( _fixup_attrs($parser, %attrs) );
            }
            elsif ($action->{ type } eq 'METHOD') {
                my $method = $action->{ method } || $localname;
                no strict qw(refs);
                # call method with
                # - default value ($action->{ value } if defined,
                #   dereferencing lists
                # - the values of the elements Attributes hash
                # TODO: add namespaces declared to attributes.
                # Expat consumes them, so we have to re-add them here.
                $current->$method( defined $action->{ value }
                    ? ref $action->{ value }
                        ? @{ $action->{ value } }
                        : ($action->{ value })
                    : _fixup_attrs($parser, %attrs) 
                );
            }
        },
        Char => sub { $characters .= $_[1]  },
        End => sub {        
            my ($parser, $localname) = @_;
            my $action = SOAP::WSDL::TypeLookup->lookup(
                $parser->namespace( $localname ),
                $localname
            ) || {};
            return if not ($action->{ type });
            if ( $action->{ type } eq 'CLASS' )	{
        	   $current = pop @{ $list };
            }
            elsif ($action->{ type } eq 'CONTENT' ) {
                my $method = $action->{ method };
                # normalize whitespace
                $characters =~s{ ^ \s+ (.+) \s+ $ }{$1}xms;
                $characters =~s{ \s+ }{ }xmsg;
                no strict qw(refs);
                $current->$method( $characters );
            }
        }
    );
    return $parser;
 }
 # make attrs SAX style
 sub _fixup_attrs {
    my ($parser, %attrs_of) = @_;
    my @attrs_from = map { $_ = 
        {
            Name => $_, 
            Value => $attrs_of{ $_ }, 
            LocalName => $_ 
        } 
    } keys %attrs_of;
    # add xmlns: attrs. expat eats them.  
    push @attrs_from, map { 
        # ignore xmlns=FOO namespaces - must be XML schema 
        # Other nodes should be ignored somewhere else
        ($_ eq '#default')
        ? () 
        :
        { 
            Name => "xmlns:$_", 
            Value => $parser->expand_ns_prefix( $_ ),
            LocalName => $_
        }
    } $parser->new_ns_prefixes();
    return @attrs_from;
 }
 sub parse {
    $_[0]->_initialize( XML::Parser::Expat->new(
        Namespaces => 1
    ) )->parse( $_[1] );
    $_[0]->{ parser }->release();    
    return $_[0]->{ data };     
 }
 sub parsefile {
    $_[0]->_initialize( XML::Parser::Expat->new(
        Namespaces => 1
    ) )->parsefile( $_[1] );
    $_[0]->{ parser }->release();
    return $_[0]->{ data };     
 }
 # aliases to make it more SAX-like
 sub parse_file;
 *parse_file = \&parsefile;
 sub parse_string;
 *parse_string = \&parse;
 sub get_data {
    return $_[0]->{ data };
 }
 1;
@@ -0,0 +1,152 @@
 package SOAP::WSDL::Factory::Deserializer;
 use strict;
 use warnings;
 my %DESERIALIZER = (
    '1.1' => 'SOAP::WSDL::Deserializer::SOAP11',
 );
 # class method
 sub register {
    my ($class, $ref_type, $package) = @_;
    $DESERIALIZER{ $ref_type } = $package;
 }
 sub get_deserializer {
    my ($self, $args_of_ref) = @_;
    # sanity check
    die "no deserializer registered for SOAP version $args_of_ref->{ soap_version }"
        if not exists ($DESERIALIZER{ $args_of_ref->{ soap_version } });
    # load module
    eval "require $DESERIALIZER{ $args_of_ref->{ soap_version } }" 
        or die "Cannot load serializer $DESERIALIZER{ $args_of_ref->{ soap_version } }", $@;
    return $DESERIALIZER{ $args_of_ref->{ soap_version } }->new($args_of_ref);
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Factory::Deserializer - Factory for retrieving Deserializer objects
 =head1 SYNOPSIS
 # from SOAP::WSDL::Client:
 $deserializer = SOAP::WSDL::Factory::Deserializer->get_deserializer({
     soap_version => $soap_version,
     class_resolver => $class_resolver,
 });
 # in deserializer class:
 package MyWickedDeserializer;
 use SOAP::WSDL::Factory::Deserializer;
 # register class as deserializer for SOAP1.2 messages
 SOAP::WSDL::Factory::Deserializer->register( '1.2' , __PACKAGE__ );
 =head1 DESCRIPTION
 SOAP::WSDL::Factory::Deserializer serves as factory for retrieving 
 deserializer objects for SOAP::WSDL.
 The actual work is done by specific deserializer classes.
 SOAP::WSDL::Deserializer tries to load one of the following classes:
 =over
 =item * The class registered for the scheme via register()
 =back
 By default, L<SOAP::WSDL::Deserializer::SOAP11|SOAP::WSDL::Deserializer::SOAP11> 
 is registered for SOAP1.1 messages.
 =head1 METHODS
 =head2 register
 SOAP::WSDL::Deserializer->register('1.1', 'MyWickedDeserializer');
 Globally registers a class for use as deserializer class.
 =head2 get_deserializer
 Returns an object of the deserializer class for this endpoint.
 =head1 WRITING YOUR OWN DESERIALIZER CLASS
 Deserializer classes may register with SOAP::WSDL::Factory::Deserializer.
 =head2 Registering a deserializer
 Registering a deserializer class with SOAP::WSDL::Factory::Deserializer 
 is done by executing the following code where $version is the SOAP version 
 the class should be used for, and $class is the class name.
 SOAP::WSDL::Factory::Deserializer->register( $version, $class);
 To auto-register your transport class on loading, execute register() 
 in your tranport class (see L<SYNOPSIS|SYNOPSIS> above).
 =head2 Deserializer package layout
 Deserializer modules must be named equal to the deserializer class they 
 contain. There can only be one deserializer class per deserializer module.
 =head2 Methods to implement
 Deserializer classes must implement the following methods:
 =over 
 =item * new
 Constructor.
 =item * deserialize
 Deserialize data from XML to arbitrary formats. 
 deserialize() must return a fault indicating that deserializing failed if 
 any error is encountered during the process of deserializing the XML message.
 The following positional parameters are passed to the deserialize method:
 $content   - the xml message 
 =item * generate_fault
 Generate a fault in the supported format. The following named parameters are 
 passed as a single hash ref:
 code       - The fault code, e.g. 'soap:Server' or the like
 role       - The fault role (actor in SOAP1.1) 
 message    - The fault message (faultstring in SOAP1.1)
 =back
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 176 $
 $LastChangedBy: kutterma $
 $Id: Serializer.pm 176 2007-08-31 15:28:29Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Factory/Serializer.pm $
 =cut
@@ -0,0 +1,144 @@
 package SOAP::WSDL::Factory::Serializer;
 use strict;
 use warnings;
 my %SERIALIZER = (
    '1.1' => 'SOAP::WSDL::Serializer::SOAP11',
 );
 # class method
 sub register {
    my ($class, $ref_type, $package) = @_;
    $SERIALIZER{ $ref_type } = $package;
 }
 sub get_serializer {
    my ($self, $args_of_ref) = @_;
    # sanity check
    die "no deserializer registered for SOAP version $args_of_ref->{ soap_version }"
        if not exists ($SERIALIZER{ $args_of_ref->{ soap_version } });
    # load module
    eval "require $SERIALIZER{ $args_of_ref->{ soap_version } }" 
        or die "Cannot load serializer $SERIALIZER{ $args_of_ref->{ soap_version } }", $@;
    return $SERIALIZER{ $args_of_ref->{ soap_version } }->new();
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Factory::Serializer - Factory for retrieving serializer objects
 =head1 SYNOPSIS
 # from SOAP::WSDL::Client:
 $serializer = SOAP::WSDL::Factory::Serializer->get_serializer({
     soap_version => $soap_version,
 });
 # in serializer class:
 package MyWickedSerializer;
 use SOAP::WSDL::Factory::Serializer;
 # register as serializer for SOAP1.2 messages
 SOAP::WSDL::Factory::Serializer->register( '1.2' , __PACKAGE__ );
 =head1 DESCRIPTION
 SOAP::WSDL::Factory::Serializer serves as factory for retrieving 
 serializer objects for SOAP::WSDL.
 The actual work is done by specific serializer classes.
 SOAP::WSDL::Serializer tries to load one of the following classes:
 =over
 =item * the class registered for the scheme via register()
 =back
 =head1 METHODS
 =head2 register
 SOAP::WSDL::Serializer->register('1.1', 'MyWickedSerializer');
 Globally registers a class for use as serializer class.
 =head2 get_serializer
 Returns an object of the serializer class for this endpoint.
 =head1 WRITING YOUR OWN SERIALIZER CLASS
 =head2 Registering a deserializer
 Serializer classes may register with SOAP::WSDL::Factory::Serializer.
 Serializer objects may also be passed directly to SOAP::WSDL::Client by 
 using the set_serializer method. Note that serializers objects set via 
 SOAP::WSDL::Client's set_serializer method are discarded when the SOAP 
 version is changed via set_soap_version.
 Registering a serializer class with SOAP::WSDL::Factory::Serializer is done 
 by executing the following code where $version is the SOAP version the 
 class should be used for, and $class is the class name.
 SOAP::WSDL::Factory::Serializer->register( $version, $class);
 To auto-register your transport class on loading, execute register() in 
 your tranport class (see L<SYNOPSIS|SYNOPSIS> above).
 =head2 Serializer package layout
 Serializer modules must be named equal to the serializer class they contain. 
 There can only be one serializer class per serializer module.
 =head2 Methods to implement
 Serializer classes must implement the following methods:
 =over 
 =item * new
 Constructor.
 =item * serialize
 Serializes data to XML. The following named parameters are passed to the 
 serialize method in a anonymous hash ref:
 {
   method => $operation_name,
   header => $header_data,
   body => $body_data,
 }
 =back
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 225 $
 $LastChangedBy: kutterma $
 $Id: Serializer.pm 225 2007-09-10 19:04:57Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Factory/Serializer.pm $
 =cut
@@ -0,0 +1,240 @@
 package SOAP::WSDL::Factory::Transport;
 use strict;
 use warnings;
 # class data
 my %registered_transport_of = ();
 # Local constants
 # Could be made readonly, but that's just for the paranoid...
 my %SOAP_LITE_TRANSPORT_OF = (
    ftp => 'SOAP::Transport::FTP',
    http => 'SOAP::Transport::HTTP',
    https => 'SOAP::Transport::HTTPS',
    mailto => 'SOAP::Transport::MAILTO',
    'local' => 'SOAP::Transport::LOCAL',
    jabber => 'SOAP::Transport::JABBER',
    mq => 'SOAP::Transport::MQ',        
 );
 my %SOAP_WSDL_TRANSPORT_OF = (
    http => 'SOAP::WSDL::Transport::HTTP',
    https => 'SOAP::WSDL::Transport::HTTP',   
 );
 # class methods only
 sub register {
    my ($class, $scheme, $package) = @_;
    die "cannot use reference as scheme" if ref $scheme;
    $registered_transport_of{ $scheme } = $package;
 }
 sub get_transport {
    my ($class, $scheme, %attrs) = @_;
    $scheme =~s{ \A ([^\:]+) \: .+ }{$1}smx;
    if (exists $registered_transport_of{ $scheme }) {
        eval "require $registered_transport_of{ $scheme }" or die $@;
        # try "foo::Client" class first - SOAP::Tranport always requires 
        # a package withoug the ::Client appended, and then
        # instantiates a ::Client object...
        # ... pretty weird ...
        # ... must be from some time when the max number of files was a 
        # sparse resource ...
        # ... but we've decided to mimic SOAP::Lite...
        my $protocol_class = $SOAP_LITE_TRANSPORT_OF{ $scheme } . '::Client';
        my $transport;
        eval {
            $transport = $protocol_class->new( %attrs );
        };
        return $transport if not $@;
        return $registered_transport_of{ $scheme }->new( %attrs );
    }
    # try SOAP::Lite's Transport module - just skip if not require'able
    SOAP_Lite: {
      if (exists $SOAP_LITE_TRANSPORT_OF{ $scheme }) {
          eval "require $SOAP_LITE_TRANSPORT_OF{ $scheme }"
            or last SOAP_Lite;
          my $protocol_class = $SOAP_LITE_TRANSPORT_OF{ $scheme } . '::Client';
          return $protocol_class->new( %attrs );
      }
    }
    if (exists $SOAP_WSDL_TRANSPORT_OF{ $scheme }) {
        eval "require $SOAP_WSDL_TRANSPORT_OF{ $scheme }" or die $@;
        return $SOAP_WSDL_TRANSPORT_OF{ $scheme }->new( %attrs );
    }
    die "no transport class found for scheme <$scheme>";
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Factory::Transport - Factory for retrieving transport objects
 =head1 SYNOPSIS
 # from SOAP::WSDL::Client:
 $transport = SOAP::WSDL::Factory::Transport->get_transport( $url, @opt );
 # in transport class:
 package MyWickedTransport;
 use SOAP::WSDL::Factory::Transport;
 # register class as transport module for httpr and https
 # (httpr is "reliable http", a protocol developed by IBM).
 SOAP::WSDL::Factory::Transport->register( 'httpr' , __PACKAGE__ );
 SOAP::WSDL::Factory::Transport->register( 'https' , __PACKAGE__ );
 =head1 DESCRIPTION
 SOAP::WSDL::Transport serves as factory for retrieving transport objects for 
 SOAP::WSDL.
 The actual work is done by specific transport classes.
 SOAP::WSDL::Transport tries to load one of the following classes:
 =over 
 =item * the class registered for the scheme via register()
 =item * the SOAP::Lite class matching the scheme
 =item * the SOAP::WSDL class matching the scheme
 =back
 =head1 METHODS
 =head2 register
 SOAP::WSDL::Transport->register('https', 'MyWickedTransport');
 Globally registers a class for use as transport class.
 =head2 proxy
 $trans->proxy('http://soap-wsdl.sourceforge.net');
 Sets the proxy (endpoint). 
 Returns the transport for this protocol.
 =head2 set_transport
 Sets the current transport object.
 =head2 get_transport
 Gets the current transport object.
 =head1 WRITING YOUR OWN TRANSPORT CLASS
 =head2 Registering a transport class
 Transport classes must be registered with SOAP::WSDL::Factory::Transport. 
 This is done by executing the following code where $scheme is the URL scheme 
 the class should be used for, and $module is the class' module name. 
 SOAP::WSDL::Factory::Transport->register( $scheme, $module);
 To auto-register your transport class on loading, execute register() in your 
 tranport class (see L<SYNOPSIS|SYNOPSIS> above).
 Multiple protocols ore multiple classes are registered by multiple calls to 
 register().
 =head2 Transport plugin package layout
 You may only use transport classes whose name is either 
 the module name or the module name with '::Client' appended.
 =head2 Methods to implement
 Transport classes must implement the interface required for SOAP::Lite 
 transport classes (see L<SOAP::Lite::Transport> for details, 
 L<SOAP::WSDL::Transport::HTTP|SOAP::WSDL::Transport::HTTP> for an example).
 To provide this interface, transport modules must implement the following 
 methods:
 =over 
 =item * new
 =item * send_receive
 Dispatches a request and returns the content of the response.
 =item * code
 Returns the status code of the last send_receive call (if any).
 =item * message
 Returns the status message of the last send_receive call (if any).
 =item * status
 Returns the status of the last send_receive call (if any).
 =item * is_success
 Returns true after a send_receive was successful, false if it was not.
 =back
 SOAP::Lite requires transport modules to pack client and server 
 classes in one file, and to follow this naming scheme:
 Module name: 
   "SOAP::Transport::" . uc($scheme)
 Client class (additional package in module):
   "SOAP::Transport::" . uc($scheme) . "::Client"
 Server class (additional package in module):
   "SOAP::Transport::" . uc($scheme) . "::Client"
 SOAP::WSDL does not require you to follow these restrictions.
 There is only one restriction in SOAP::WSDL:
 You may only use transport classes whose name is either the module name or 
 the module name with '::Client' appended.
 SOAP::WSDL will try to instantiate an object of your transport class with 
 '::Client' appended to allow using transport classes written for SOAP::Lite.
 This may lead to errors when a different module with the name of your 
 transport module suffixed with ::Client is also loaded.
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 225 $
 $LastChangedBy: kutterma $
 $Id: Transport.pm 225 2007-09-10 19:04:57Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Factory/Transport.pm $
 =cut
@@ -35,9 +35,6 @@ the service's interface structure.
 The results of all calls to your service object's methods (except new) 
 are objects based on SOAP::WSDL's XML schema implementation.
 These objects are false in boolean context, and serialize to XML when 
 printed.
 To access the object's properties use get_NAME / set_NAME getter/setter 
 methods whith NAME corresponding to the XML tag name.
@@ -11,9 +11,12 @@ some internet protocol, typically via HTTP(S).
 =head2 SOAP
-SOAP (the Simple Object Access Protocol) is a specification for 
+SOAP is an acronym for Simple Object Access Protocol. 
-defining RPC interfaces, including (but not neccessarily limited to) 
+SOAP is a W3C recommendation. The latest version of the SOAP 
-web services. 
+specification may be found at L<http://www.w3.org/TR/soap/>.
 SOAP defines a protocoll for message exchange between applications. 
 The most popular usage is to use SOAP for remote procedure calls (RPC).
 While one of the constituting aspects of a web service is its 
 reachability via some internet protocol, you might as well define 
@@ -26,15 +29,52 @@ carry your pet.
 =head2 WSDL
-WSDL (Web Service Definition Language) is a XML-based markup language 
+WSDL is an acronym for Web Services Description Language. 
-for defining web service interfaces. 
+WSDL is a W3C recommendation. The latest version of the WSDL specification 
 may be found at L<http://www.w3.org/TR/wsdl20/>. 
 WSDL defines a XML-based language for describing web service interfaces, 
 including SOAP interfaces.
 =head2 WS-I
-WS-I (Web Service Interoperability) is a industry consortium dedicated 
+WS-I (Web Services Interoperability Organization) is an open industry 
-to finding interoperability rules for web services.
+organisation chartered to promote Web service interoperability across 
 platforms, operating systems, and programming languages.
-SOAP::WSDL aims to be a WS-I compliant SOAP client.
+WS-I publishes profiles, which provide implementation guidelines for 
 how related Web services specifications should be used together for 
 best interoperability. To date, WS-I has finalized the Basic Profile, 
 Attachments Profile and Simple SOAP Binding Profile. 
 SOAP::WSDL aims at complying to the Basic Profile (but does not 
 implement full support yet).
 =head2 SOAP message styles
 =head3 rpc
 Meant for transporting a RPC message. All contents of the SOAP body are 
 put into a top-level node named equal to the SOAP operation.
 WS-I Basic Profile allows the use of rpc message style.
 SOAP::WSDL does not support rpc message style yet.
 SOAP::Lite supports rpc message style only.
 =head3 document
 Meant for transporting arbitrary content. No additional nodes are inserted 
 between the SOAP body and the actual content.
 WS-I Basic Profile allows the use of document message style.
 =head2 SOAP encoding styles
 =head3 encoded
 =head3 literal
 =head1 LICENSE
@@ -6,8 +6,8 @@ SOAP::WSDL::Parser - How SOAP::WSDL parses XML messages
 =head1 Which XML message does SOAP::WSDL parse ?
-Naturally, there are two kinds of XMLdocuments (or messages) SOAP::WSDL 
+Naturally, there are two kinds of XML documents (or messages) 
-has to parse:
+SOAP::WSDL has to parse:
 =over
@@ -19,13 +19,55 @@ has to parse:
 =head1 Parser implementations
-There are different parser implementations available for SOAP messages - 
+There are different parser implementations available for SOAP messages 
-currently there's only one for WSDL definitions.
+and WSDL definitions.
 Historically, SOAP::WSDL used SAX for parsing XML. The SAX handlers 
 were implemented as L<XML::LibXML|XML::LibXML> handlers, which 
 also worked with L<XML::SAX::ParserFactory|XML::SAX::ParserFactory>.
 The use of SAX and L<XML::LibXML|XML::LibXML> in SOAP::WSDL is 
 deprecated for the following reasons:
 =over
 =item * Speed
 L<XML::Parser::Expat|XML::Parser::Expat> is faster than 
 L<XML::LibXML|XML::LibXML> - at least when optimized for speed.
 =item * Availability
 L<XML::Parser|XML::Parser> is more popular than 
 L<XML::LibXML|XML::LibXML>.
 =item * Stability
 XML::LibXML is based on the libxml2 library. Several versions of 
 libxml2 are known to have specific bugs. As a workaround, there are 
 often several versions of libxml2 installed on one system. This may 
 lead to problems on operating systems which cannot load more than 
 one version of a shared library simultaneously.
 =item * SOAP::Lite uses XML::Parser
 L<SOAP::Lite|SOAP::Lite> uses L<XML::Parser|XML::Parser> if available. 
 SOAP::WSDL should not require users to install both L<XML::Parser|XML::Parser> 
 and L<XML::LibXML|XML::LibXML>.
 =back
 =head2 WSDL definitions parser
 =over
 =item * SOAP::WSDL::Expat::WSDLParser
 A parser for WSDL definitions based on L<XML::Parser::Expat|XML::Parser::Expat>.
 my $parser = SOAP::WSDL::Expat::WSDLParser->new();
 my $wsdl = $parser->parse_file( $filename );
 =item * SOAP::WSDL::SAX::WSDLHandler
 This is a SAX handler for parsing WSDL files into object trees SOAP::WSDL 
@@ -132,6 +174,19 @@ L<SOAP::WSDL::XSD::Typelib::ComplexType> and L<SOAP::WSDL::XSD::Typelib::SimpleT
 =over
 =item * SOAP::WSDL::Expat::MessageParser
 A L<XML::Parser::Expat|XML::Parser::Expat> based parser. This is the fastest 
 parser for most SOAP messages and the default for SOAP::WSDL::Client.
 =item * SOAP::WSDL::Expat::MessageStreamParser
 A XML::Parser::ExpatNB based parser. Useful for parsing huge HTTP responses, 
 as you don't need to keep everything in memory.
 See L<SOAP::WSDL::Expat::MessageStreamParser|SOAP::WSDL::Expat::MessageStreamParser> 
 for details.
 =item * SOAP::WSDL::SAX::MessageHandler
 This is a SAX handler for parsing WSDL files into object trees SOAP::WSDL 
@@ -144,18 +199,6 @@ Can be used for parsing both streams (chunks) and documents.
 See L<SOAP::WSDL::SAX::MessageHandler> for details.
 =item * SOAP::WSDL::Expat::MessageParser
 A L<XML::Parser::Expat|XML::Parser::Expat> based parser. This is the fastest 
 parser for most SOAP messages and the default for SOAP::WSDL::Client.
 =item * SOAP::WSDL::Expat::MessageStreamParser
 A XML::Parser::ExpatNB based parser. Useful for parsing huge HTTP responses, 
 as you don't need to keep everything in memory.
 See L<SOAP::WSDL::Expat::MessageStreamParser|SOAP::WSDL::Expat::MessageStreamParser> for details.
 =back
 =head3 Performance
@@ -273,9 +273,9 @@ This module may be used under the same terms as perl itself.
 $ID: $
- $LastChangedDate: $
+ $LastChangedDate: 2007-09-10 17:54:52 +0200 (Mo, 10 Sep 2007) $
- $LastChangedRevision: $
+ $LastChangedRevision: 214 $
- $LastChangedBy: $
+ $LastChangedBy: kutterma $
- $HeadURL: $
+ $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/SAX/MessageHandler.pm $
@@ -1,13 +1,18 @@
 #!/usr/bin/perl -w
-package SOAP::WSDL::Envelope;
+package SOAP::WSDL::Serializer::SOAP11;
 use strict;
-use base qw/SOAP::WSDL::Base/;
+use warnings;
 use Class::Std::Storable;
 our $VERSION='2.00_13';
 my $SOAP_NS = 'http://schemas.xmlsoap.org/soap/envelope/';
 my $XML_INSTANCE_NS = 'http://www.w3.org/2001/XMLSchema-instance';
 sub serialize {
-    my ($self, $name, $data, $opt) = @_;
+    my ($self, $args_of_ref) = @_;
    my $opt = $args_of_ref->{ options };   
    if (not $opt->{ namespace }->{ $SOAP_NS })
    {
@@ -32,8 +37,9 @@ sub serialize {
    # TODO insert encoding
    $xml.='>';
-    $xml .= $self->serialize_header($name, $data, $opt);
+    $xml .= $self->serialize_header($args_of_ref->{ method }, $args_of_ref->{ header }, $opt);
-    $xml .= $self->serialize_body($name, $data, $opt);
+    $xml .= "\n" if ($opt->{ readable });
    $xml .= $self->serialize_body($args_of_ref->{ method }, $args_of_ref->{ body }, $opt);
    $xml .= "\n" if ($opt->{ readable });
    $xml .= '</' . $soap_prefix .':Envelope>';
    $xml .= "\n" if ($opt->{ readable });
@@ -41,26 +47,25 @@ sub serialize {
 }
 sub serialize_header {
-    my $xml = '';
+    my ($self, $name, $data, $opt) = @_;
-    return $xml;
+    
    # header is optional. Leave out if there's no header data
    return q{} if not $data;
    return join ( ($opt->{ readable }) ? "\n" : q{}, 
        "<$opt->{ namespace }->{ $SOAP_NS }\:Header>",
        "$data",
        "</$opt->{ namespace }->{ $SOAP_NS }\:Header>",
    );
 }
 sub serialize_body {
-    my $self = shift;
+    my ($self, $name, $data, $opt) = @_;
    my $name = shift;
    my $data = shift;
    my $opt = shift;
-    my $soap_prefix = $opt->{ namespace }->{ $SOAP_NS };
+    # Body is NOT optional. Serialize to empty body 
-
+    # if we have no data.
-    my $xml = '';
+    return join ( ($opt->{ readable }) ? "\n" : q{}, 
-    $xml .= "\n" if ($opt->{ readable });
+        "<$opt->{ namespace }->{ $SOAP_NS }\:Body>",
-    $xml .= "<$soap_prefix\:Body>";
+        defined $data ? "$data" : (),
-    $xml .= "\n" if ($opt->{ readable });
+        "</$opt->{ namespace }->{ $SOAP_NS }\:Body>",
-
+    );
    # include parts
    $xml .= $data if ( defined($data) );
    $xml .= "</$soap_prefix\:Body>";
    return $xml;
 }
@@ -0,0 +1,101 @@
 package SOAP::WSDL::Transport::HTTP;
 use strict;
 use base qw(LWP::UserAgent);
 # create methods normally inherited from SOAP::Client
 SUBFACTORY: {
    no strict qw(refs);
    foreach my $method ( qw(code message status is_success) ) {
        *{ $method } = sub { 
            my $self = shift;
            return $self->{ $method } if not @_;
            return $self->{ $method } = shift;
        };
    }
 }
 sub send_receive {
    my ($self, %parameters) = @_;
    my ($envelope, $soap_action, $endpoint, $encoding, $content_type) =
        @parameters{qw(envelope action endpoint encoding content_type)};
    $encoding = defined($encoding) 
        ? 'utf8' 
        : lc($encoding);
    # TODO check whether we need this with current LWP::UserAgent - we're 
    # not here to fix LWP::UserAgent bugs...
    #
    # what's this all about?
    # unfortunately combination of LWP and Perl 5.6.1 and later has bug
    # in sending multibyte characters. LWP uses length() to calculate
    # content-length header and starting 5.6.1 length() calculates chars
    # instead of bytes. 'use bytes' in THIS file doesn't work, because
    # it's lexically scoped. Unfortunately, content-length we calculate
    # here doesn't work either, because LWP overwrites it with
    # content-length it calculates (which is wrong) AND uses length()
    # during syswrite/sysread, so we are in a bad shape anyway.
    #
    # what to do? we calculate proper content-length (using
    # bytelength() function from SOAP::Utils) and then drop utf8 mark
    # from string (doing pack with 'C0A*' modifier) if length and
    # bytelength are not the same
    # use bytes is lexically scoped
    my $bytelength = do { use bytes; length $envelope };
    $envelope = pack('C0A*', $envelope) 
        if length($envelope) != $bytelength;
    # END TODO
    my $request = HTTP::Request->new( 'POST',
        $endpoint,
        [   'Content-Type', "$content_type; charset=$encoding",
            'Content-Length', $bytelength,
            'SOAPAction', $soap_action,
        ],
        $envelope );
    my $response = $self->request( $request );
    $self->code( $response->code);
    $self->message( $response->message);
    $self->is_success($response->is_success);
    $self->status($response->status_line);
    return $response->content();    
 }
 1;
 =pod
 =head1 NAME
 SOAP::WSDL::Transport::HTTP - Fallback http(s) transport class
 =head1 DESCRIPTION
 Provides a thin transport class used by SOAP::WSDL::Transport when 
 SOAP::Lite is not available.
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 218 $
 $LastChangedBy: kutterma $
 $Id: HTTP.pm 218 2007-09-10 16:19:23Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Transport/HTTP.pm $
 =cut
@@ -0,0 +1,129 @@
 package SOAP::WSDL::Transport::Test;
 use strict;
 use warnings;
 use Class::Std::Storable;
 use SOAP::WSDL::Factory::Transport;
 our $VERSION = '2.00_14'; 
 SOAP::WSDL::Factory::Transport->register( http => __PACKAGE__ );
 SOAP::WSDL::Factory::Transport->register( https => __PACKAGE__ );
 my %code_of :ATTR(:name<code>           :default<()>);
 my %status_of :ATTR(:name<status>       :default<()>);
 my %message_of :ATTR(:name<message>     :default<()>);
 my %is_success_of :ATTR(:name<is_success> :default<()>);
 my %base_dir_of :ATTR(:name<base_dir> :init_arg<base_dir> :default<.>);
 # create methods normally inherited from SOAP::Client
 SUBFACTORY: {
    no strict qw(refs);
    foreach my $method ( qw(code message status is_success) ) {
        *{ $method } = *{ "get_$method" };
    }
 }
 sub send_receive {
    my ($self, %parameters) = @_;
    my ($envelope, $soap_action, $endpoint, $encoding, $content_type) =
        @parameters{qw(envelope action endpoint encoding content_type)};
    my $filename = $soap_action;
    $filename =~s{ \A(:?'|") }{}xms;
    $filename =~s{ (:?'|")\z }{}xms;
    $filename =~s{ \A [^:]+ : (:? /{2})? }{}xms;
    $filename = join '/', $base_dir_of{ ident $self }, "$filename.xml";
    if (not -r $filename) { 
        warn "cannot access $filename";
        $self->set_code( 500 );
        $self->set_message( "Failed" );
        $self->set_is_success(0);
        $self->set_status("500 Failed");
        return;    
    }
    open my $fh, '<', $filename or die "cannot open $filename: $!";
    binmode $fh;
    my $response = <$fh>;
    close $fh or die "cannot close $filename: $!"; 
    $self->set_code( 200 );
    $self->set_message( "OK" );
    $self->set_is_success(1);
    $self->set_status("200 OK");    
    return $response;
 }
 1;
 =head1 NAME
 SOAP::WSDL::Transport::Test - Test transport class for SOAP::WSDL
 =head1 SYNOPSIS
 use SOAP::WSDL::Client;
 use SOAP::WSDL::Transport::Test;
 my $soap = SOAP::WSDL::Client->new()
 $soap->get_transport->set_base_dir('.');
 $soap->call('method', \%body, \%header);
 =head1 DESCRIPTION
 SOAP::WSDL::Transport::Test is a file-based test transport backend for 
 SOAP::WSDL. 
 When SOAP::WSDL::Transport::Test is used as transport backend, the reponse is 
 read from a XML file and the request message is discarded. This is particularly 
 useful for testing SOAP::WSDL plugins.
 =head2 Filename resolution
 SOAP::WSDL::Transport makes up the response XML file name from the SOAPAction 
 of the request. The following filename is used:
 base_dir / soap_action .xml
 The protocol scheme (e.g. http:) and two heading slashes (//) are stripped from 
 the soap_action.
 base_dir defaults to '.'
 Examples:
 SOAPAction: http://somewhere.over.the.rainbow/webservice/webservice.asmx
 Filename: ./somewhere.over.the.rainbow/webservice/webservice.asmx.xml
 SOAPAction: uri:MyWickedService/test
 Filename: ./MyWickedService/test.xml
 =head1 METHODS
 =head2 set_base_dir
 Sets the base directory SOAP::WSDL::Transport::Test should look for response 
 files.
 =head1 LICENSE
 Copyright 2004-2007 Martin Kutter.
 This file is part of SOAP-WSDL. You may distribute/modify it under 
 the same terms as perl itself
 =head1 AUTHOR
 Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 =head1 REPOSITORY INFORMATION
 $Rev: 218 $
 $LastChangedBy: kutterma $
 $Id: HTTP.pm 218 2007-09-10 16:19:23Z kutterma $
 $HeadURL: https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/Transport/HTTP.pm $
 =cut
@@ -14,6 +14,8 @@ my %base_of         :ATTR(:name<base>       :default<()>);
 my %itemType_of     :ATTR(:name<itemType>   :default<()>);
 my %enumeration_of  :ATTR(:name<enumeration>   :default<()>);
 my %abstract_of     :ATTR(:name<abstract>   :default<()>);
 my %mixed_of        :ATTR(:name<mixed>      :default<()>);      # default is false
 # is set to simpleContent/complexContent
 my %content_Model_of    :ATTR(:name<contentModel>   :default<()>);
@@ -181,7 +183,7 @@ sub to_class {
 my $template = <<'EOT';
 package [% type_prefix %][% self.get_name %];
 use strict;
-use Class::Std::Storable;
+
 use SOAP::WSDL::XSD::Typelib::ComplexType;
 use base qw(
    SOAP::WSDL::XSD::Typelib::ComplexType
@@ -269,7 +271,7 @@ methods:
 [% element.get_name -%]
 [%      END %]
-=head1 Object structure
+[% head1 %] Object structure
 [% FOREACH element=self.get_element;
        IF (element.get_type);
@@ -244,7 +244,7 @@ sub to_class {
 my $template = <<'EOT';
 package [% element_prefix %][% self.get_name %];
 use strict;
-use Class::Std::Storable;
+
 use SOAP::WSDL::XSD::Typelib::Element;
 [% IF (type = self.first_simpleType) %]
@@ -215,13 +215,20 @@ All input variants supported by Date::Parse are supported. You may even pass
 in dateTime strings - the time part will be ignored. Note that 
 set_value is around 100 times slower when setting non-XML-time strings
 When setting dates before the beginning of the epoch (negative UNIX timestamp), 
 you should use the XML date string format for setting dates. The behaviour of 
 Date::Parse for dates before the epoch is system dependent.
 =head2 SOAP::WSDL::XSD::Typelib::Builtin::dateTime
 dateTime values are automatically converted into XML dateTime strings during setting:
 YYYY-MM-DDThh:mm:ss.nnnnnnn+zz:zz
-The optional nanoseconds parts is excluded in converted values, as it would always be 0.
+The fraction of seconds (nnnnnnn) part is optional. Fractions of seconds may 
 be given with arbitrary precision
 The fraction of seconds part is excluded in converted values, as it would always be 0.
 All input variants supported by Date::Parse are supported. Note that 
 set_value is around 100 times slower when setting non-XML-time strings
@@ -13,15 +13,23 @@ my %value_of :ATTR(:get<value> :init_arg<value> :default<()>);
 # and we don't need to return the last value...
 sub set_value { $value_of{ ident $_[0] } = $_[1] }
 # use $_[n] for speed.
 # This is less readable, but notably faster.
 #
 # use postfix-if for speed. This is slightly faster, as it saves 
 # perl from creating a pad (variable context).
 #
 # The methods below may get called zillions of times, so 
 # every little statement matters...
 sub serialize {
-    my ($self, $opt) = @_;
+    no warnings qw(uninitialized);
-    my $ident = ident $self;
+    my $ident = ident $_[0];
-    $opt ||= {};
+    $_[1]->{ nil } = 1 if not defined $value_of{ $ident };
-    return $self->start_tag({ %$opt, nil => 1})
+    return join q{}
-        if not defined $value_of{ $ident };
+        , $_[0]->start_tag($_[1], $value_of{ $ident })
    return join q{}, $self->start_tag($opt, $value_of{ $ident })
        , $value_of{ $ident }
-        , $self->end_tag($opt);
+        , $_[0]->end_tag($_[1]); 
 }
 # TODO disallow serializing !
@@ -3,7 +3,9 @@ use strict;
 use warnings;
 use Class::Std::Storable;
-my %xmlns_of :ATTR(:name<xmlns> :default<()>);
+my %xmlns_of :ATTR(:get<xmlns> :init_arg<xmlns> :default<()>);
 sub set_xmlns { $xmlns_of{ ident $_[0] } = $_[1] };
 # use $_[1] for performance
 sub start_tag { 
@@ -19,6 +21,8 @@ sub end_tag {
        : q{};
 };
 sub serialize { q{} };
 sub serialize_qualified :STRINGIFY {
    return $_[0]->serialize( { qualified => 1 } );
 }
@@ -1,6 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::boolean;
 use strict;
 use warnings;
 use Class::Std::Storable;
 my %pattern_of          :ATTR(:name<pattern> :default<()>);
 my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
@@ -9,7 +10,7 @@ my %value_of            :ATTR(:get<value> :init_attr<value> :default<()>);
 # Speed up. Class::Std::new is slow - and we don't need it's functionality...
 BEGIN {
-    use Class::Std::Storable;
+#    use Class::Std::Storable;
    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
    no warnings qw(redefine);
@@ -39,25 +39,39 @@ sub set_value {
    #2037-12-31+01:00
    if (
        $_[1] =~ m{ ^\d{4} \- \d{2} \- \d{2} 
-            (:? [\+\-] \d{2} \: \d{2} )?$
+            (:? [\+\-] \d{2} \: \d{2} )$
        }xms       
    ) {
        $_[0]->SUPER::set_value($_[1])
    }
-    # use a combination of strptime and strftime for converting the date
+    # converting a date is hard work: It needs a timezone, because 
-    # Unfortunately, strftime outputs the time zone as [+-]0000, whereas XML
+    # 2007-12-30+12:00 and 2007-12-31-12:00 mean the same day - just in 
-    # whants it as [+-]00:00
+    # different locations.
-    # We know that the latter part of the TZ is always :00 (there's no time 
+    # strftime actually prints out the correct date, but always prints the 
-    # zone whith minute offset yet), so we just use substr to get the part 
+    # local timezone with %z.
-    # up to the last 2 timezone digits and append :00
+    # So, if our timezone is not 0, we strftime it without timezone and 
-    # We leave out the optional nanoseconds part, as it would always be empty.
+    # append it by hand by the following formula:
    # The timezone hours are the int (timesone seconds / 3600)
    # The timezone minutes (if someone ever specifies something like that) 
    # are int( (seconds % 3600) / 60 ) 
    # say, int( (seconds modulo 3600) / 60 )
    #
    # If we have no timezone (meaning the timezone is 
    else {
        # strptime sets empty values to undef - and strftime doesn't like that...
-        my @time_from = map { ! defined $_ ? 0 : $_ } strptime($_[1]);
+        my @time_from =  strptime($_[1]);
-        my $time_str = strftime( '%Y-%m-%d%z', @time_from );
+        my $time_zone_seconds = $time_from[6];
        @time_from = map { (! defined $_) ? 0 : $_ } @time_from;
 #        use Data::Dumper;
 #        warn Dumper \@time_from, sprintf('%+03d%02d', $time_from[6] / 3600, $time_from[6] % 60 );
        my $time_str = defined $time_zone_seconds
          ? strftime( '%Y-%m-%d', @time_from ) 
            . sprintf('%+03d%02d', int($time_from[6] / 3600), int ( ($time_from[6] % 3600) / 60 ) )
          : do { 
              strftime( '%Y-%m-%d%z', @time_from );
          };
        substr $time_str, -2, 0, ':';
        $_[0]->SUPER::set_value($time_str);
    }
 }
@@ -37,29 +37,20 @@ BEGIN {
 sub set_value {
    # use set_value from base class if we have a XML-DateTime format
    #2037-12-31T00:00:00.0000000+01:00
-    if (
+    return $_[0]->SUPER::set_value($_[1]) if (
        $_[1] =~ m{ ^\d{4} \- \d{2} \- \d{2} 
            T \d{2} \: \d{2} \: \d{2} (:? \. \d{1,7} )?
            [\+\-] \d{2} \: \d{2} $
        }xms       
-    ) {
+    );
        $_[0]->SUPER::set_value($_[1])
    }
    # use a combination of strptime and strftime for converting the date
    # strptime does not emit timezone info, so we're pretty fucked up here.
    # 
    # Unfortunately, strftime outputs the time zone as [+-]0000, whereas XML
    # whants it as [+-]00:00
    # We leave out the optional nanoseconds part, as it would always be empty.
    else {
        # strptime sets empty values to undef - and strftime doesn't like that...
        my @time_from = map { ! defined $_ ? 0 : $_ } strptime($_[1]);
        undef $time_from[-1];
-        my $time_str = strftime( '%Y-%m-%dT%H:%M:%S%z', @time_from );
+    # strptime sets empty values to undef - and strftime doesn't like that...
-        substr $time_str, -2, 0, ':';
+    my @time_from = map { ! defined $_ ? 0 : $_ } strptime($_[1]);
-        $_[0]->SUPER::set_value($time_str);
+    undef $time_from[-1];
-    }
+        
    my $time_str = strftime( '%Y-%m-%dT%H:%M:%S%z', @time_from );
    substr $time_str, -2, 0, ':';
    $_[0]->SUPER::set_value($time_str);
 }
 1;
@@ -4,9 +4,9 @@ use strict;
 use warnings;
 use Carp;
 use SOAP::WSDL::XSD::Typelib::Builtin;
-use Scalar::Util qw(blessed);
+use Scalar::Util qw(blessed refaddr);
 use Class::Std::Storable;
 use Data::Dumper;
 use Class::Std::Storable;
 use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
@@ -14,6 +14,32 @@ my %ELEMENTS_FROM;
 my %ATTRIBUTES_OF;
 my %CLASSES_OF;
 # STORABLE_ methods for supporting Class::Std::Storable.
 # We could also handle them via AUTOMETHOD,
 # but AUTOMETHOD should always croak...
 sub STORABLE_freeze_pre {  
 }
 sub STORABLE_freeze_post {  
 }
 sub STORABLE_thaw_pre {  
 }
 sub STORABLE_thaw_post {  
 }
 # for error reporting. Eases working with data objects...
 sub AUTOMETHOD {
    my ($self, $ident, @args_from) = @_;
    my $class = ref $self || $self;
    confess "Can't locate object method \"$_\" via package \"$class\". \n"
        . "Valid methods are: " 
        . join(', ', map { ("get_$_" , "set_$_") } keys %{ $ATTRIBUTES_OF{ $class } })
        . "\n"
 }
 # we store per-class elements.
 # call as __PACKAGE__->_factory
 sub _factory {
@@ -38,7 +64,7 @@ sub _factory {
        my $is_list = $type->isa('SOAP::WSDL::XSD::Typelib::Builtin::list');
        *{ "$class\::set_$name" } = sub  {
-            my ($self, $value) = @_;
+            # my ($self, $value) = @_;
 #  The structure below looks rather weird, but is optimized for performance.
 #
@@ -67,11 +93,11 @@ sub _factory {
 #  for GLOB references, feel free to add them.
 #  d) we should also die for non-blessed non-ARRAY/HASH references in lists but don't do yet - oh my ! 
-            my $is_ref = ref $value;
+            my $is_ref = ref $_[1];
-            $attribute_ref->{ ident $self } = ($is_ref) 
+            $attribute_ref->{ ident $_[0] } = ($is_ref) 
                ? $is_ref eq 'ARRAY' 
                    ? $is_list                             # remembered from outside closure 
-                        ? $type->new({ value => $value })  # list element - can take list ref as value
+                        ? $type->new({ value => $_[1] })   # list element - can take list ref as value
                        : [ map {                          
                            ref $_ 
                              ? ref $_ eq 'HASH'
@@ -80,20 +106,20 @@ sub _factory {
                                      ? $_
                                      : croak "cannot use " . ref($_) . " reference as value for $name - $type required"
                              : $type->new({ value => $_ })
-                            } @{ $value } 
+                            } @{ $_[1] } 
                         ]
                    : $is_ref eq 'HASH' 
-                        ?  $type->new( $value )
+                        ?  $type->new( $_[1] )
                        :  $is_ref eq $type
-                            ? $value
+                            ? $_[1]
                            : die croak "cannot use $is_ref reference as value for $name - $type required"
-                : $type->new({ value => $value });                     
+                : $type->new({ value => $_[1] });                     
        };
        *{ "$class\::add_$name" } = sub {
            my $ident = ident $_[0];
            warn "attempting to add empty value to " . ref $_[0] 
-                if (not defined $_[1]);
+                if not defined $_[1];
            # first call
            return $attribute_ref->{ $ident } = $_[1]
@@ -107,16 +133,30 @@ sub _factory {
            return push @{ $attribute_ref->{ $ident } }, $_[1];                                          
        };
        *{ "$class\::$name" } = *{ "$class\::add_$name" };
    }
-    *{ "$class\::START" } = sub {
+    *{ "$class\::new" } = sub {
-        my ($self, $ident, $args_of) = @_;
+        my $self = bless \my ($o), $_[0];
        $self->BUILD( ident $self, $_[1] ) if exists &BUILD;
        $self->_init( ident $self, $_[1] );
        $self->START( ident $self, $_[1] ) if exists &START;        
        return $self;
    };
    *{ "$class\::_init" } = sub {
        # We're working on @_ for speed.
        # Normally, the first line would look like this:
        # my ($self, $ident, $args_of) = @_;
        #
        # The hanging side comment show you what would be there, then.
        # iterate over keys of arguments 
        # and call set appropriate field in clase
        map { ($ATTRIBUTES_OF{ $class }->{ $_ }) 
            ? do {
                 my $method = "set_$_";
-                 $self->$method( $args_of->{ $_ } );
+                 $_[0]->$method( $_[2]->{ $_ } );               # ( $args_of->{ $_ } );
           }
           : $_ =~ m{ \A              # beginning of string
                      xmlns           # xmlns 
@@ -126,8 +166,8 @@ sub _factory {
                     croak "unknown field $_ in $class. Valid fields are:\n" 
                     . join(', ', @{ $ELEMENTS_FROM{ $class } }) . "\n"
                     . "Structure given:\n" . Dumper @_ };
-        } keys %$args_of;
+        } keys %{ $_[2] };                                      # %$args_of;
-        return $self;
+        return $_[0];                                           # $self;
    };
@@ -1,8 +1,6 @@
 #!/usr/bin/perl
 package SOAP::WSDL::XSD::Typelib::Element;
 use strict;
 use Class::Std::Storable;
 use Data::Dumper;
 my %NAME;
 my %NILLABLE;
@@ -1,11 +1,15 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More qw/no_plan/; # TODO: change to tests => N;
+use Test::More; # TODO: change to tests => N;
 use lib '../lib';
 chdir 't/' if (-d 't/');
 my @modules = qw(
    SOAP::WSDL
    SOAP::WSDL::Client
    SOAP::WSDL::Serializer::SOAP11
    SOAP::WSDL::Deserializer::SOAP11
    SOAP::WSDL::Transport::HTTP
    SOAP::WSDL::Definitions
    SOAP::WSDL::Message
    SOAP::WSDL::Operation
@@ -15,7 +19,6 @@ my @modules = qw(
    SOAP::WSDL::Port
    SOAP::WSDL::PortType
    SOAP::WSDL::Types
    SOAP::WSDL::SAX::WSDLHandler
    SOAP::WSDL::XSD::Builtin
    SOAP::WSDL::XSD::ComplexType
    SOAP::WSDL::XSD::SimpleType
@@ -23,6 +26,8 @@ my @modules = qw(
    SOAP::WSDL::XSD::Schema
 );
 plan tests => 2* scalar @modules;
 for my $module (@modules)
 {
    use_ok($module);
@@ -0,0 +1,335 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 17;
 use lib '../lib';
 eval {
    require Test::XML;
    import Test::XML;
 };
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $filter;
 my $parser = SOAP::WSDL::Expat::WSDLParser->new();
 $parser->parse_string( xml() );
 my $wsdl;
 ok( $wsdl = $parser->get_data() , "get object tree");
 my $types = $wsdl->first_types();
 is $types->get_parent(), $wsdl , 'types parent';
 my $serializer_options = {
    readable => 1,
    autotype => 1,
    namespace => { 'urn:myNamespace' => 'tns',
        "http://www.w3.org/2001/XMLSchema" => 'xsd' },
    typelib => $wsdl->first_types(),
    indent => "\t",
 };
 my $xml;
 my $type = $types->find_type( 'urn:myNamespace', 'testSimpleType1' );
 ok($xml = $type->serialize( 'test', 1 , $serializer_options ),
    "serialize simple Type"
 );
 # print $xml;
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, '<test type="tns:testSimpleType1">1</test>',
        "content compare" );
 };
 $type = $types->find_type( 'urn:myNamespace', 'testSimpleList' );
 ok($xml = $type->serialize( 'testList', [ 1, 2, 3 ] , $serializer_options ),
    "serialize simple list type"
 );
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, '<testList type="tns:testSimpleList">1 2 3</testList>',
        "content compare" );
 };
 $type = $types->find_element( 'urn:myNamespace', 'TestElement' );
 ok($xml = $type->serialize( undef, 1 , $serializer_options ),
    "serialize simple element");
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, '<TestElement type="xsd:int">1</TestElement>',
        "content compare" );
 };
 ok( $xml = $types->find_type( 'urn:myNamespace', 'length3')->serialize(
        'TestComplex', { size => -13, unit => 'BLA' } ,
        $serializer_options
    ),
    "serialize complex type");
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, q{
        <TestComplex type="tns:length3">
           <size type="xsd:non-positive-integer">-13</size>
           <unit type="xsd:NMTOKEN">BLA</unit>
        </TestComplex>},
        "content compare" );
 };
 ok($xml = $types->find_element( 'urn:myNamespace', 'TestElementComplexType')
    ->serialize(
        undef, { size => -13, unit => 'BLA' } , $serializer_options ),
        "serialize element with complex type"
 );
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, q{
        <TestElementComplexType type="tns:length3">
                <size type="xsd:non-positive-integer">-13</size>
                <unit type="xsd:NMTOKEN">BLA</unit>
        </TestElementComplexType>
    },
    "content compare" );
 };
 ok($xml = $types->find_type( 'urn:myNamespace', 'complex')->serialize(
        'complexComplex',
        { 'length' => {  size => -13, unit => 'BLA' }, 'int' => 1 },
        $serializer_options ),
        "serialize complex type with complex content"
 );
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, q{
        <complexComplex type="tns:complex">
                <length type="tns:length3">
                        <size type="xsd:non-positive-integer">-13</size>
                        <unit type="xsd:NMTOKEN">BLA</unit>
                </length>
                <int type="xsd:int">1</int>
        </complexComplex>
        },
        "content compare" );
 }
 ok($xml = $wsdl->find_message('urn:myNamespace', 'testRequest')
        ->get_part()->[0]->serialize(
        undef, 
        { test => { length => {  size => -13, unit => 'BLA' } , int => 3 } },
    $serializer_options ),
    "serialize part"
 );
 SKIP: {
    skip_without_test_xml();
    is_xml( $xml, q{
        <test type="tns:complex">
                <length type="tns:length3">
                        <size type="xsd:non-positive-integer">-13</size>
                        <unit type="xsd:NMTOKEN">BLA</unit>
                </length>
                <int type="xsd:int">3</int>
        </test>
    },
    "content compare")
 };
 my $opt = {
        typelib => $types,
        readable => 1,
        autotype => 0,
        namespace => { 'urn:myNamespace' => 'tns',
                'http://www.w3.org/2001/XMLSchema' => 'xsd',
                'http://schemas.xmlsoap.org/wsdl/' => 'wsdl',
        },
        indent => "",
        wsdl => $wsdl,
 };
 # ok $wsdl->explain($opt) =~ m/#optional/m;
 sub skip_without_test_xml {
    skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
 }
 sub xml
 {
        return q{<?xml version="1.0"?>
 <definitions name="simpleType"
        targetNamespace="urn:myNamespace"
        xmlns="http://schemas.xmlsoap.org/wsdl/"
        xmlns:tns="urn:myNamespace"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 >
        <types>
                <xsd:schema targetNamespace="urn:myNamespace">
                <xsd:complexType name="length3">
                         <xsd:all>
                                  <xsd:element name="size" type="xsd:non-positive-integer"/>
                                  <xsd:element name="unit" type="xsd:NMTOKEN"/>
                         </xsd:all>
                </xsd:complexType>
                <xsd:complexType name="complex">
                        <xsd:sequence>
                                  <xsd:element name="length" type="tns:length3"/>
                                  <xsd:element name="int" type="xsd:int"/>
                         </xsd:sequence>
                </xsd:complexType>
                <xsd:complexType name="mixed" mixed="true">
                        <xsd:sequence>
                                  <xsd:element name="length" type="tns:length3"/>
                                  <xsd:element name="int" type="xsd:int"/>
                         </xsd:sequence>
                </xsd:complexType>
                <xsd:element name="TestElement" type="xsd:int"/>
                <xsd:element name="TestElementComplexType" type="tns:length3"/>
                <xsd:simpleType name="testSimpleType1">
                        <xsd:restriction base="int">
                                <xsd:enumeration value="1"/>
                                <xsd:enumeration value="2"/>
                                <xsd:enumeration value="3"/>
                        </xsd:restriction>
                </xsd:simpleType>
                <xsd:simpleType name="testSimpleList">
                        <xsd:annotation>
                                <xsd:documentation>
                                SimpleType Test
                                </xsd:documentation>
                        </xsd:annotation>
                        <xsd:list itemType="int">
                        </xsd:list>
                </xsd:simpleType>
                <xsd:simpleType name="testSimpleUnion">
                        <xsd:annotation>
                                <xsd:documentation>
                                SimpleType Union test
                                </xsd:documentation>
                        </xsd:annotation>
                        <xsd:union memberTypes="int float">
                        </xsd:union>
                </xsd:simpleType>
                </xsd:schema>
        </types>
        <message name="testRequest">
                <part name="test" type="tns:complex"/>
        </message>
        <message name="testResponse">
                <part name="test" type="tns:testSimpleType1"/>
        </message>
        <message name="testRequest2">
                <part name="test" type="tns:testSimpleType1"/>
        </message>
        <message name="testResponse2">
                <part name="test" type="tns:testSimpleType1"/>
        </message>
        <portType name="testPort">
                <operation name="test">
                        <documentation>
                                Test-Methode
                        </documentation>
                        <input message="tns:testRequest"/>
                        <output message="tns:testResponse"/>
                </operation>
                <operation name="test2">
                        <documentation>
                                Test-Methode
                        </documentation>
                        <input message="tns:testRequest2"/>
                        <output message="tns:testResponse2"/>
                </operation>
        </portType>
        <portType name="testPort2">
                <operation name="test">
                        <documentation>
                                Test-Methode
                        </documentation>
                        <input message="tns:testRequest"/>
                        <output message="tns:testResponse"/>
                </operation>
        </portType>
        <portType name="testPort3">
                <operation name="test">
                        <documentation>
                                Test-Methode
                        </documentation>
                        <input message="tns:testRequest"/>
                        <output message="tns:testResponse"/>
                </operation>
        </portType>
        <binding type="tns:testPort" name="testBinding">
        <operation name="test">
                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
                <soap:operation soapAction="test">
                        <input>
                                <soap:body use="literal"/>
                        </input>
                        <output>
                                <soap:body use="literal"/>
                        </output>
                </soap:operation>
        </operation>
        </binding>
        <binding type="tns:testPort2" name="testBinding2">
                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
        <operation name="test">
                <soap:operation soapAction="test">
                        <input>
                                <soap:body use="literal"/>
                        </input>
                        <output>
                                <soap:body use="literal"/>
                        </output>
                </soap:operation>
        </operation>
        </binding>
        <binding type="tns:testPort3" name="testBinding3">
                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
        <operation name="test">
                <soap:operation soapAction="test">
                        <input>
                                <soap:body use="literal"/>
                        </input>
                        <output>
                                <soap:body use="literal"/>
                        </output>
                </soap:operation>
        </operation>
        </binding>
        <service name="testService">
                <port name="testPort" binding="tns:testBinding">
                        <soap:address location="http://127.0.0.1/testPort" />
                </port>
                <port name="testPort2" binding="tns:testBinding2">
                        <soap:address location="http://127.0.0.1/testPort2" />
                </port>
        </service>
        <service name="testService2">
                <port name="testPort3" binding="tns:testBinding3">
                        <soap:address location="http://127.0.0.1/testPort3" />
                </port>
        </service>
 </definitions>
 };
 }
@@ -1,9 +1,15 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 18; # qw/no_plan/; # TODO: change to tests => N;
+use Test::More;
 use lib '../lib';
-use XML::SAX::ParserFactory;
+
 if (eval "require XML::LibXML") {
     plan tests => 18;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 eval {
    require Test::XML;
@@ -15,12 +21,10 @@ use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
 my $filter;
 ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(
    { base => 'XML::SAX::Base' }
 ), "Object creation");
-my $parser = XML::SAX::ParserFactory->parser(
+my $parser = XML::LibXML->new();
-        Handler => $filter
+$parser->set_handler( $filter );
 );
 $parser->parse_string( xml() );
@@ -1,7 +1,13 @@
-use Test::More tests => 11;
+use Test::More;
 use Data::Dumper;
 use lib '../lib';
-use XML::LibXML;
+
 if (eval "require XML::LibXML") {
     plan tests => 11;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
@@ -0,0 +1,252 @@
 use Test::More tests => 11;
 use lib '../lib';
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $filter;
 my $parser;
 ok($parser = SOAP::WSDL::Expat::WSDLParser->new() );
 eval { $parser->parse_string( xml() ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL";
 }
 else
 {
 	pass("parsing XML");
 }
 my $wsdl;
 ok( $wsdl = $parser->get_data() , "get object tree");
 my $schema = $wsdl->first_types();
 my $opt = {
 	readable => 0,
 	autotype => 1,
    namespace => $wsdl->get_xmlns(),
 	indent => "\t",
 	typelib => $schema,
 };
 is( $schema->find_type( 'myNamespace', 'testSimpleType1' )->serialize(
 	'test', 1 , $opt ),
 	q{<test type="tns:testSimpleType1">1</test>} , "serialize simple type");
 is( $schema->find_type( 'myNamespace', 'testSimpleList' )->serialize(
 	'testList', [ 1, 2, 3 ] , $opt),
 	q{<testList type="tns:testSimpleList">1 2 3</testList>},
 	"serialize simple list type"
 );
 is( $schema->find_element( 'myNamespace', 'TestElement' )->serialize(
 	undef, 1 , $opt),
 	q{<TestElement type="xsd:int">1</TestElement>}, "Serialize element"
 );
 $opt->{ readable } = 0;
 is( $schema->find_type( 'myNamespace', 'length3')->serialize(
 	'TestComplex', { size => -13, unit => 'BLA' } ,
 	$opt ),
 	q{<TestComplex type="tns:length3" >}
 	. q{<size type="xsd:non-positive-integer">-13</size>}
 	. q{<unit type="xsd:NMTOKEN">BLA</unit></TestComplex>}
 	, "serialize complex type" );
 is( $schema->find_element( 'myNamespace', 'TestElementComplexType')->serialize(
 	undef, { size => -13, unit => 'BLA' } ,
 	$opt ),
 	q{<TestElementComplexType type="tns:length3" >}
 	. q{<size type="xsd:non-positive-integer">-13</size>}
 	. q{<unit type="xsd:NMTOKEN">BLA</unit></TestElementComplexType>},
 	"element with complex type"
 );
 is( $schema->find_type( 'myNamespace', 'complex')->serialize(
 	'complexComplex',
 	{ 'length' => {  size => -13, unit => 'BLA' }, 'int' => 1 },
 	$opt ),
 	q{<complexComplex type="tns:complex" >}
 	. q{<length type="tns:length3" >}
 	. q{<size type="xsd:non-positive-integer">-13</size>}
 	. q{<unit type="xsd:NMTOKEN">BLA</unit></length>}
 	. q{<int type="xsd:int">1</int></complexComplex>},
 	"nested complex type"
 );
 is( $wsdl->find_message('myNamespace', 'testRequest')->first_part()->serialize(
 	undef, { test => { length => {  size => -13, unit => 'BLA' } , int => 3 } },
 	$opt ),
 	q{<test type="tns:complex" >}
 	. q{<length type="tns:length3" >}
 	. q{<size type="xsd:non-positive-integer">-13</size>}
 	. q{<unit type="xsd:NMTOKEN">BLA</unit>}
 	. q{</length><int type="xsd:int">3</int></test>}
 	, "Message part"
 );
 exit;
 sub xml
 {
 	return q{<?xml version="1.0"?>
 <definitions name="simpleType"
 	targetNamespace="myNamespace"
 	xmlns="http://schemas.xmlsoap.org/wsdl/"
 	xmlns:tns="myNamespace"
 	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 >
 	<types>
 		<xsd:schema targetNamespace="myNamespace">
 		<xsd:complexType name="length3">
 			<xsd:sequence>
  				<xsd:element name="size" type="xsd:non-positive-integer"/>
  				<xsd:element name="unit" type="xsd:NMTOKEN"/>
 			</xsd:sequence>
 		</xsd:complexType>
 		<xsd:complexType name="complex">
 			<xsd:sequence>
  				<xsd:element name="length" type="tns:length3"/>
  				<xsd:element name="int" type="xsd:int"/>
 			</xsd:sequence>
 		</xsd:complexType>
 		<xsd:element name="TestElement" type="xsd:int"/>
 		<xsd:element name="TestElementComplexType" type="tns:length3"/>
 		<xsd:simpleType name="testSimpleType1">
 			<xsd:restriction base="int">
 				<xsd:enumeration value="1"/>
 				<xsd:enumeration value="2"/>
 				<xsd:enumeration value="3"/>
 			</xsd:restriction>
 		</xsd:simpleType>
 		<xsd:simpleType name="testSimpleList">
 			<xsd:annotation>
 				<xsd:documentation>
 				SimpleType Test
 				</xsd:documentation>
 			</xsd:annotation>
 			<xsd:list itemType="int">
 			</xsd:list>
 		</xsd:simpleType>
 		<xsd:simpleType name="testSimpleUnion">
 			<xsd:annotation>
 				<xsd:documentation>
 				SimpleType Union test
 				</xsd:documentation>
 			</xsd:annotation>
 			<xsd:union memberTypes="int float">
 			</xsd:union>
 		</xsd:simpleType>
 		</xsd:schema>
 	</types>
 	<message name="testRequest">
 		<part name="test" type="tns:complex"/>
 	</message>
 	<message name="testResponse">
 		<part name="test" type="tns:testSimpleType1"/>
 	</message>
 	<message name="testRequest2">
 		<part name="test" type="tns:testSimpleType1"/>
 	</message>
 	<message name="testResponse2">
 		<part name="test" type="tns:testSimpleType1"/>
 	</message>
 	<portType name="testPort">
 		<operation name="test">
 			<documentation>
 				Test-Methode
 			</documentation>
 			<input message="testRequest"/>
 			<output message="testResponse"/>
 		</operation>
 		<operation name="test2">
 			<documentation>
 				Test-Methode
 			</documentation>
 			<input message="testRequest2"/>
 			<output message="testResponse2"/>
 		</operation>
 	</portType>
 	<portType name="testPort2">
 		<operation name="test">
 			<documentation>
 				Test-Methode
 			</documentation>
 			<input message="testRequest"/>
 			<output message="testResponse"/>
 		</operation>
 	</portType>
 	<portType name="testPort3">
 		<operation name="test">
 			<documentation>
 				Test-Methode
 			</documentation>
 			<input message="testRequest"/>
 			<output message="testResponse"/>
 		</operation>
 	</portType>
 	<binding type="testPort" name="testBinding">
 		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
 		<soap:operation soapAction="test">
 			<input>
 				<soap:body use="literal"/>
 			</input>
 			<output>
 				<soap:body use="literal"/>
 			</output>
 		</soap:operation>
 	</binding>
 	<binding type="testPort2" name="testBinding2">
 		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
 		<soap:operation soapAction="test">
 			<input>
 				<soap:body use="literal"/>
 			</input>
 			<output>
 				<soap:body use="literal"/>
 			</output>
 		</soap:operation>
 	</binding>
 	<binding type="testPort3" name="testBinding3">
 		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
 		<soap:operation soapAction="test">
 			<input>
 				<soap:body use="literal"/>
 			</input>
 			<output>
 				<soap:body use="literal"/>
 			</output>
 		</soap:operation>
 	</binding>
 	<service name="testService">
 		<port name="testPort" binding="testBinding">
 			<soap:address location="http://127.0.0.1/testPort" />
 		</port>
 		<port name="testPort2" binding="testBinding2">
 			<soap:address location="http://127.0.0.1/testPort2" />
 		</port>
 		<port name="testPort3" binding="testBinding3">
 			<soap:address location="http://127.0.0.1/testPort3" />
 		</port>
 	</service>
 </definitions>
 };
 }
@@ -0,0 +1,398 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 5;
 use lib '../lib';
 eval {
    require Test::XML;
    import Test::XML;
 };
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $parser;
 ok($parser = SOAP::WSDL::Expat::WSDLParser->new(), "Object creation");
 eval { $parser->parse_string( xml() ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL: $@";
 }
 else
 {
 	pass("parsing XML");
 }
 my $wsdl;
 ok( $wsdl = $parser->get_data() , "get object tree");
 my $schema = $wsdl->get_types()->[0]->get_schema()->[0] || die "No schema !";
 my $opt = {
 	typelib => $wsdl->first_types,
 	readable => 1,
 	autotype => 0,
 	namespace => { 'http://www.example.org/MessageGateway2/' => 'tns',
 		'http://www.w3.org/2001/XMLSchema' => 'xsd',
 		'http://schemas.xmlsoap.org/wsdl/' => 'wsdl',
 	},
 	indent => "",
 };
 my $data = { EnqueueMessage => {
 	MMessage => {
 		MRecipientURI => 'anyURI',
 		MSenderAddress => 'a string',
 		MMessageContent => 'a string',
 		MSubject => 'a string',
 		MDeliveryReportRecipientURI => 'anyURI',
 		MKeepalive => {
 			MKeepaliveTimeout => 1234567,
 			MKeepaliveErrorPolicy => ' ( suppress | report ) ',
 		}
 	}
 }
 };
 SKIP: { skip_without_test_xml();
    is_xml( $wsdl->find_message(
        "http://www.example.org/MessageGateway2/" ,'EnqueueMessageRequest'
        )->first_part()->serialize( 'test', $data, $opt ),
        xml_message()
        , "Serialized message part"
    );
 }
 sub skip_without_test_xml {
    skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
 }
 sub xml_message {
 	return
 q{<EnqueueMessage xmlns="http://www.example.org/MessageGateway2/">
 	<MMessage>
 		<MRecipientURI>anyURI</MRecipientURI>
 		<MSenderAddress>a string</MSenderAddress>
 		<MMessageContent>a string</MMessageContent>
 		<MSubject>a string</MSubject>
 		<MDeliveryReportRecipientURI>anyURI</MDeliveryReportRecipientURI>
 		<MKeepalive>
 			<MKeepaliveTimeout>1234567</MKeepaliveTimeout>
 			<MKeepaliveErrorPolicy> ( suppress | report ) </MKeepaliveErrorPolicy>
 		</MKeepalive>
 	</MMessage>
 </EnqueueMessage>
 };
 }
 sub xml {
 	return q{<?xml version="1.0" encoding="UTF-8"?>
 <wsdl:definitions name="MessageGateway"
  targetNamespace="http://www.example.org/MessageGateway2/"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:tns="http://www.example.org/MessageGateway2/"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
  <wsdl:types>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://www.example.org/MessageGateway2/">
      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage"
        xmlns:tns="http://www.example.org/MessageGateway2/">
        <xsd:annotation>
          <xsd:documentation>Enqueue message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TMessage">
        <xsd:annotation>
          <xsd:documentation>
            A type containing all elements of a message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
                phone:. Not all URI schemas need to be implemented at the current
                implementation stage.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                E-Mail sender address. Ignored for all but mailto: recipient URIs.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>Message Content.</xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Message Subject. Ignored for all but mailto: URIs
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                URI to send a delivery report to. May be of one of the following schemes:
                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
                reports to http(s) URIs are sent as SOAP requests following the
                MessageGatewayClient service definition.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Container for keepalive information. May be missing.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepalive">
        <xsd:annotation>
          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
            <xsd:annotation>
              <xsd:documentation>
                Keepalive timeout. The keepalive timeout spezifies how long the sending of
                a message will be delayed waiting for keepalive updates. If a keepalive
                update is received during this period, the timeout will be reset. If not,
                the message will be sent after the timeout has expired.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Policy to comply to in case of system errors. Valid values are "suppress"
                and "report". If the policy is set to "suppress", keepalive messages will
                not be sent to their recipients in case of partial system failure, even if
                the keepalive has expired. This may result in "false negatives", i.e.
                messages may not be sent, even though their keepalive has expired. If the
                value is "report", keepalive messages will be sent from any cluster node.
                This may result in "false positive" alerts.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="suppress"></xsd:enumeration>
                <xsd:enumeration value="report"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TMessageID">
        <xsd:annotation>
          <xsd:documentation>Type containing a message ID.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepliveMessage">
        <xsd:annotation>
          <xsd:documentation>
            Type containing all elements of a keppalive update / remove request.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The ID for the message to update / remove
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The action to perform. Valid values are: "remove", "update". On "remove",
                the message with the ID specified will be removed from the queue, thus it
                will never be sent, even if it's timeout expires. On "update" the
                keepalive timeout of the corresponding message will be reset.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="remove"></xsd:enumeration>
                <xsd:enumeration value="update"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>Keepalive message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Enqueue message response element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TEnqueueMessage">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessage" type="tns:TMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a message to enqueue.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The keepalive message to process.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a keepalive message to process.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="EnqueueMessageRequest">
    <wsdl:part name="parameters" element="tns:EnqueueMessage">
      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="EnqueueMessageResponse">
    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageRequest">
    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageResponse">
    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:portType name="MGWPortType">
    <wsdl:documentation>
      generic port type for all methods required for sending messages over the mosaic
      message gatewa
    </wsdl:documentation>
    <wsdl:operation name="EnqueueMessage">
      <wsdl:documentation>
        This method is used to enqueue a normal (immediate send) or a delayed message with
        keepalive functionality.
      </wsdl:documentation>
      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <wsdl:documentation>
        This method is used to update or remove a
        keepalive message.
      </wsdl:documentation>
      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="EnqueueMessage">
      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <soap:operation
        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="MessageGateway">
    <wsdl:documentation>
      Web Service for sending messages over the mosaic message gatewa
    </wsdl:documentation>
    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
      <wsdl:documentation>HTTP(S) port for the mosaic message gatewa</wsdl:documentation>
      <soap:address location="https://www.example.org/MessageGateway/" />
    </wsdl:port>
  </wsdl:service>
 </wsdl:definitions>};
 }
@@ -1,11 +1,15 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 5;
+use Test::More;
 use lib '../lib';
 use XML::SAX::ParserFactory;
-use diagnostics;
+if (eval "require XML::LibXML") {
     plan tests => 5;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 eval {
    require Test::XML;
@@ -18,7 +22,6 @@ my $filter;
 ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
 use XML::LibXML;
 my $parser = XML::LibXML->new();
 $parser->set_handler( $filter );
@@ -0,0 +1,247 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More qw/no_plan/; # TODO: change to tests => N;
 use lib '../lib';
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $parser;
 ok($parser = SOAP::WSDL::Expat::WSDLParser->new(), "Object creation");
 eval { $parser->parse_string( xml() ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL: $@";
 }
 else
 {
 	pass("parsing XML");
 }
 my $wsdl;
 ok( $wsdl = $parser->get_data() , "get object tree");
 my $opt = {
 	namespace => $wsdl->get_xmlns(),
 	style => 'perl',
 	wsdl => $wsdl,
 	readable => 1,
 };
 my $txt;
 ok( $txt = $wsdl->explain( $opt ) , "explain WSDL" );
 # print $txt;
 sub xml {
 	return q{<?xml version="1.0" encoding="UTF-8"?>
 <wsdl:definitions targetNamespace="http://example.com/soap/services/ETest/impl"
  xmlns="http://schemas.xmlsoap.org/wsdl/"
  xmlns:apachesoap="http://xml.apache.org/xml-soap"
  xmlns:impl="http://example.com/soap/services/ETest/impl"
  xmlns:intf="http://example.com/soap/services/ETest"
  xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
  xmlns:tns1="urn:ETest"
  xmlns:tns2="urn:acquisition"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <wsdl:types>
    <schema targetNamespace="urn:ETest" xmlns="http://www.w3.org/2001/XMLSchema">
      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
      <complexType name="CreationBaseData">
        <sequence>
          <element name="createdBy" nillable="true" type="xsd:long" />
          <element name="creationDate" nillable="true" type="xsd:dateTime" />
          <element name="updateDateCenter" nillable="true" type="xsd:dateTime" />
          <element name="updateDateLocal" nillable="true" type="xsd:dateTime" />
          <element name="updatedBy" nillable="true" type="xsd:long" />
        </sequence>
      </complexType>
      <complexType name="CreationData">
        <complexContent>
          <extension base="tns1:CreationBaseData">
            <sequence>
              <element name="creatorFullName" nillable="true" type="xsd:string" />
              <element name="modifierFullName" nillable="true" type="xsd:string" />
            </sequence>
          </extension>
        </complexContent>
      </complexType>
      <complexType abstract="true" name="EProductData">
        <sequence>
          <element name="EStatus" nillable="true" type="xsd:string" />
          <element name="EStatusUpdatedate" nillable="true" type="xsd:dateTime" />
          <element name="SFXID" nillable="true" type="xsd:string" />
          <element name="activationFromDate" nillable="true" type="xsd:dateTime" />
          <element name="activationToDate" nillable="true" type="xsd:dateTime" />
          <element name="activityStatusDateFrom" nillable="true" type="xsd:dateTime" />
          <element name="activityStatusDateTo" nillable="true" type="xsd:dateTime" />
          <element name="canEditSFXID" type="xsd:boolean" />
          <element name="concurrentNumberOfUsers" nillable="true" type="xsd:int" />
          <element name="creationData" nillable="true" type="tns1:CreationData" />
          <element name="deleteable" type="xsd:boolean" />
          <element name="ETestCode" nillable="true" type="xsd:string" />
          <element name="id" nillable="true" type="xsd:long" />
          <element name="instanceCode" nillable="true" type="xsd:string" />
          <element name="mainContact" nillable="true" type="xsd:string" />
          <element name="metaLibID" nillable="true" type="xsd:string" />
          <element name="otherID" nillable="true" type="xsd:string" />
          <element name="otherSource" nillable="true" type="xsd:string" />
          <element name="privateNote" nillable="true" type="xsd:string" />
          <element name="procurementStatus" nillable="true" type="xsd:string" />
          <element name="procurementStatusUpdateDate" nillable="true" type="xsd:dateTime" />
          <element name="procurementStatusUpdatedate" nillable="true" type="xsd:dateTime" />
          <element name="sourceInstanceCode" nillable="true" type="xsd:string" />
          <element name="sponseringLibraryCode" nillable="true" type="xsd:string" />
          <element name="sponseringLibraryName" nillable="true" type="xsd:string" />
          <element name="updateTarget" nillable="true" type="xsd:string" />
          <element name="workExpressionCode" nillable="true" type="xsd:string" />
        </sequence>
      </complexType>
      <complexType name="EProductInformation">
        <sequence>
          <element name="acquisitions" nillable="true"
            type="impl:ArrayOf_tns2_AcquisitionData" />
          <element name="data" nillable="true" type="tns1:EProductData" />
        </sequence>
      </complexType>
    </schema>
    <schema targetNamespace="urn:acquisition" xmlns="http://www.w3.org/2001/XMLSchema">
      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
      <complexType name="AcquisitionCommonData">
        <sequence>
          <element name="budgets" nillable="true" type="xsd:string" />
          <element name="campusCode" nillable="true" type="xsd:string" />
          <element name="concurrentUsersNote" nillable="true" type="xsd:string" />
          <element name="creationData" nillable="true" type="tns1:CreationData" />
          <element name="id" nillable="true" type="xsd:long" />
          <element name="instituteCode" nillable="true" type="xsd:string" />
        </sequence>
      </complexType>
      <complexType name="AcquisitionData">
        <sequence>
          <element name="ILSSubscriptionNo" nillable="true" type="xsd:string" />
          <element name="acquisitionCode" nillable="true" type="xsd:string" />
          <element name="acquisitionCommonData" nillable="true"
            type="tns2:AcquisitionCommonData" />
          <element name="acquisitionMethod" nillable="true" type="xsd:string" />
          <element name="acquisitionNumber" nillable="true" type="xsd:string" />
          <element name="acquisitionStatus" nillable="true" type="xsd:string" />
          <element name="acquisitionStatusDate" nillable="true" type="xsd:dateTime" />
          <element name="advanceNoticeDate" nillable="true" type="xsd:dateTime" />
          <element name="autoRenewal" nillable="true" type="xsd:boolean" />
          <element name="consortialAgreement" type="xsd:boolean" />
          <element name="discountOnPrice" nillable="true" type="xsd:int" />
          <element name="id" nillable="true" type="xsd:long" />
          <element name="instanceCode" nillable="true" type="xsd:string" />
          <element name="materialType" nillable="true" type="xsd:string" />
          <element name="noteForILS" nillable="true" type="xsd:string" />
          <element name="noteForVendor" nillable="true" type="xsd:string" />
          <element name="noticePeriodCode" nillable="true" type="xsd:string" />
          <element name="numberOfCopies" nillable="true" type="xsd:int" />
          <element name="orderDate" nillable="true" type="xsd:dateTime" />
          <element name="orderForm" nillable="true" type="xsd:string" />
          <element name="orderSendMethod" nillable="true" type="xsd:string" />
          <element name="pooledConcurrentUsers" nillable="true" type="xsd:int" />
          <element name="price" nillable="true" type="xsd:double" />
          <element name="pricingCap" nillable="true" type="xsd:int" />
          <element name="pricingCapFrom" nillable="true" type="xsd:dateTime" />
          <element name="pricingCapTo" nillable="true" type="xsd:dateTime" />
          <element name="pricingModel" nillable="true" type="xsd:string" />
          <element name="printCancellationNote" nillable="true" type="xsd:string" />
          <element name="printCancellationRestriction" type="xsd:boolean" />
          <element name="printPurchaseOrderNo" nillable="true" type="xsd:string" />
          <element name="purchaseOrderNo" nillable="true" type="xsd:string" />
          <element name="renewallOrCancellationDate" nillable="true" type="xsd:dateTime" />
          <element name="renewallOrCancellationDescisionNote" nillable="true"
            type="xsd:string" />
          <element name="renewallOrCancellationNoteForILS" nillable="true"
            type="xsd:string" />
          <element name="renewallOrCancellationNoteForVendor" nillable="true"
            type="xsd:string" />
          <element name="subscriptionNotification" nillable="true" type="xsd:int" />
          <element name="subscriptionPeriodCode" nillable="true" type="xsd:string" />
          <element name="subscriptionType" nillable="true" type="xsd:string" />
          <element name="subscriptionTypeNote" nillable="true" type="xsd:string" />
          <element name="vendorAdvancedNotice" nillable="true" type="xsd:int" />
          <element name="vendorAdvancedNoticeVal" nillable="true" type="xsd:string" />
          <element name="vendorCode" nillable="true" type="xsd:string" />
          <element name="vendorName" nillable="true" type="xsd:string" />
          <element name="vendorSubscriptionCode" nillable="true" type="xsd:string" />
        </sequence>
      </complexType>
    </schema>
    <schema targetNamespace="http://example.com/soap/services/ETest/impl"
      xmlns="http://www.w3.org/2001/XMLSchema">
      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
      <complexType name="ArrayOf_tns2_AcquisitionData">
        <complexContent>
          <restriction base="soapenc:Array">
            <attribute ref="soapenc:arrayType" wsdl:arrayType="tns2:AcquisitionData[]" />
          </restriction>
        </complexContent>
      </complexType>
    </schema>
  </wsdl:types>
  <wsdl:message name="getETestResponse">
    <wsdl:part name="getETestReturn" type="tns1:EProductInformation" />
  </wsdl:message>
  <wsdl:message name="getFixedETestResponse">
    <wsdl:part name="getFixedETestReturn" type="tns1:EProductInformation" />
  </wsdl:message>
  <wsdl:message name="getFixedETestRequest"></wsdl:message>
  <wsdl:message name="getETestRequest">
    <wsdl:part name="indexName" type="xsd:string" />
    <wsdl:part name="indexValue" type="xsd:string" />
    <wsdl:part name="withStatus" type="xsd:string" />
  </wsdl:message>
  <wsdl:portType name="ETestWeb">
    <wsdl:operation name="getETest" parameterOrder="indexName indexValue withStatus">
      <wsdl:input message="impl:getETestRequest" name="getETestRequest" />
      <wsdl:output message="impl:getETestResponse" name="getETestResponse" />
    </wsdl:operation>
    <wsdl:operation name="getFixedETest">
      <wsdl:input message="impl:getFixedETestRequest" name="getFixedETestRequest" />
      <wsdl:output message="impl:getFixedETestResponse"
        name="getFixedETestResponse" />
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="ETestSoapBinding" type="impl:ETestWeb">
    <wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="getETest">
      <wsdlsoap:operation soapAction="" />
      <wsdl:input name="getETestRequest">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
          namespace="http://example.com/soap/services/ETest" use="encoded" />
      </wsdl:input>
      <wsdl:output name="getETestResponse">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
          namespace="http://example.com/soap/services/ETest" use="encoded" />
      </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="getFixedETest">
      <wsdlsoap:operation soapAction="" />
      <wsdl:input name="getFixedETestRequest">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
          namespace="http://example.com/soap/services/ETest" use="encoded" />
      </wsdl:input>
      <wsdl:output name="getFixedETestResponse">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
          namespace="http://example.com/soap/services/ETest" use="encoded" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="ETestWebService">
    <wsdl:port binding="impl:ETestSoapBinding" name="ETest">
      <wsdlsoap:address location="http://example.com/soap/services/ETest" />
    </wsdl:port>
  </wsdl:service>
 </wsdl:definitions>
 };
 }
@@ -1,12 +1,15 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More qw/no_plan/; # TODO: change to tests => N;
+use Test::More; # TODO: change to tests => N;
 use Data::Dumper;
 use lib '../lib';
 use XML::LibXML;
-use diagnostics;
+if (eval "require XML::LibXML") {
     plan tests => 5;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
@@ -1,18 +1,14 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Pod::Simple::Text;
 use Test::More qw/no_plan/; # TODO: change to tests => N;
 use lib '../lib';
 use XML::SAX::ParserFactory;
 eval {
    require Test::XML;
    import Test::XML
 };
 use diagnostics;
 use Cwd;
 my $path = cwd;
@@ -31,11 +27,17 @@ ok( $soap->no_dispatch( 1 ) , "Set no_dispatch" );
 ok( $soap->explain() );
-my $pod = Pod::Simple::Text->new();
+SKIP: {
 my $output;
 $pod->output_string( \$output );
 $pod->parse_string_document( $soap->explain() );
    if (not eval "require Pod::Simple::Text") {
        skip "cannot test parsing pod without Pod::Test::Simple", 1;
    };
    my $pod = Pod::Simple::Text->new();
    my $output;
    $pod->output_string( \$output );
    ok $pod->parse_string_document( $soap->explain() ), 'parse explain pod';
 }
 # print $output;
 SKIP: {
@@ -60,6 +62,3 @@ sub skip_without_test_xml {
    my $number = shift || 1;
    skip("Test::XML not available", $number) if (not $Test::XML::VERSION);
 }
 __END__
@@ -10,7 +10,7 @@ eval {
    import Test::XML;
 };
-use_ok qw/SOAP::WSDL::Envelope/;
+use_ok qw/SOAP::WSDL::Serializer::SOAP11/;
 my $opt = {
    readable => 1,
@@ -18,7 +18,7 @@ my $opt = {
    },
 };
 my $xml;
-ok( $xml = SOAP::WSDL::Envelope->serialize(
+ok( $xml = SOAP::WSDL::Serializer::SOAP11->serialize(
    undef, undef, $opt
    ),
    "serialize empty envelope"
@@ -1,13 +1,14 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 5;
 use lib 't/lib';
 use lib '../lib';
 use lib 'lib';
-use XML::Simple;
+
 use SOAP::WSDL::SAX::WSDLHandler;
 use Cwd;
-use XML::LibXML::SAX;
+
 use_ok(qw/SOAP::WSDL::SAX::MessageHandler/);
 use SOAP::WSDL;
@@ -15,22 +16,18 @@ use SOAP::WSDL::XSD::Typelib::Builtin;
 my $path = cwd;
 $path =~s|\/t\/?$||;      # allow running from t/ and above (Build test)
 $XML::Simple::PREFERRED_PARSER = 'XML::Parser';
-my $filter;
+my $parser; 
-ok($filter = SOAP::WSDL::SAX::MessageHandler->new( {
+
 ok $parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => FakeResolver->new(),
-} ), "Object creation");
+}), "Object creation";
-my $parser = XML::LibXML->new();
+# TODO factor out into bool test
 $parser->set_handler( $filter );
-$parser->parse_string( xml() );
+$parser->parse( xml() );
-# print $filter->get_data();
+if($parser->get_data()->get_MMessage()->get_MDeliveryReportRecipientURI()) {
 # print $filter->get_data()->get_MMessage()->_DUMP();
 if($filter->get_data()->get_MMessage()->get_MDeliveryReportRecipientURI()) {
    pass "bool context overloading";
 }
 else
@@ -38,6 +35,8 @@ else
    fail "bool context overloading"
 }
 # TODO factor out into different test
 my $soap = SOAP::WSDL->new(
    readable => 1,
    wsdl => 'file:///' . $path .'/t/acceptance/wsdl/006_sax_client.wsdl',
@@ -86,6 +85,4 @@ BEGIN {
                : warn "no class found for $name";
        };
    };
 };
@@ -40,8 +40,6 @@ is $obj, '<MyAtomicComplexTypeElement xmlns="urn:Test" ><test >Test</test>'
    . '</MyAtomicComplexTypeElement>'
    , 'multi value stringification';
 use diagnostics;
 ok $obj = MyComplexTypeElement->new({ MyTestName => 'test' });
 is $obj, '<MyComplexTypeElement xmlns="urn:Test" ><MyTestName >test</MyTestName ></MyComplexTypeElement>';
@@ -1,11 +1,15 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 16;
+use Test::More;
 use lib '../lib';
 use XML::SAX::ParserFactory;
-use diagnostics;
+if (eval "require XML::LibXML") {
     plan tests => 16;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 eval {
    require Test::XML;
@@ -18,7 +22,6 @@ my $filter;
 ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
 use XML::LibXML;
 my $parser = XML::LibXML->new();
 $parser->set_handler( $filter );
@@ -3,25 +3,16 @@ use strict;
 use warnings;
 use Test::More tests => 5;
 use lib '../lib';
 use XML::SAX::ParserFactory;
 use diagnostics;
 eval {
    require Test::XML;
    import Test::XML;
 };
-use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
-my $filter;
+my $parser;
 ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
 use XML::LibXML;
 my $parser = XML::LibXML->new();
 $parser->set_handler( $filter );
 ok($parser = SOAP::WSDL::Expat::WSDLParser->new(), "Object creation");
 eval { $parser->parse_string( xml() ) };
 if ($@)
 {
@@ -34,7 +25,7 @@ else
 }
 my $wsdl;
-ok( $wsdl = $filter->get_data() , "get object tree");
+ok( $wsdl = $parser->get_data() , "get object tree");
 ok $wsdl->to_typemap( { prefix => 'CP::EAI::Typelib::' } ), 'typemap';
 exit;
@@ -1,11 +1,11 @@
 #!/usr/bin/perl
 use Test::More tests => 9;
 use strict;
 use diagnostics;
 use lib 'lib/';
 use lib '../lib/';
 use lib 't/lib';
 use_ok qw(SOAP::WSDL::SOAP::Typelib::Fault11);
 use_ok qw(SOAP::WSDL::XSD::Typelib::Element);
 use_ok qw( MyElement );
 use_ok qw( SOAP::WSDL::Client );
@@ -30,14 +30,16 @@ my $soap = SOAP::WSDL::Client->new( {
    ->proxy('http://bla')
        ->no_dispatch(1);
-is $soap->call('Test', $obj), q{<SOAP-ENV:Envelope }
+# TODO: use Test::XML for testing and re-integrate
-    . q{xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" }
+
-    . q{xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >}
+#  is $soap->call('Test', $obj), q{<SOAP-ENV:Envelope }
-    . q{<SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >}
+    #  . q{xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" }
-    . q{<test >Test</test>}
+    #  . q{xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >}
-    . q{<test2 >Test2</test2>}
+    #  . q{<SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >}
-    . q{</MyAtomicComplexTypeElement></SOAP-ENV:Body></SOAP-ENV:Envelope>}
+    #  . q{<test >Test</test>}
-    , 'SOAP Envelope generation with objects';
+    #  . q{<test2 >Test2</test2>}
    #  . q{</MyAtomicComplexTypeElement></SOAP-ENV:Body></SOAP-ENV:Envelope>}
    #  , 'SOAP Envelope generation with objects';
 my $result = $soap->proxy('http://bla')
    ->no_dispatch(0)
@@ -0,0 +1,412 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 19;
 use lib '../lib';
 use SOAP::WSDL::Expat::WSDLParser;
 use SOAP::WSDL::Expat::MessageParser;
 use File::Path;
 use File::Basename;
 my $path = dirname __FILE__;
 my $wsdl;
 ok( $wsdl = SOAP::WSDL::Expat::WSDLParser->new()
    ->parse_string( xml() ) , "get object tree");
 $wsdl->create({
  base_path => "$path/testlib",
  typemap_prefix => "Test::Typemap::",
  type_prefix => "Test::Type::",
  element_prefix => "Test::Element::",
  interface_prefix => "Test::Interface::",
 });
 eval "use lib '$path/testlib'";
 use_ok qw(Test::Element::EnqueueMessage);
 use_ok qw(Test::Type::TMessage);
 use_ok qw(Test::Typemap::MessageGateway);
 my $data = {
    MMessage => {
        MRecipientURI => 'anyURI',
        MSenderAddress => 'a string',
        MMessageContent => 'a string',
        MSubject => 'a string',
        MDeliveryReportRecipientURI => 'anyURI',
        MKeepalive => {
            MKeepaliveTimeout => 1234567,
            MKeepaliveErrorPolicy => ' ( suppress | report ) ',
        }
    }
 };
 ok Test::Element::EnqueueMessage->new( $data ) , '(generated) object constructor';
 my $message_parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'Test::Typemap::MessageGateway'
 });
 eval { $message_parser->parse_string( xml_message2() ) };
 ok ( !$@, 'parse XML message');
 TODO: {
  local $TODO = 'support embedded atomic simpleType/complexType definitions';
  eval { $message_parser->parse_string( xml_message() ) };
  ok ( !$@, 'parse XML message using atomic type definitions');
 };
 SKIP: {
    eval "require Test::Pod; ";
    skip 'Cannot test generated POD without Test::POD' , 12 if $@;
    foreach my $module (Test::Pod::all_pod_files( "$path/testlib")) {
        Test::Pod::pod_file_ok( $module )
    }
 }
 # cleanup
 rmtree "$path/testlib";
 # print $wsdl->explain();
 sub xml_message {
 	return
 q{<EnqueueMessage xmlns="http://www.example.org/MessageGateway2/">
 	<MMessage>
 		<MRecipientURI>anyURI</MRecipientURI>
 		<MSenderAddress>a string</MSenderAddress>
 		<MMessageContent>a string</MMessageContent>
 		<MSubject>a string</MSubject>
 		<MDeliveryReportRecipientURI>anyURI</MDeliveryReportRecipientURI>
 		<MKeepalive>
 			<MKeepaliveTimeout>1234567</MKeepaliveTimeout>
 			<MKeepaliveErrorPolicy> ( suppress | report ) </MKeepaliveErrorPolicy>
 		</MKeepalive>
 	</MMessage>
 </EnqueueMessage>
 };
 }
 sub xml_message2 {
 	return
 q{<EnqueueMessage xmlns="http://www.example.org/MessageGateway2/">
 	<MMessage>
 		<MRecipientURI>anyURI</MRecipientURI>
 		<MSenderAddress>a string</MSenderAddress>
 		<MMessageContent>a string</MMessageContent>
 		<MSubject>a string</MSubject>
 		<MDeliveryReportRecipientURI>anyURI</MDeliveryReportRecipientURI>
 	</MMessage>
 </EnqueueMessage>
 };
 }
 sub xml {
 	return q{<?xml version="1.0" encoding="UTF-8"?>
 <wsdl:definitions name="MessageGateway"
  targetNamespace="http://www.example.org/MessageGateway2/"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:tns="http://www.example.org/MessageGateway2/"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
  <wsdl:types>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://www.example.org/MessageGateway2/">
      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage"
        xmlns:tns="http://www.example.org/MessageGateway2/">
        <xsd:annotation>
          <xsd:documentation>Enqueue message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TMessage">
        <xsd:annotation>
          <xsd:documentation>
            A type containing all elements of a message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
                phone:. Not all URI schemas need to be implemented at the current
                implementation stage.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                E-Mail sender address. Ignored for all but mailto: recipient URIs.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>Message Content.</xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Message Subject. Ignored for all but mailto: URIs
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                URI to send a delivery report to. May be of one of the following schemes:
                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
                reports to http(s) URIs are sent as SOAP requests following the
                MessageGatewayClient service definition.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Container for keepalive information. May be missing.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepalive">
        <xsd:annotation>
          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
            <xsd:annotation>
              <xsd:documentation>
                Keepalive timeout. The keepalive timeout spezifies how long the sending of
                a message will be delayed waiting for keepalive updates. If a keepalive
                update is received during this period, the timeout will be reset. If not,
                the message will be sent after the timeout has expired.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Policy to comply to in case of system errors. Valid values are "suppress"
                and "report". If the policy is set to "suppress", keepalive messages will
                not be sent to their recipients in case of partial system failure, even if
                the keepalive has expired. This may result in "false negatives", i.e.
                messages may not be sent, even though their keepalive has expired. If the
                value is "report", keepalive messages will be sent from any cluster node.
                This may result in "false positive" alerts.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="suppress"></xsd:enumeration>
                <xsd:enumeration value="report"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TMessageID">
        <xsd:annotation>
          <xsd:documentation>Type containing a message ID.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepliveMessage">
        <xsd:annotation>
          <xsd:documentation>
            Type containing all elements of a keppalive update / remove request.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The ID for the message to update / remove
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The action to perform. Valid values are: "remove", "update". On "remove",
                the message with the ID specified will be removed from the queue, thus it
                will never be sent, even if it's timeout expires. On "update" the
                keepalive timeout of the corresponding message will be reset.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="remove"></xsd:enumeration>
                <xsd:enumeration value="update"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>Keepalive message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Enqueue message response element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TEnqueueMessage">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessage" type="tns:TMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a message to enqueue.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The keepalive message to process.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a keepalive message to process.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="EnqueueMessageRequest">
    <wsdl:part name="parameters" element="tns:EnqueueMessage">
      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="EnqueueMessageResponse">
    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageRequest">
    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageResponse">
    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:portType name="MGWPortType">
    <wsdl:documentation>
      generic port type for all methods required for sending messages over the mosaic
      message gatewa
    </wsdl:documentation>
    <wsdl:operation name="EnqueueMessage">
      <wsdl:documentation>
        This method is used to enqueue a normal (immediate send) or a delayed message with
        keepalive functionality.
      </wsdl:documentation>
      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <wsdl:documentation>
        This method is used to update or remove a
        keepalive message.
      </wsdl:documentation>
      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="EnqueueMessage">
      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <soap:operation
        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="MessageGateway">
    <wsdl:documentation>
      Web Service for sending messages over the message gatewa
    </wsdl:documentation>
    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
      <wsdl:documentation>HTTP(S) port for the message gateway</wsdl:documentation>
      <soap:address location="https://www.example.org/MessageGateway/" />
    </wsdl:port>
  </wsdl:service>
 </wsdl:definitions>};
 }
@@ -1,14 +1,20 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 18;
+use Test::More;
 use lib '../lib';
 use XML::LibXML;
 use SOAP::WSDL::SAX::WSDLHandler;
 use SOAP::WSDL::SAX::MessageHandler;
 use File::Path;
 use File::Basename;
 if (eval "require XML::LibXML") {
     plan tests => 18;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 my $path = dirname __FILE__;
 my $filter = SOAP::WSDL::SAX::WSDLHandler->new();
@@ -63,7 +69,7 @@ TODO: {
 SKIP: {
    eval "require Test::Pod";
-    skip 'Cannot test generated POD without Test::POD' , 6 if $@;
+    skip 'Cannot test generated POD without Test::POD' , 12 if $@;
    foreach my $module (Test::Pod::all_pod_files( "$path/testlib")) {
        Test::Pod::pod_file_ok( $module )
@@ -0,0 +1,49 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 12;
 use lib '../lib';
 use SOAP::WSDL::Expat::WSDLParser;
 use File::Find;
 use File::Basename;
 my $path = dirname __FILE__;
 my $wsdl;
 my $parser = SOAP::WSDL::Expat::WSDLParser->new();
 ok( $wsdl = $parser->parse_file( "$path/../example/wsdl/globalweather.xml" ) );
 $wsdl->create({
  base_path => "$path/testlib",
  typemap_prefix => "Test::Typemap::",
  type_prefix => "Test::Type::",
  element_prefix => "Test::Element::",
  interface_prefix => "Test::Interface::",
 });
 # Check for created files (and dirs) - value is the number of entries
 # with this (local) name
 my %expected = (
    'GetCitiesByCountry.pm' => 1,
    'GetCitiesByCountryResponse.pm' => 1,
    'GetWeather.pm' => 1,
    'GetWeatherResponse.pm' => 1,
    'string.pm' => 1,
    'Element' => 1,
    'Interface' => 1,
    'GlobalWeather.pm' => 2,
    'Typemap' => 1,
    'Test' => 1,
 );
 File::Find::finddepth(
    sub { 
        return if $_ eq '.';
        ok $expected{ $_ }--, $_;
        unlink $_ if -f $_;
        rmdir $_ if -d $_;      
    },
    "$path/testlib",
 );
 rmdir "$path/testlib";
@@ -1,14 +1,20 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 1;
+use Test::More;
 use lib '../lib';
 use XML::LibXML;
 use SOAP::WSDL::SAX::WSDLHandler;
 use SOAP::WSDL::SAX::MessageHandler;
 use File::Path;
 use File::Basename;
 if (eval "require XML::LibXML") {
     plan tests => 1;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 my $path = dirname __FILE__;
 my $filter = SOAP::WSDL::SAX::WSDLHandler->new();
@@ -0,0 +1,58 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More tests => 10;
 use File::Path;
 use File::Basename;
 use lib '../lib';
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $path = dirname __FILE__;
 my $parser = SOAP::WSDL::Expat::WSDLParser->new();
 eval { $parser->parsefile( "$path/acceptance/wsdl/03_complexType-element-ref.wsdl" ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL: $@";
 }
 else
 {
 	pass("parsing XML");
 }
 my $definitions = $parser->get_data();
 my $type = $definitions->first_types()->find_type('urn:Test', 'testComplexTypeRef');
 my $element = $definitions->first_types()->find_element('urn:Test', 'TestElement');
 my $output = '';
 ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate element code';
 ok eval $output, 'eval generated code';
 $output = '';
 ok $type->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate complexType code with element ref=""';
 ok eval $output, 'eval generated code';
 my $obj = Test::testComplexTypeRef->new({
  TestRef => 'test_ref',
  Test2 => 'test2',
 });
 is $obj, '<TestRef >test_ref</TestRef><Test2 >test2</Test2 >', 'serialization';
 $element = $definitions->first_types()->find_element('urn:Test', 'TestRef');
 $output = '';
 ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate top level element ref code';
 ok eval $output, 'eval generated code' . $@;
 $obj = Test::TestRef->new({ value => 'test_ref' });
 is $obj, '<TestRef xmlns="urn:Test" >test_ref</TestRef>', 'serialization';
@@ -0,0 +1,76 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use Test::More;
 use File::Path;
 use File::Basename;
 use lib '../lib';
 if (eval "require XML::LibXML") {
     plan tests => 11;
 }
 else {
    plan skip_all => "Cannot test without XML::LibXML";
 }
 my $path = dirname __FILE__;
 use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
 my $filter;
 my $parser = XML::LibXML->new();
 ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
 $parser->set_handler( $filter );
 eval { $parser->parse_file( "$path/acceptance/wsdl/03_complexType-element-ref.wsdl" ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL: $@";
 }
 else
 {
 	pass("parsing XML");
 }
 my $definitions = $filter->get_data();
 my $type = $definitions->first_types()->find_type('urn:Test', 'testComplexTypeRef');
 my $element = $definitions->first_types()->find_element('urn:Test', 'TestElement');
 my $output;
 ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate element code';
 ok eval $output, 'eval generated code';
 $output = '';
 ok $type->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate complexType code with element ref=""';
 ok eval $output, 'eval generated code';
 my $obj = Test::testComplexTypeRef->new({
  TestRef => 'test_ref',
  Test2 => 'test2',
 });
 is $obj, '<TestRef >test_ref</TestRef><Test2 >test2</Test2 >', 'serialization';
 $element = $definitions->first_types()->find_element('urn:Test', 'TestRef');
 $output = '';
 ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$output })
  , 'generate top level element ref code';
 ok eval $output, 'eval generated code' . $@;
 # print $output;
 $obj = Test::TestRef->new({ value => 'test_ref' });
 is $obj, '<TestRef xmlns="urn:Test" >test_ref</TestRef>', 'serialization';
@@ -5,7 +5,6 @@ use Test::More tests => 2;
 use lib '../lib';
 use lib 'lib';
 use lib 't/lib';
 use XML::LibXML;
 use SOAP::WSDL::SAX::MessageHandler;
 use_ok(qw/SOAP::WSDL::Expat::MessageParser/);
@@ -13,7 +12,6 @@ use_ok(qw/SOAP::WSDL::Expat::MessageParser/);
 use MyComplexType;
 use MyElement;
 use MySimpleType;
 use Benchmark;
 my $xml = q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
@@ -26,13 +24,6 @@ my $parser = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'FakeResolver'
 });
 my $libxml = XML::LibXML->new();
 my $handler = SOAP::WSDL::SAX::MessageHandler->new({
    class_resolver => 'FakeResolver',
 });
 $libxml->set_handler( $handler );
 $parser->parse( $xml );
 is $parser->get_data(), q{<MyAtomicComplexTypeElement xmlns="urn:Test" >}
@@ -0,0 +1,335 @@
 package TopElement;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::ComplexType;
 use Memoize;
 memoize('_get_handlers');
 use base qw(SOAP::WSDL::XSD::Typelib::Element
    SOAP::WSDL::XSD::Typelib::ComplexType
 );
 {
    my %TestElement_of :ATTR();
    my $CLASS_OF_REF = { TestElement => 'TestElement' };
    __PACKAGE__->_factory( [ 'TestElement' ], 
        { 'TestElement' => \%TestElement_of, },
        { TestElement => 'TestElement' },
    );
    sub get_xmlns { 'urn:Test' };
    __PACKAGE__->__set_name('TopElement');
    __PACKAGE__->__set_nillable(1);
    sub _get_handlers {
         my $self = shift;
         my $parser = shift;
         return {
             Start => $parser->start_tag({
                class_of => $CLASS_OF_REF,
                handler_of => {
                    TestElement => TestElement->_get_handlers( $parser ), 
                }            
             }),
             End => $parser->end_top_tag( ),
             Char => undef,
         };
    }
 }
 1;
 package TestElement;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::ComplexType;
 use Memoize;
 memoize('_get_handlers');
 use base qw(
    SOAP::WSDL::XSD::Typelib::Element
    SOAP::WSDL::XSD::Typelib::ComplexType
 );
 {
    my %test_of :ATTR();
    my %test2_of :ATTR();
    my $CLASS_OF_REF = { 
          test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
          test2 => 'SOAP::WSDL::XSD::Typelib::Builtin::string'
    };
    __PACKAGE__->_factory( [ 'test', 'test2' ], 
        { test => \%test_of, test2 => \%test2_of, },
        $CLASS_OF_REF,
    );
    sub get_xmlns { 'urn:Test' };
    __PACKAGE__->__set_name('TestElement');
    __PACKAGE__->__set_nillable(1);
    sub _get_handlers {
         my $self = shift;
         my $parser = shift;
         return {
             Start => $parser->start_tag({
                class_of => $CLASS_OF_REF,
                handler_of => 
                {
                   map { ( $_ => $CLASS_OF_REF->{$_}->_get_handlers( $parser ) )} 
                        keys %{ $CLASS_OF_REF }
                }, 
             }),
             End => $parser->end_tag(),
             Char => undef,
         };
    }
 }
 1;
 package TestResolver;
 sub get_class {
    my $path = join('/', @{ $_[1] });
    my $class = {
        'TestElement' => 'TestElement',
        'TestElement/test' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
        'TestElement/test2' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
        'TopElement' => 'TopElement',
        'TopElement/TestElement' => 'TestElement',
        'TopElement/TestElement/test' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
        'TopElement/TestElement/test2' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
    };
    return $class->{ $path }; 
 }
 1;
 package main;
 use Test::More qw/no_plan/; # TODO: change to tests => N;
 use strict;
 use warnings;
 use lib '../../lib';
 use_ok('SOAP::WSDL::Expat::MessageParser');
 use_ok('SOAP::WSDL::Expat::MessageSubParser');
 my $obj;
 ok($obj = SOAP::WSDL::Expat::MessageSubParser->new(), "Object creation");
 #my $test = $obj->start_tag({
 #    order => [],
 #    class_of => {
 #        test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #        test2 => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #    },
 #    handler_of => {
 #        test => {
 #            Char => $obj->characters(),
 #        },
 #        test2 => {
 #            Char => $obj->characters(),
 #        },       
 #    }
 #});
 #
 #my $handlers = {
 #    Start => $test,
 #    End => $obj->end_tag(),
 #};
 #
 #my $parser = $obj->initialize( $handlers );
 #
 #$parser->parsestring('<test>Test</test>');
 #is $obj->get_data(), 'Test', 'Parse simple XML';
 #
 #my $element = $obj->start_tag({
 #    order => [],
 #    class_of => {
 #        TestElement => 'TestElement',
 #    },
 #    handler_of => {
 #        TestElement => {
 #            Start => $obj->start_tag({
 #                order => [],
 #                class_of => {
 #                    test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #                    test2 => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #                },
 #                handler_of => {
 #                    test => {
 #                        Char => $obj->characters(),
 #                    },
 #                    test2 => {
 #                        Char => $obj->characters(),
 #                    },       
 #                }
 #            }),
 #            End => $obj->end_tag(),
 #            Char => undef,
 #        }
 #    }
 #});
 #
 #
 #$handlers = {
 #    Start => $element,
 #    End => $obj->end_tag(),
 #    Char => undef,
 #};
 #
 #$parser = $obj->initialize( TestElement->_get_parser( $obj ) );
 #
 #my $xml = '<TestElement xmlns="urn:Test">
 #    <test>Test</test>
 #    <test2>Test2</test2>
 #</TestElement>';
 #
 #$parser->parsestring($xml);
 #
 #is $obj->get_data()
 #    , '<TestElement xmlns="urn:Test" ><test >Test</test ><test2 >Test2</test2 ></TestElement>'
 #    , 'Parse && serialize ComplexType Element';
 #
 #my $mp = SOAP::WSDL::Expat::MessageParser->new({
 #    class_resolver => 'TestResolver',
 #});
 #
 #$mp->parse( $xml );
 #use Benchmark;
 #
 #timethese 1000 , {
 #    mp =>  sub { $mp->parse($xml) },
 #    'sub_p' => sub { $obj->initialize( $handlers )->parse( $xml ) },
 #
 #};
 #my $top = $obj->start_tag({
 #    order => [],
 #    class_of => {
 #        TopElement => 'TopElement',
 #    },
 #    handler_of => {
 #        TopElement => {
 #            Start => $obj->start_tag({
 #                order => [ 'TestElement', ],
 #                class_of => {
 #                    TestElement => 'TestElement',
 #                },
 #                handler_of => {
 #                    TestElement => {
 #                        Start => $obj->start_tag({
 #                            order => ['test', 'test2'],
 #                            class_of => {
 #                                test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #                                test2 => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
 #                            },
 #                            handler_of => {
 #                                test => {
 #                                    Char => $obj->characters(),
 #                                },
 #                                test2 => {
 #                                    Char => $obj->characters(),
 #                                },       
 #                            },
 #                            occurs_of => {
 #                                test => { max => 1 },
 #                            }
 #                        }),
 #                        End => $obj->end_tag(),
 #                        Char => undef,
 #                    }
 #                }
 #            })
 #        }
 #    }
 #});
 my $top = $obj->start_tag({
    class_of => {
        TopElement => 'TopElement',
    },
    handler_of => {
        TopElement => TopElement->_get_handlers( $obj ),
    }
 });
 my $parser = $obj->initialize( { Start => $top , End => $obj->end_tag() , Char => undef } );
 my $xml = '
 <TopElement  xmlns="urn:Test">
    <TestElement>
        <test>Test</test>  
        <test2>Test2</test2>    
    </TestElement>
    <TestElement>
        <test>Test</test>
        <test2>Test2</test2>    
    </TestElement>
    <TestElement>
        <test>Test</test>
        <test2>Test2</test2>    
    </TestElement>
    <TestElement>
        <test>Test</test>  
        <test2>Test2</test2>    
    </TestElement>
    <TestElement>
        <test>Test</test>
        <test2>Test2</test2>    
    </TestElement>
    <TestElement>
        <test>Test</test>
        <test2>Test2</test2>    
    </TestElement>
 </TopElement>';
 $parser->parsestring($xml);
 # print $obj->get_data();
 __END__
 # TODO factor out into benchmark suite
 use XML::Simple;
 use Benchmark;
 my $mp = SOAP::WSDL::Expat::MessageParser->new({
    class_resolver => 'TestResolver',
 });
 $mp->parse( $xml );
 $top = $obj->start_tag({
    class_of => {
        TopElement => 'TopElement',
    },
    handler_of => {
        TopElement => TopElement->_get_handlers( $obj ),
    }
 });
 my $top_end = $obj->end_top_tag();
 $parser = $obj->initialize( { Start => $top , End => $top_end, , Char => undef } );
 $parser->parse( $xml ),
 print "DATA:" . $obj->get_data(), "\n";
 # $XML::Simple::PREFERRED_PARSER = 'XML::SAX::Expat';
 $XML::Simple::PREFERRED_PARSER = 'XML::Parser';
 timethese 500 , {
    'typemap' =>  sub { $mp->parse($xml) },
    'sub_tree' => sub {            
            my $parser = $obj->initialize( { Start => $top , End => $top_end, , Char => undef } );
            $parser->parse( $xml ),
     },
     'XML::Simple' => sub { XMLin( $xml ); }
 };
@@ -0,0 +1,411 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
 use diagnostics;
 use Test::More tests => 7;
 use Data::Dumper;
 use lib '../lib';
 eval {
    require Test::XML;
    import Test::XML;
 };
 use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
 my $parser;
 ok $parser = SOAP::WSDL::Expat::WSDLParser->new(), "Object creation";
 $parser->parse( xml() );
 eval { $parser->parse( xml() ) };
 if ($@)
 {
 	fail("parsing WSDL");
 	die "Can't test without parsed WSDL: " , Dumper $@;
 }
 else
 {
 	pass("parsing XML");
 }
 my $wsdl;
 ok $wsdl = $parser->get_data() , "get object tree";
 my $schema = $wsdl->first_types()->get_schema()->[1] || die "No schema !";
 my $element = $schema->find_element(
  'http://www.example.org/MessageGateway2/'
  , 'EnqueueMessage'
 );
 ok $element, 'find element';
 is $element->get_xmlns()->{ 'http://www.example.org/MessageGateway2/' }, 'tns', 'Namespace definition';
 my $opt = {
 	typelib => $wsdl->first_types,
 	readable => 1,
 	autotype => 0,
 	namespace => { 'http://www.example.org/MessageGateway2/' => 'tns',
 		'http://www.w3.org/2001/XMLSchema' => 'xsd',
 		'http://schemas.xmlsoap.org/wsdl/' => 'wsdl',
 	},
 	indent => "",
 };
 my $data = { EnqueueMessage => {
 	MMessage => {
 		MRecipientURI => 'anyURI',
 		MSenderAddress => 'a string',
 		MMessageContent => 'a string',
 		MSubject => 'a string',
 		MDeliveryReportRecipientURI => 'anyURI',
 		MKeepalive => {
 			MKeepaliveTimeout => 1234567,
 			MKeepaliveErrorPolicy => ' ( suppress | report ) ',
 		}
 	}
 }
 };
 SKIP: { skip_without_test_xml();
    is_xml( $wsdl->find_message(
        "http://www.example.org/MessageGateway2/" ,'EnqueueMessageRequest'
        )->first_part()->serialize( 'test', $data, $opt ),
        xml_message()
        , "Serialized message part"
    );
 }
 sub skip_without_test_xml {
    skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
 }
 sub xml_message {
 	return
 q{<EnqueueMessage xmlns="http://www.example.org/MessageGateway2/">
 	<MMessage>
 		<MRecipientURI>anyURI</MRecipientURI>
 		<MSenderAddress>a string</MSenderAddress>
 		<MMessageContent>a string</MMessageContent>
 		<MSubject>a string</MSubject>
 		<MDeliveryReportRecipientURI>anyURI</MDeliveryReportRecipientURI>
 		<MKeepalive>
 			<MKeepaliveTimeout>1234567</MKeepaliveTimeout>
 			<MKeepaliveErrorPolicy> ( suppress | report ) </MKeepaliveErrorPolicy>
 		</MKeepalive>
 	</MMessage>
 </EnqueueMessage>
 };
 }
 sub xml {
 	return q{<?xml version="1.0" encoding="UTF-8"?>
 <wsdl:definitions name="MessageGateway"
  targetNamespace="http://www.example.org/MessageGateway2/"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:tns="http://www.example.org/MessageGateway2/"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
  <wsdl:types>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://www.example.org/MessageGateway2/">
      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage"
        xmlns:tns="http://www.example.org/MessageGateway2/"
        >
        <xsd:annotation>
          <xsd:documentation>Enqueue message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TMessage">
        <xsd:annotation>
          <xsd:documentation>
            A type containing all elements of a message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
                phone:. Not all URI schemas need to be implemented at the current
                implementation stage.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                E-Mail sender address. Ignored for all but mailto: recipient URIs.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>Message Content.</xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Message Subject. Ignored for all but mailto: URIs
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                URI to send a delivery report to. May be of one of the following schemes:
                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
                reports to http(s) URIs are sent as SOAP requests following the
                MessageGatewayClient service definition.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
            maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Container for keepalive information. May be missing.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepalive">
        <xsd:annotation>
          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
            <xsd:annotation>
              <xsd:documentation>
                Keepalive timeout. The keepalive timeout spezifies how long the sending of
                a message will be delayed waiting for keepalive updates. If a keepalive
                update is received during this period, the timeout will be reset. If not,
                the message will be sent after the timeout has expired.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                Policy to comply to in case of system errors. Valid values are "suppress"
                and "report". If the policy is set to "suppress", keepalive messages will
                not be sent to their recipients in case of partial system failure, even if
                the keepalive has expired. This may result in "false negatives", i.e.
                messages may not be sent, even though their keepalive has expired. If the
                value is "report", keepalive messages will be sent from any cluster node.
                This may result in "false positive" alerts.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="suppress"></xsd:enumeration>
                <xsd:enumeration value="report"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TMessageID">
        <xsd:annotation>
          <xsd:documentation>Type containing a message ID.</xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepliveMessage">
        <xsd:annotation>
          <xsd:documentation>
            Type containing all elements of a keppalive update / remove request.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The ID for the message to update / remove
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
            <xsd:annotation>
              <xsd:documentation>
                The action to perform. Valid values are: "remove", "update". On "remove",
                the message with the ID specified will be removed from the queue, thus it
                will never be sent, even if it's timeout expires. On "update" the
                keepalive timeout of the corresponding message will be reset.
              </xsd:documentation>
            </xsd:annotation>
            <xsd:simpleType>
              <xsd:restriction base="xsd:string">
                <xsd:enumeration value="remove"></xsd:enumeration>
                <xsd:enumeration value="update"></xsd:enumeration>
              </xsd:restriction>
            </xsd:simpleType>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>Keepalive message request element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
        <xsd:annotation>
          <xsd:documentation>Enqueue message response element</xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:complexType name="TEnqueueMessage">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The message to enqueue.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MMessage" type="tns:TMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a message to enqueue.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="TKeepaliveMessageRequest">
        <xsd:annotation>
          <xsd:documentation>
            A complex type containing one element: The keepalive message to process.
          </xsd:documentation>
        </xsd:annotation>
        <xsd:sequence>
          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
            <xsd:annotation>
              <xsd:documentation>
                Element containing a keepalive message to process.
              </xsd:documentation>
            </xsd:annotation>
          </xsd:element>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="EnqueueMessageRequest">
    <wsdl:part name="parameters" element="tns:EnqueueMessage">
      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="EnqueueMessageResponse">
    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageRequest">
    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="KeepaliveMessageResponse">
    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
    </wsdl:part>
  </wsdl:message>
  <wsdl:portType name="MGWPortType">
    <wsdl:documentation>
      generic port type for all methods required for sending messages over the mosaic
      message gatewa
    </wsdl:documentation>
    <wsdl:operation name="EnqueueMessage">
      <wsdl:documentation>
        This method is used to enqueue a normal (immediate send) or a delayed message with
        keepalive functionality.
      </wsdl:documentation>
      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <wsdl:documentation>
        This method is used to update or remove a
        keepalive message.
      </wsdl:documentation>
      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="EnqueueMessage">
      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="KeepaliveMessage">
      <soap:operation
        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="MessageGateway">
    <wsdl:documentation>
      Web Service for sending messages over the mosaic message gatewa
    </wsdl:documentation>
    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
      <wsdl:documentation>HTTP(S) port for the mosaic message gatewa</wsdl:documentation>
      <soap:address location="https://www.example.org/MessageGateway/" />
    </wsdl:port>
  </wsdl:service>
 </wsdl:definitions>};
 }
@@ -0,0 +1,43 @@
 use Test::More tests => 4;
 use strict;
 use warnings;
 use lib '../lib';
 use lib 't/lib';
 use lib 'lib';
 use Cwd;
 use File::Basename;
 my $path = cwd();
 my $name = basename $0;
 $name =~s/\.t$//;
 $name =~s/^t\///;
 $path =~s{(/t)?/SOAP/WSDL}{}xms;
 use_ok(qw/SOAP::WSDL/);
 print "# SOAP::WSDL Version: $SOAP::WSDL::VERSION\n";
 my $xml;
 my $soap;
 #2
 ok( $soap = SOAP::WSDL->new(
 	wsdl => 'file://' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl',
 	readable => 1,
    no_dispatch => 1,
 ), 'Instantiated object' );
 ok ($xml = $soap->call('test',  
 			testAll => {
 				Test2 => 'Test2',
 				TestRef => 'TestRef'
 			}
 ), 'Serialized complexType' );
 is $xml, q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" ><SOAP-ENV:Body><testAll>
 	<TestRef>TestRef</TestRef>
 	<Test2>Test2</Test2>
 </testAll>
 </SOAP-ENV:Body></SOAP-ENV:Envelope>}
    , 'element ref="" serialization';
@@ -1,83 +0,0 @@
 #!/usr/bin/perl -w
 use strict;
 use Test::More tests=> 5;
 use Time::HiRes qw( gettimeofday tv_interval );
 use lib '../..';
 use Data::Dumper;
 use Cwd;
 use File::Basename;
 use_ok qw/ SOAP::WSDL /;
 use Benchmark;
 print "# Testing SOAP::WSDL ". $SOAP::WSDL::VERSION."\n";
 print "# Performance test with simple WSDL file\n";
 my $soap;
 my $data = {
    sayHello => {
 		name => 'Mein Name',
 		givenName => 'Vorname',
    }		
 };
 my $name = basename( $0 );
 $name =~s/\.(t|pl)$//;
 my $path = cwd;
 $path=~s{(/t)?/SOAP/WSDL}{}xms;
 my $cacheDir;
 if ($^O =~ m/Win/)
 {
 	$cacheDir = 'C:/Temp/WSDL';
 }
 else
 {
 	$cacheDir = '/tmp/';
 }
 my $t0 = [gettimeofday];
 ok( 
 	$soap=SOAP::WSDL->new(
 		wsdl => "file://$path/t/acceptance/wsdl/10_helloworld.asmx.xml",
 		no_dispatch => 1
 	),
    "Create SOAP::WSDL object (".tv_interval ( $t0, [gettimeofday]) ."ms)" );
 $soap->proxy('http://helloworld/helloworld.asmx');
 $t0 = [gettimeofday];
 eval{ 
 	$soap->wsdlinit(
 	   caching => 1,
 	   cache_directory => $cacheDir,
 	   servicename => 'Service1' ) };
 unless ($@) {
 	pass("wsdl file init (".tv_interval ( $t0, [gettimeofday]) ."s)");
 } else {
 	fail( $@ );
 }
 $soap->readable(1);
 $t0 = [gettimeofday];
 ok( $soap->call("sayHello" , %{ $data }),
 	"1 x call pre-work (".tv_interval ( $t0, [gettimeofday]) ."s)") ;
 $t0 = [gettimeofday];
 ok($soap->call(sayHello => %{ $data }),
 	"1 x call pre-work (".tv_interval ( $t0, [gettimeofday]) ."s)" );
 timethis 1000, sub { $soap->call(sayHello => %{ $data }) };
 __END__
 $t0 = [gettimeofday];
 for (my $i=1; $i<100; $i++) 
 {
 	$soap->call(sayHello => %{ $data });
 }
 ok(1, "100 x call pre-work (".tv_interval ( $t0, [gettimeofday]) ."s)");
 chdir $cwd;
@@ -12,7 +12,7 @@
 use strict;
 use Test::More tests => 4;
-use lib '../..';
+use lib '../../../lib/';
 use Cwd;
 use File::Basename;
@@ -0,0 +1,44 @@
 use Test::More tests => 9;
 use strict;
 use warnings;
 use File::Basename;
 use SOAP::WSDL::Client;
 my $soap;
 my $base_dir = dirname( __FILE__ );
 use_ok(qw/SOAP::WSDL::Transport::Test/);
 $soap = SOAP::WSDL::Client->new();
 $soap->set_proxy('http://somewhere.over.the.rainbow');
 ok( $soap->get_transport->set_base_dir( join '/', $base_dir, 'acceptance' ) );
 my $response = $soap->call({ operation => 'test', soap_action => 'http://test' }, {});
 ok ! $response, 'Returned fault on error';
 is $response->get_faultcode(), 'soap:Server', 'faultcode';
 is $response->get_faultactor(), 'urn:localhost', 'faultactor';
 $soap->outputxml(1);
 $response = $soap->call({ operation => 'test', soap_action => 'http://test2' }, {});
 is $response, 'test2', 'Returned file content';
 SKIP: {
    eval { require SOAP::WSDL::Deserializer::SOM; }
      or skip 'SOAP::WSDL::Deserializer::SOM required', 3;
    # requre SOAP::WSDL::Factory::Deserializer;
    SOAP::WSDL::Factory::Deserializer->register('1.1', 'SOAP::WSDL::Deserializer::SOM');
    my $soap_som = SOAP::WSDL::Client->new();
    $soap_som->set_proxy('http://somewhere.over.the.rainbow');
    $soap_som->get_transport->set_base_dir( join '/', $base_dir, 'acceptance' );
    my $som;
    ok $som = $soap_som->call({ operation => 'test', soap_action => 'http://test3' }, {}) 
      , 'Call with SOAP::WSDL::Deserializer::SOM';
    # In the somewhat weird logic of SOAP::Lite, the first node inside the root element
    # is the reault, all others are output parameters (and may be accessed via "paramsout")
    is $som->result(), 'Munich', 'Result match';
    is $som->paramsout(), 'Germany' , 'Output parameter match';
 }
@@ -0,0 +1 @@
 test2
@@ -0,0 +1 @@
 <SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" ><SOAP-ENV:Body><GetWeatherResponse xmlns="http://www.webserviceX.NET"><CityName>Munich</CityName><CountryName>Germany</CountryName></GetWeatherResponse></SOAP-ENV:Body></SOAP-ENV:Envelope>
@@ -0,0 +1,20 @@
 use strict;
 use warnings;
 use Test::More qw(no_plan);
 use Scalar::Util qw(blessed);
 use lib '../../../../../../lib';
 use_ok qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
 my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anyType->new({
    xmlns => 'urn:Siemens.mosaic'
 });
 ok blessed $obj, 'constructor returned blessed reference';
 ok $obj->set_xmlns('urn:SOAP-WSDL'), 'set_xmlns';
 is $obj->get_xmlns(), 'urn:SOAP-WSDL', 'get_xmlns';
 is $obj->start_tag({ name => 'test' }), '<test >', 'start_tag';
 is $obj->end_tag({ name => 'test' }), '</test >', 'end_tag';
 is "$obj", q{}, 'serialize overloading';
@@ -0,0 +1,44 @@
 use strict;
 use warnings;
 use Test::More qw(no_plan);
 use Scalar::Util qw(blessed);
 use lib '../../../../../../lib';
 use_ok qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
 my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({});
 ok $obj->set_xmlns('urn:SOAP-WSDL'), 'set_xmlns';
 is $obj->get_xmlns(), 'urn:SOAP-WSDL', 'get_xmlns';
 ok blessed $obj, 'constructor returned blessed reference';
 is $obj->start_tag({ name => 'test' }), '<test >', 'start_tag';
 is $obj->end_tag({ name => 'test' }), '</test >', 'end_tag';
 ok $obj->set_value('test'), 'set_value';
 is $obj->get_value(), 'test', 'get_value';
 is "$obj", q{test}, 'serialize overloading';
 ok ($obj)
    ? pass 'boolean overloading'
    : fail 'boolean overloading';
 ok ! $obj->set_value(undef), 'set_value with explicit undef';
 is $obj->get_value(), undef, 'get_value';
 is "$obj", q{}, 'stringification overloading';
 ok $obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({
    xmlns => 'urn:XSD',
    value => 'test2',
 });
 is $obj->get_xmlns(), 'urn:XSD', 'get_xmlns on attr value';
 is $obj->get_value(), 'test2', 'get_value on attr value';
 $obj->set_value(undef);
 is $obj->serialize({ name => 'foo' }), '<foo ></foo >'
    , 'serialize undef value with name';
 is $obj->serialize(), q{}, 'serialize undef value without name'
@@ -1,5 +1,8 @@
-use Test::More tests => 6;
+use Test::More tests => 30;
 use strict;
 use Carp qw(cluck);
 $SIG{__WARN__} = sub { cluck @_ };
 use warnings;
 use lib '../lib';
 use Date::Format;
@@ -8,7 +11,7 @@ use_ok('SOAP::WSDL::XSD::Typelib::Builtin::date');
 my $obj;
 sub timezone {
-    my @time = strptime shift;
+    my @time = map { defined $_ ? $_ : 0 } strptime shift;
    my $tz = strftime('%z', @time);
    substr $tz, -2, 0, ':';
    return $tz;
@@ -20,6 +23,44 @@ my %dates = (
    '30 Aug 2007' => '2007-08-30',
 );
 my %localized_date_of = (
    '2007-12-31T00:00:00.0000000+0000' => '2007-12-31+00:00',
    '2007-12-31T00:00:00.0000000+0130' => '2007-12-31+01:30',
    '2007-12-31T00:00:00.0000000+0200' => '2007-12-31+02:00',
    '2007-12-31T00:00:00.0000000+0300' => '2007-12-31+03:00',
    '2007-12-31T00:00:00.0000000+0400' => '2007-12-31+04:00',
    '2007-12-31T00:00:00.0000000+0500' => '2007-12-31+05:00',
    '2007-12-31T00:00:00.0000000+0600' => '2007-12-31+06:00',
    '2007-12-31T00:00:00.0000000+0700' => '2007-12-31+07:00',
    '2007-12-31T00:00:00.0000000+0800' => '2007-12-31+08:00',
    '2007-12-31T00:00:00.0000000+0900' => '2007-12-31+09:00',
    '2007-12-31T00:00:00.0000000+1000' => '2007-12-31+10:00',
    '2007-12-31T00:00:00.0000000+1100' => '2007-12-31+11:00',    
    '2007-12-31T00:00:00.0000000+1200' => '2007-12-31+12:00',    
    '2007-12-31T00:00:00.0000000-0100' => '2007-12-31-01:00',
    '2007-12-31T00:00:00.0000000-0200' => '2007-12-31-02:00',
    '2007-12-31T00:00:00.0000000-0300' => '2007-12-31-03:00',
    '2007-12-31T00:00:00.0000000-0400' => '2007-12-31-04:00',
    '2007-12-31T00:00:00.0000000-0500' => '2007-12-31-05:00',
    '2007-12-31T00:00:00.0000000-0600' => '2007-12-31-06:00',
    '2007-12-31T00:00:00.0000000-0700' => '2007-12-31-07:00',
    '2007-12-31T00:00:00.0000000-0800' => '2007-12-31-08:00',
    '2007-12-31T00:00:00.0000000-0900' => '2007-12-31-09:00',
    '2007-12-31T00:00:00.0000000-1000' => '2007-12-31-10:00',
    '2007-12-31T00:00:00.0000000-1100' => '2007-12-31-11:00',    
    '2007-12-31T00:00:00.0000000-1200' => '2007-12-31-12:00',    
 );
 while (my ($date, $converted) = each %localized_date_of ) {
    $obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
    $obj->set_value( $date );
    is $obj->get_value() , $converted , 'conversion';
 }
 while (my ($date, $converted) = each %dates ) {
    $obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
@@ -28,9 +69,6 @@ while (my ($date, $converted) = each %dates ) {
    is $obj->get_value() , $converted . timezone($date), 'conversion';
 }
-$obj->set_value('2007-12-31T00:00:00.0000000+01:00');
+$obj->set_value( '2037-12-31+12:00' );
-is $obj->get_value() , '2007-12-31+01:00', 'conversion from XML dateTime';
+is $obj->get_value() , '2037-12-31+12:00', 'no conversion on match';
 $obj->set_value( '2037-12-31' );
 is $obj->get_value() , '2037-12-31', 'no conversion on match';
@@ -13,6 +13,8 @@ sub timezone {
 }
 use_ok('SOAP::WSDL::XSD::Typelib::Builtin::dateTime');
 print "# timezone is " . timezone( scalar localtime(time) ) . "\n";
 my $obj;
 my %dates = (
    '2007-12-31 12:32' => '2007-12-31T12:32:00', 
@@ -25,14 +27,6 @@ while (my ($date, $converted) = each %dates ) {
    $obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new();
    $obj->set_value( $date );
-    is $obj->get_value() , $converted . timezone($date), 'conversion';
+    is $obj->get_value() , $converted . timezone($date), 'conversion with timezone';
 }
 $obj->set_value('2007-12-31T00:00:00.0000000+01:00');
 # exit;
 #~ use Benchmark;
 #~ timethese 10000, {
    #~ xml => sub { $obj->set_value('2037-12-31T00:00:00.0000000+01:00') },
    #~ string => sub { $obj->set_value('2037-12-31') },
 #~ }
@@ -2,7 +2,7 @@
 <definitions name="urn:simpleType" 
 	targetNamespace="urn:simpleType"
 	xmlns:tns="urn:simpleType"
-	xmlns:wsd="http://www.w3c.org/2001/XMLSchema"
+	xmlns:xsd="http://www.w3c.org/2001/XMLSchema"
 	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 >
@@ -0,0 +1,53 @@
 <?xml version="1.0"?>
 <definitions name="urn:Test" targetNamespace="urn:Test" xmlns:tns="urn:Test"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  <types>
    <xsd:schema targetNamespace="urn:Test">
      <xsd:element name="TestElement" type="xsd:string" />
      <xsd:element name="TestRef" ref="tns:TestElement" />
      <xsd:complexType name="testComplexTypeRef">
        <xsd:annotation>
          <xsd:documentation>ComplexType Test</xsd:documentation>
        </xsd:annotation>
        <xsd:all>
          <xsd:element name="TestRef" ref="tns:TestElement" />
          <xsd:element name="Test2" type="xsd:string" minOccurs="1" />
        </xsd:all>
      </xsd:complexType>
    </xsd:schema>
  </types>
  <message name="testRequest">
    <part name="testAll" type="tns:testComplexTypeRef" />
  </message>
  <message name="testResponse">
    <part name="testAll" type="tns:testComplexTypeRef" />
  </message>
  <portType name="testPort">
    <operation name="test">
      <documentation>Test-Methode</documentation>
      <input message="tns:testRequest" />
      <output message="tns:testResponse" />
    </operation>
  </portType>
  <binding type="tns:testPort" name="testBinding">
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <operation name="test">
      <soap:operation soapAction="test">
        <input>
          <soap:body use="literal" />
        </input>
        <output>
          <soap:body use="literal" />
        </output>
      </soap:operation>
    </operation>
  </binding>
  <service name="testService">
    <port name="testPort" binding="tns:testBinding">
      <soap:address location="http://127.0.0.1/testPort" />
    </port>
  </service>
 </definitions>
@@ -1,7 +1,6 @@
 #!/usr/bin/perl
 package MyElement;
 use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use base (
@@ -14,7 +13,6 @@ sub get_xmlns { 'urn:Test' };
 package MyComplexTypeElement;
 use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use MyComplexType;
 use base (
@@ -27,7 +25,6 @@ sub get_xmlns { 'urn:Test' };
 package MyTestElement;
 use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::Builtin::string;
 use base (
@@ -41,7 +38,6 @@ sub get_xmlns { 'urn:Test' };
 package MyTestElement2;
 use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use base (
@@ -57,7 +53,6 @@ sub get_xmlns { 'urn:Test' };
 package MyAtomicComplexTypeElement;
 use strict;
 use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Element;
 use SOAP::WSDL::XSD::Typelib::ComplexType;
 use SOAP::WSDL::XSD::Typelib::Builtin;
@@ -1,7 +1,6 @@
 package Typelib::TEnqueueMessage;
 use strict;
 use base qw(Typelib::Base);
 use Class::Std::Storable;
 my %MMessage_of :ATTR(:name<MMessage> :default<()>);
@@ -1,7 +1,6 @@
 package Typelib::TMessage;
 use strict;
 use base qw(Typelib::Base);
 use Class::Std::Storable;
 my %MRecipientURI_of   :ATTR(:name<MRecipientURI> :default<()>);
 my %MMessageContent_of :ATTR(:name<MMessageContent> :default<()>);
@@ -0,0 +1,15 @@
 use Date::Format;
 use Date::Parse;
 use Date::Language;
 my $date_string='2007-12-13T00:00:00.12345+0300';
 my $time = str2time( $date_string );
 print $time,"\n";
 $date_string='2007-12-13T00:00:00.12345+0200';
 my $time = str2time( $date_string );
 print time2str('%d. %B %Y %H %M %S', $time, '+0200' );
Author	SHA1	Message	Date
Martin Kutter	099c83b6bc	import SOAP-WSDL 2.00_14 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_14 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_14.tar.gz	2009-12-12 19:47:53 -08:00
Martin Kutter	f63138fc87	import SOAP-WSDL 2.00_13 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_13 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_13.tar.gz	2009-12-12 19:47:52 -08:00
Martin Kutter	fd0854e34a	import SOAP-WSDL 2.00_12 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_12 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_12.tar.gz	2009-12-12 19:47:49 -08:00
Martin Kutter	c2da74b5ae	import SOAP-WSDL 2.00_11 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_11 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_11.tar.gz	2009-12-12 19:47:49 -08:00
		`@@ -0,0 +1 @@`
							`<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" ><SOAP-ENV:Body><GetWeatherResponse xmlns="http://www.webserviceX.NET"><CityName>Munich</CityName><CountryName>Germany</CountryName></GetWeatherResponse></SOAP-ENV:Body></SOAP-ENV:Envelope>`