import SOAP-WSDL 2.00_24 from CPAN

git-cpan-module:   SOAP-WSDL
git-cpan-version:  2.00_24
git-cpan-authorid: MKUTTER
git-cpan-file:     authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_24.tar.gz

t/002_parse_wsdl.t

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 use strict;
 use warnings;
-use Test::More tests => 17;
+use Test::More tests => 22;
 use lib '../lib';
 
 eval {
@@ -156,6 +156,21 @@ my $opt = {
 
 # ok $wsdl->explain($opt) =~ m/#optional/m;
 
+eval { $wsdl->expand('hallo:welt')};
+like $@, qr{unbound}, 'Die on attempt to resolve unbound prefix';
+
+my $complex = $types->find_type( 'urn:myNamespace', 'complex');
+
+ok $complex->find_element('urn:myNamespace', 'length'), 'Find element in complexType';
+ok ! $complex->find_element('urn:myNamespace', 'FOO'), 'Find element in complexType';
+
+eval { $complex->foo() };
+like $@, qr{ foo }xms;
+
+eval { SOAP::WSDL::ComplexType->foo() };
+like $@, qr{ foo }xms;
+
+
 sub skip_without_test_xml {
     skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
 }

t/097_kwalitee.t

@@ -0,0 +1,21 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+use Test::More;
+use English qw(-no_match_vars);
+
+if ( not $ENV{TEST_AUTHOR} ) {
+    my $msg = 'Author test.  Set $ENV{TEST_AUTHOR} to a true value to run.';
+    plan( skip_all => $msg );
+}
+
+chdir '..' if -d ('../t');
+
+eval 'use Test::Kwalitee';
+
+if ( $EVAL_ERROR ) {
+    my $msg = 'Test::Kwalitee not installed; skipping';
+    plan( skip_all => $msg );
+}

t/099_pod_coverage.t

@@ -0,0 +1,58 @@
+use Test::More;
+
+
+if ( not $ENV{TEST_AUTHOR} ) {
+    my $msg = 'Author test.  Set $ENV{TEST_AUTHOR} to a true value to run.';
+    plan( skip_all => $msg );
+}
+
+eval "use Test::Pod::Coverage 1.00";
+plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD" if $@;
+
+my @dirs = ( 'lib' );
+if (-d '../t/') {       # we are inside t/
+    @dirs = ('../lib');
+} 
+else {                  # we are outside t/
+    # add ./lib to include path if blib/lib is not there (e.g. we're not 
+    # run from Build test or the like) 
+    push @INC, './lib' if not grep { $_ eq 'blib/lib' } @INC; 
+}
+
+# Don't test Builtin XSD types - they're undocumented on purpose
+# Don't test WSDL datatypes - they're undocumented on purpose.
+@files = grep { $_ !~m{ (SOAP::WSDL::XSD::Typelib::Builtin::.+
+    |SOAP::WSDL::OpMessage
+    |SOAP::WSDL::Types
+    |SOAP::WSDL::PortType
+    |SOAP::WSDL::Port
+    |SOAP::WSDL::Service
+    |SOAP::WSDL::Binding
+    |SOAP::WSDL::Message
+    |SOAP::WSDL::TypeLookup
+    |SOAP::WSDL::Base
+    |SOAP::WSDL::Part
+    |SOAP::WSDL::Operation
+    |SOAP::WSDL::SOAP::[^:]+
+    |SOAP::WSDL::XSD::SimpleType
+    |SOAP::WSDL::XSD::Element
+    |SOAP::WSDL::XSD::ComplexType
+    |SOAP::WSDL::XSD::Builtin
+    |SOAP::WSDL::XSD::Schema
+    
+    ) \z }xms; } all_modules( @dirs );
+
+plan tests => scalar @files;
+foreach (@files) {
+    pod_coverage_ok( $_ , 
+	{ 
+	    private => [ 
+	       qr/^_/, 
+	       qr/^BUILD$/, 
+	       qr/^START$/, 
+	       qr/^STORABLE/, 
+	       qr/^AUTOMETHOD$/,
+	       qr/^DEMOLISH$/
+	       ]
+	});
+}

t/Expat/01_expat.t

@@ -17,6 +17,7 @@ my $xml = q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta
     <SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >
     <test>Test</test>
     <test2 >Test2</test2>
+    <foo><bar></bar><baz></baz></foo>
     </MyAtomicComplexTypeElement></SOAP-ENV:Body></SOAP-ENV:Envelope>};
 
 my $parser = SOAP::WSDL::Expat::MessageParser->new({
@@ -37,6 +38,9 @@ BEGIN {
             'MyAtomicComplexTypeElement' => 'MyAtomicComplexTypeElement',
             'MyAtomicComplexTypeElement/test' => 'MyTestElement',
             'MyAtomicComplexTypeElement/test2' => 'MyTestElement2',
+            'MyAtomicComplexTypeElement/foo' => '__SKIP__',
+            'MyAtomicComplexTypeElement/foo/bar' => 'MyFooElement',
+            'MyAtomicComplexTypeElement/foo/baz' => 'MyFooElement',
         );
 
         sub new { return bless {}, 'FakeResolver' };

t/SOAP/WSDL/03_complexType-element-ref.t

@@ -37,5 +37,5 @@ ok ($xml = $soap->call('test',
 			}
 ), '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>}
+like $xml, qr{<SOAP-ENV:Body><testAll><TestRef>TestRef</TestRef><Test2>Test2</Test2></testAll></SOAP-ENV:Body>}
     , 'element ref="" serialization';

t/SOAP/WSDL/04_element.t

@@ -44,8 +44,8 @@ ok ($xml = $soap->call('testRef',
 	testElementRef => 'Test'
 ), 'Serialized (simple) element' );
 
-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><testElementRef  xmlns="urn:Test">Test</testElementRef></SOAP-ENV:Body></SOAP-ENV:Envelope>}
+like $xml 
+    , qr{<testElementRef\s\sxmlns="urn:Test">Test</testElementRef></SOAP-ENV:Body></SOAP-ENV:Envelope>}
     , 'element ref serialization result'
 ;
 

t/SOAP/WSDL/Deserializer/Hash.t

@@ -1,4 +1,4 @@
-use Test::More tests => 11;
+use Test::More tests => 13;
 use lib '../../../lib';
 use_ok qw(SOAP::WSDL::Deserializer::Hash);
 
@@ -13,9 +13,27 @@ is $data->{a}->{b}->[0], 1;
 is $data->{a}->{b}->[1], 2;
 is $data->{a}->{c}, 3;
 
-ok $data = $deserializer->deserialize(q{<a><b><c>1</c></b><b><c>2</c></b></a>});
+# need 3 elements in array to trigger all branches...
+# need ignorable whitespace to trigger removal...
+ok $data = $deserializer->deserialize(
+q{<a>
+    <b><c>1</c></b>
+    <b><c>2</c></b>
+    <b><c>3</c></b>
+</a>});
 is $data->{a}->{b}->[0]->{c}, 1;
 is $data->{a}->{b}->[1]->{c}, 2;
 
 eval { $deserializer->deserialize('grzlmpfh') };
-ok $@->isa('SOAP::WSDL::SOAP::Typelib::Fault11');
+ok $@->isa('SOAP::WSDL::SOAP::Typelib::Fault11');
+
+my $fault = $deserializer->generate_fault({
+   message => 'Foo',
+   code => 'Bar',
+   role => 'mine', 
+});
+
+is $fault->get_faultstring(), 'Foo';
+
+$fault = $deserializer->generate_fault({});
+is $fault->get_faultstring(), 'Unknown error';

t/SOAP/WSDL/Deserializer/SOM.t

@@ -1,5 +1,5 @@
 use Test::More;
-use SOAP::Lite;
+
 eval { require SOAP::Lite; 1; } or do {
     plan skip_all => 'SOAP::Lite not available';
     exit 0;

t/SOAP/WSDL/Deserializer/XSD.t

@@ -1,6 +1,6 @@
 use strict;
 use warnings;
-use Test::More tests => 5;
+use Test::More tests => 8;
 
 use SOAP::WSDL::Deserializer::XSD;
 
@@ -16,4 +16,8 @@ my $fault = $obj->generate_fault();
 
 is $fault->get_faultstring(), 'Unknown error';
 is $fault->get_faultactor(), 'urn:localhost';
-is $fault->get_faultcode(), 'soap:Client';
+is $fault->get_faultcode(), 'soap:Client';
+
+isa_ok $obj->deserialize('rubbeldiekatz'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
+isa_ok $obj->deserialize('<zumsel></zumsel>'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
+isa_ok $obj->deserialize('<Envelope xmlns="huchmampf"></Envelope>'), 'SOAP::WSDL::SOAP::Typelib::Fault11';

t/SOAP/WSDL/Generator/XSD.t

@@ -1,4 +1,4 @@
-use Test::More tests => 34;
+use Test::More tests => 37;
 use File::Basename qw(dirname);
 use File::Spec;
 use File::Path;
@@ -40,9 +40,10 @@ $generator->set_typemap_prefix('MyTypemaps');
 $generator->set_interface_prefix('MyInterfaces');
 
 $generator->set_output(undef);
-$generator->generate_typelib();
-$generator->generate_typemap();
-$generator->generate_interface();
+$generator->generate();
+#$generator->generate_typelib();
+#$generator->generate_typemap();
+#$generator->generate_interface();
 
 eval "use lib '$path/testlib'";
 use_ok qw( MyInterfaces::testService::testPort );
@@ -122,6 +123,7 @@ ok eval { require MyTypes::testComplexTypeElementAtomicSimpleType; };
 my $ct_east = MyTypes::testComplexTypeElementAtomicSimpleType->new({
     testString => 'Just some test',
     testAtomicSimpleTypeElement => 42,
+    testAtomicSimpleTypeElement2 => 23,
 });
 
 is $ct_east->get_testAtomicSimpleTypeElement, 42;
@@ -129,4 +131,11 @@ is $ct_east->get_testAtomicSimpleTypeElement->get_value(), 42;
 isa_ok($ct_east->get_testAtomicSimpleTypeElement, 
     'MyTypes::testComplexTypeElementAtomicSimpleType::_testAtomicSimpleTypeElement');
 
+
+is $ct_east->get_testAtomicSimpleTypeElement2, 23;
+is $ct_east->get_testAtomicSimpleTypeElement2->get_value(), 23;
+isa_ok($ct_east->get_testAtomicSimpleTypeElement2, 
+    'MyTypes::testComplexTypeElementAtomicSimpleType::_testAtomicSimpleTypeElement2');
+
+
 rmtree "$path/testlib";

t/SOAP/WSDL/Transport/01_Test.t

@@ -23,6 +23,7 @@ ok( $soap->get_transport->set_base_dir( join '/', $base_dir, 'acceptance' ) );
     $soap->outputxml(1);
     $response = $soap->call({ operation => 'test', soap_action => 'http://test2' }, {});
     is $response, 'test2', 'Returned file content';
+
 }
 
 SKIP: {

t/SOAP/WSDL/XSD/Typelib/Builtin/boolean.t

@@ -1,4 +1,4 @@
-use Test::More tests => 18;
+use Test::More tests => 19;
 use strict;
 use warnings;
 use SOAP::WSDL::XSD::Typelib::Builtin::boolean;
@@ -46,6 +46,7 @@ is "$bool", 'false', 'stringification';
 ok $bool->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
 
 is $bool->serialize({ name => 'test'}), '<test >false</test >';
+is $bool->serialize(), 'false';
 
 $bool->delete_value();
 is "$bool", '', 'serialized undef to empty string';

t/SOAP/WSDL/XSD/Typelib/Builtin/date.t

@@ -53,6 +53,12 @@ my %localized_date_of = (
 
 );
 
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new({});
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new({
+    value => '2007-12-31'
+});
+
 while (my ($date, $converted) = each %localized_date_of ) {
 
     $obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();

t/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.t

@@ -22,6 +22,10 @@ my %dates = (
     '30 Aug 2007' => '2007-08-30T00:00:00',
 );
 
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new();
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new({});
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new({ value => '2007-08-31T00:32:00' });
+
 while (my ($date, $converted) = each %dates ) {
 
     $obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new();

t/SOAP/WSDL/XSD/Typelib/Builtin/language.t

@@ -0,0 +1,12 @@
+use Test::More tests => 5;
+use strict;
+use warnings;
+use SOAP::WSDL::XSD::Typelib::Builtin::language;
+my $Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new();
+is $Name->get_value(), undef;
+$Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new({});
+is $Name->get_value(), undef;
+ok $Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new({ value => 'DE' });
+is "$Name", "DE", 'stringification';
+
+ok $Name->isa('SOAP::WSDL::XSD::Typelib::Builtin::token'), 'inheritance';

t/SOAP/WSDL/XSD/Typelib/Builtin/time.t

@@ -17,8 +17,11 @@ my $timezone = timezone;
 use_ok('SOAP::WSDL::XSD::Typelib::Builtin::time');
 my $obj;
 
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new({value => '12:23:33'});
+$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new({});
 $obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new();
 
+
 $obj->set_value( '12:23:03' );
 is $obj->get_value() , "12:23:03$timezone", 'conversion';
 

t/SOAP/WSDL/XSD/Typelib/ComplexType.t

@@ -0,0 +1,216 @@
+use strict;
+use warnings;
+
+package MyType;
+
+use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
+
+my %test_of :ATTR(:get<test>);
+
+__PACKAGE__->_factory(
+[ 'test' ],
+{
+    test => \%test_of,
+},
+{
+    test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+}
+);
+
+package MyType2;
+
+use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
+
+my %test2_of :ATTR(:get<test>);
+
+__PACKAGE__->_factory(
+[ 'test' ],
+{
+    test => \%test2_of,
+},
+{
+    test => 'MyType',
+}
+);
+
+package main;
+use Test::More tests => 90;
+use Data::Dumper;
+use Storable;
+my $obj;
+
+$obj = MyType->new({});
+isa_ok $obj, 'MyType';
+is $obj->get_test, undef, 'undefined element content';
+
+$obj = MyType->new({ test => 'Test1'});
+isa_ok $obj, 'MyType';
+isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $obj->get_test, 'Test1', 'element content';
+
+$obj = MyType->new({ 
+    test => SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+        value => 'Test2'
+    })
+});
+isa_ok $obj, 'MyType';
+isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $obj->get_test, 'Test2', 'element content';
+
+$obj = MyType->new({ 
+    test => { value => 'Test2' } # just a trick - pass it unaltered to new...
+});
+isa_ok $obj, 'MyType';
+isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $obj->get_test, 'Test2', 'element content';
+
+$obj = MyType->new({ 
+    test => [
+        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+            value => 'Test'
+        }),
+
+        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+            value => 'Test2'
+        })
+    ],
+});
+isa_ok $obj, 'MyType';
+isa_ok $obj->get_test, 'ARRAY';
+is $obj->get_test()->[0], 'Test', 'element content';
+is $obj->get_test()->[1], 'Test2', 'element content';
+
+my $nested = MyType2->new({
+    test => $obj,
+});
+
+is $nested->get_test, $obj;
+$nested = MyType2->new({
+    test => [$obj, $obj],
+});
+
+is $nested->get_test->[0], $obj;
+
+$nested = MyType2->new({
+    test => {
+        test => [
+            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+                value => 'Test'
+            }),
+    
+            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+                value => 'Test2'
+            })
+        ],
+    },    
+});
+
+is $nested->get_test->[0], $obj;
+
+$obj = MyType->new();
+isa_ok $obj, 'MyType';
+is $obj->get_test, undef, 'undefined element content';
+
+$obj->add_test(
+    SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'TestString0'})
+);
+
+is $obj->get_test, 'TestString0', 'added element content';
+
+for my $count (1..5) {
+    $obj->add_test(
+        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => "TestString$count" })
+    );
+
+    is ref $obj->get_test(), 'ARRAY', 'element content structure';
+    is @{ $obj->get_test() }, $count+1, "element list length: " . ($count + 1);
+
+    for my $index (0..$count-1) {
+        is $obj->get_test->[$index], "TestString$index", "element content [$index]";
+    }
+}
+
+# TODO - remove after *{ "$class\::$name"" } methods are gone
+
+$obj = MyType->new();
+
+isa_ok $obj, 'MyType';
+is $obj->get_test, undef;
+
+eval { my $foo = @{ $obj->get_test() } };
+like $@ , qr{Can't \s use \s an \s undefined}x, 'get_ELEMENT still undef on ARRAYIFY';
+
+$obj->test(
+    SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'TestString0'})
+);
+
+is $obj->get_test, 'TestString0';
+eval { is @{ $obj->get_test() }, 1, 'ARRAYIFY get_ELEMENT' };
+fail 'cannot ARRAYIFY get_ELEMENT' if ($@);
+
+my @serialized = (
+'<test >TestString0</test ><test >TestString1</test >',
+'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test >',
+'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test >',
+'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test ><test >TestString4</test >',
+'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test ><test >TestString4</test ><test >TestString5</test >',
+);
+
+for my $count (1..5) {
+    $obj->test(
+        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => "TestString$count" })
+    );
+
+    is ref $obj->get_test(), 'ARRAY';
+    is @{ $obj->get_test() }, $count+1;
+
+    for my $index (0..$count-1) {
+        is $obj->get_test->[$index], "TestString$index";
+    }
+    is $obj->serialize(), $serialized[$count -1];
+    
+}
+
+eval {
+    $obj = MyType->new({ 
+    test => [
+            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+                value => 'Test'
+            }),
+
+            \&CORE::die,
+        ],
+    });
+};
+like $@, qr{cannot \s use \s CODE}xms;
+
+eval {
+    $obj = MyType->new({ 
+    test => \&CORE::die,
+    });
+};
+like $@, qr{cannot \s use \s CODE}xms;
+
+
+eval { $obj->set_FOO(42) };
+like $@, qr{Can't \s locate \s object \s method}x;
+
+eval { MyType->set_FOO(42) };
+like $@, qr{Can't \s locate \s object \s method}x;
+
+eval { MyType->new({ FOO => 42 }) };
+like $@, qr{unknown \s field \s}xm;
+
+my $clone = Storable::thaw( Storable::freeze( $obj ));
+is $clone->get_test()->[0], 'TestString0';
+
+eval { SOAP::WSDL::XSD::Typelib::ComplexType::AUTOMETHOD() };
+like $@, qr{Cannot \s call}xm;
+
+
+eval { SOAP::WSDL::XSD::Typelib::ComplexType->_factory([], { test => {} }, {}) };
+like $@, qr{ No \s class \s given \s for \s }xms;
+
+eval { SOAP::WSDL::XSD::Typelib::ComplexType->_factory([], { test => {} }, { test => 'HopeItDoesntExistOnYourSystem'}) };
+like $@, qr{ Can't \s locate \s HopeItDoesntExistOnYourSystem.pm }xms;
+

t/SOAP/WSDL/XSD/Typelib/Element.t

@@ -0,0 +1,44 @@
+use strict;
+use warnings;
+
+package MyElement;
+use base qw(SOAP::WSDL::XSD::Typelib::Element
+    SOAP::WSDL::XSD::Typelib::Builtin::string
+);
+
+__PACKAGE__->__set_name('MyElement');
+__PACKAGE__->__set_nillable(1);
+
+package main;
+use Test::More tests => 11;
+
+my $obj;
+
+# All constructor variants
+$obj = MyElement->new();
+$obj = MyElement->new({});
+$obj = MyElement->new({ value => 'Test' });
+
+is( MyElement->__get_nillable(), 1);
+is $obj->__get_nillable, 1;
+isa_ok $obj, 'MyElement';
+is $obj->get_value(), 'Test';
+
+$obj->set_value(undef);
+is $obj, '<MyElement xsi:nil="true" xmlns="http://www.w3.org/2001/XMLSchema" />';
+
+$obj->__set_nillable(0);
+is $obj->__get_nillable(), 0;
+
+eval { SOAP::WSDL::XSD::Typelib::Element::__get_nillable() };
+like $@, qr{Cannot \s call}xms;
+eval { SOAP::WSDL::XSD::Typelib::Element::__set_nillable() };
+like $@, qr{Cannot \s call}xms;
+
+is $obj->start_tag({empty => 1}), '<MyElement />'; 
+is $obj->start_tag({nil => 1}), '', 'empty string with nil option and NILLABLE false';
+$obj->set_value('Test');
+
+
+eval { is @{ $obj }, 1, 'ARRAYIFY' };
+fail 'ARRAYIFY' if ($@);

t/acceptance/wsdl/generator_test.wsdl

@@ -182,6 +182,13 @@
 		        </xsd:restriction>
 		      </xsd:simpleType>
 		    </xsd:element>
+		    <xsd:element name="testAtomicSimpleTypeElement2" minOccurs="0">
+		      <xsd:simpleType>
+		        <xsd:restriction base="xsd:decimal">
+		          <xsd:minInclusive value="0"/>
+		        </xsd:restriction>
+		      </xsd:simpleType>
+		    </xsd:element>
 		  </xsd:sequence>
 		</xsd:complexType>