dinislage/SOAP-WSDL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

import SOAP-WSDL 2.00_13 from CPAN

Browse Source 
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
This commit is contained in:
Martin Kutter
2007-09-10 08:23:59 -08:00
committed by Michael G. Schwern
parent fd0854e34a
commit f63138fc87
181 changed files with 8714 additions and 8161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
t/002_parse_wsdl.t
View File

@@ -21,8 +21,8 @@ my $wsdl;
ok( $wsdl = $parser->get_data() , "get object tree");
my $types = $wsdl->first_types();
is $types->get_parent(), $wsdl , 'types parent';
is $types->get_parent(), $wsdl , 'types parent';
my $serializer_options = {
readable => 1,
@@ -187,6 +187,14 @@ sub xml
</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">

4
t/002_sax.t
View File

@@ -32,8 +32,8 @@ my $wsdl;
ok( $wsdl = $filter->get_data() , "get object tree");
my $types = $wsdl->first_types();
is $types->get_parent(), $wsdl , 'types parent';
is $types->get_parent(), $wsdl , 'types parent';
my $serializer_options = {
readable => 1,

1
t/003_wsdl_based_serializer.t
View File

@@ -1,5 +1,4 @@
use Test::More tests => 11;
use Data::Dumper;
use lib '../lib';
use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);

2
t/004_parse_wsdl.t
View File

@@ -57,7 +57,7 @@ my $data = { EnqueueMessage => {
}
};
SKIP: { skip_without_test_xml();
is_xml( $wsdl->find_message(

2
t/004_sax_wsdl.t
View File

@@ -67,7 +67,7 @@ my $data = { EnqueueMessage => {
}
};
SKIP: { skip_without_test_xml();
is_xml( $wsdl->find_message(

2
t/005_parse_contributed.t
View File

@@ -2,9 +2,7 @@
use strict;
use warnings;
use Test::More qw/no_plan/; # TODO: change to tests => N;
use Data::Dumper;
use lib '../lib';
use diagnostics;
use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);

2
t/005_sax_contributed_wsdl.t
View File

@@ -11,8 +11,6 @@ else {
plan skip_all => "Cannot test without XML::LibXML";
}
use diagnostics;
use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
my $filter;

4
t/006_client.t
View File

@@ -9,8 +9,6 @@ eval {
import Test::XML
};
use diagnostics;
use Cwd;
my $path = cwd;
@@ -41,7 +39,7 @@ SKIP: {
ok $pod->parse_string_document( $soap->explain() ), 'parse explain pod';
}
# print $output;
SKIP: {
skip_without_test_xml();
is_xml( $soap->call( 'EnqueueMessage' , EnqueueMessage => {

2
t/009_data_classes.t
View File

@@ -1,5 +1,5 @@
#!/usr/bin/perl -w
use strict;
use strict;
use warnings;
use Test::More tests => 5;
use lib 't/lib';

10
t/012_element.t
View File

@@ -7,7 +7,7 @@ use lib 't/lib';
use_ok qw(SOAP::WSDL::XSD::Typelib::Element);
use_ok qw( MyElement );
# simple type derived from builtin via restriction
my $obj = MyElement->new({ value => 'test'});
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
@@ -24,7 +24,7 @@ ok $obj->get_test->isa('SOAP::WSDL::XSD::Typelib::Builtin::string')
is $obj, '<MyAtomicComplexTypeElement xmlns="urn:Test" ><test >Test</test>'
. '<test2 >Test2</test2></MyAtomicComplexTypeElement>'
, 'stringification';
$obj = MyElement->new({ value => undef});
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
, 'inherited class';
@@ -39,10 +39,8 @@ is $obj, '<MyAtomicComplexTypeElement xmlns="urn:Test" ><test >Test</test>'
. '<test2 >Test3</test2>'
. '</MyAtomicComplexTypeElement>'
, 'multi value stringification';
use diagnostics;
ok $obj = MyComplexTypeElement->new({ MyTestName => 'test' });
ok $obj = MyComplexTypeElement->new({ MyTestName => 'test' });
is $obj, '<MyComplexTypeElement xmlns="urn:Test" ><MyTestName >test</MyTestName ></MyComplexTypeElement>';
__END__

46
t/014_sax_typelib.t
View File

@@ -35,43 +35,43 @@ else
{
pass("parsing XML");
}
my $TMessage;
my $wsdl;
ok( $wsdl = $filter->get_data() , "get object tree");
my %content;
my %content;
for my $element (@{ $wsdl->first_types()->get_schema()->[1]->get_type() } ) {
local $SIG{__WARN__} = sub {
like $_[0], qr{toClass \s is \s deprecated}xms, 'deprecated method warning';
local $SIG{__WARN__} = sub {
like $_[0], qr{toClass \s is \s deprecated}xms, 'deprecated method warning';
};
my $output;
$element->to_class({ prefix => 'MessageGateway::', wsdl => $wsdl,
output => \$output
});
# skip eval'ing TMessage - it requires evalling other
# types first
if ($element->get_name() =~ m{\A (TMessage|TEnqueueMessage) \Z}xmsg ) {
$content{$1} = $output;
next;
}
});
# skip eval'ing TMessage - it requires evalling other
# types first
if ($element->get_name() =~ m{\A (TMessage|TEnqueueMessage) \Z}xmsg ) {
$content{$1} = $output;
next;
}
my $name = 'MessageGateway::' . $element->get_name();
ok eval $output, $name
or die $@, $output;
or die $@, $output;
ok $name->can('serialize'), "$name\->can('serialize')";
}
while ( my ($name, $code) = (each %content) ) {
ok eval "$code", $name;
}
ok MessageGateway::TMessage->can('serialize'), 'MessageGateway::TMessage->can("serialize")';
while ( my ($name, $code) = (each %content) ) {
ok eval "$code", $name;
}
ok MessageGateway::TMessage->can('serialize'), 'MessageGateway::TMessage->can("serialize")';
ok MessageGateway::TEnqueueMessage->can('serialize'), "MessageGateway::TEnqueueMessage->can('serialize')";
sub xml {
return q{<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="MessageGateway"

24
t/016_client_object.t
View File

@@ -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 );
@@ -14,8 +14,8 @@ use_ok qw( SOAP::WSDL::Client );
my $obj = MyAtomicComplexTypeElement->new({ test=> 'Test', test2 => 'Test2'});
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
, 'inherited class';
# print $obj->get_test;
# print $obj->get_test;
ok $obj->get_test->isa('SOAP::WSDL::XSD::Typelib::Builtin::string')
, 'element isa';
@@ -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 }
. q{xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" }
. q{xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >}
. q{<SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >}
. q{<test >Test</test>}
. q{<test2 >Test2</test2>}
. q{</MyAtomicComplexTypeElement></SOAP-ENV:Body></SOAP-ENV:Envelope>}
, 'SOAP Envelope generation with objects';
# TODO: use Test::XML for testing and re-integrate
# is $soap->call('Test', $obj), q{<SOAP-ENV:Envelope }
# . q{xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" }
# . q{xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >}
# . q{<SOAP-ENV:Body><MyAtomicComplexTypeElement xmlns="urn:Test" >}
# . q{<test >Test</test>}
# . 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)

92
t/017_generator_expat.t
View File

@@ -3,31 +3,31 @@ 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;
use SOAP::WSDL::Expat::WSDLParser;
use SOAP::WSDL::Expat::MessageParser;
use File::Path;
use File::Basename;
my $path = dirname __FILE__;
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);
$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',
@@ -40,37 +40,37 @@ my $data = {
MKeepaliveErrorPolicy => ' ( suppress | report ) ',
}
}
};
ok Test::Element::EnqueueMessage->new( $data ) , '(generated) object constructor';
};
ok Test::Element::EnqueueMessage->new( $data ) , '(generated) object constructor';
my $message_parser = SOAP::WSDL::Expat::MessageParser->new({
class_resolver => 'Test::Typemap::MessageGateway'
});
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() ) };
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' , 6 if $@;
foreach my $module (Test::Pod::all_pod_files( "$path/testlib")) {
Test::Pod::pod_file_ok( $module )
}
}
# cleanup
rmtree "$path/testlib";
# print $wsdl->explain();
};
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

100
t/017_generator_libxml.t
View File

@@ -3,10 +3,10 @@ use strict;
use warnings;
use Test::More;
use lib '../lib';
use SOAP::WSDL::SAX::WSDLHandler;
use SOAP::WSDL::SAX::MessageHandler;
use File::Path;
use File::Basename;
use SOAP::WSDL::SAX::WSDLHandler;
use SOAP::WSDL::SAX::MessageHandler;
use File::Path;
use File::Basename;
if (eval "require XML::LibXML") {
plan tests => 18;
@@ -14,31 +14,31 @@ if (eval "require XML::LibXML") {
else {
plan skip_all => "Cannot test without XML::LibXML";
}
my $path = dirname __FILE__;
my $path = dirname __FILE__;
my $filter = SOAP::WSDL::SAX::WSDLHandler->new();
my $parser = XML::LibXML->new();
$parser->set_handler( $filter );
$parser->parse_string( xml() );
my $wsdl;
ok( $wsdl = $filter->get_data() , "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);
$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',
@@ -51,35 +51,35 @@ my $data = {
MKeepaliveErrorPolicy => ' ( suppress | report ) ',
}
}
};
ok Test::Element::EnqueueMessage->new( $data ) , '(generated) object constructor';
my $handler = SOAP::WSDL::SAX::MessageHandler->new({
class_resolver => 'Test::Typemap::MessageGateway'
});
};
ok Test::Element::EnqueueMessage->new( $data ) , '(generated) object constructor';
my $handler = SOAP::WSDL::SAX::MessageHandler->new({
class_resolver => 'Test::Typemap::MessageGateway'
});
$parser->set_handler( $handler );
TODO: {
local $TODO = 'support embedded atomic simpleType/complexType definitions';
eval { $parser->parse_string( xml_message() ) };
TODO: {
local $TODO = 'support embedded atomic simpleType/complexType definitions';
eval { $parser->parse_string( xml_message() ) };
ok ( !$@, 'parse XML message into object tree');
};
SKIP: {
eval "require Test::Pod";
skip 'Cannot test generated POD without Test::POD' , 6 if $@;
foreach my $module (Test::Pod::all_pod_files( "$path/testlib")) {
Test::Pod::pod_file_ok( $module )
}
}
# cleanup
rmtree "$path/testlib";
# print $wsdl->explain();
};
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

28
t/018_generator_expat.t
View File

@@ -3,25 +3,25 @@ use strict;
use warnings;
use Test::More tests => 12;
use lib '../lib';
use SOAP::WSDL::Expat::WSDLParser;
use File::Find;
use SOAP::WSDL::Expat::WSDLParser;
use File::Find;
use File::Basename;
my $path = dirname __FILE__;
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
$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,

34
t/018_generator_libxml.t
View File

@@ -3,10 +3,10 @@ use strict;
use warnings;
use Test::More;
use lib '../lib';
use SOAP::WSDL::SAX::WSDLHandler;
use SOAP::WSDL::SAX::MessageHandler;
use File::Path;
use File::Basename;
use SOAP::WSDL::SAX::WSDLHandler;
use SOAP::WSDL::SAX::MessageHandler;
use File::Path;
use File::Basename;
if (eval "require XML::LibXML") {
plan tests => 1;
@@ -14,23 +14,23 @@ if (eval "require XML::LibXML") {
else {
plan skip_all => "Cannot test without XML::LibXML";
}
my $path = dirname __FILE__;
my $path = dirname __FILE__;
my $filter = SOAP::WSDL::SAX::WSDLHandler->new();
my $parser = XML::LibXML->new();
$parser->set_handler( $filter );
$parser->parse_file( "$path/../example/wsdl/globalweather.xml" );
my $wsdl;
ok( $wsdl = $filter->get_data() , "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::",
});
$wsdl->create({
base_path => "$path/testlib",
typemap_prefix => "Test::Typemap::",
type_prefix => "Test::Type::",
element_prefix => "Test::Element::",
interface_prefix => "Test::Interface::",
});
rmtree "$path/testlib";

56
t/021_generator_element_ref_expat.t
View File

@@ -2,9 +2,9 @@
use strict;
use warnings;
use Test::More tests => 10;
use File::Path;
use File::Basename;
use lib '../lib';
use File::Path;
use File::Basename;
use lib '../lib';
use_ok(qw/SOAP::WSDL::Expat::WSDLParser/);
@@ -27,32 +27,32 @@ 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 $element = $definitions->first_types()->find_element('urn:Test', 'TestElement');
my $output = '';
ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$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');
ok eval $output, 'eval generated code';
$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' });
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';

80
t/021_generator_element_ref_libxml.t
View File

@@ -2,9 +2,9 @@
use strict;
use warnings;
use Test::More;
use File::Path;
use File::Basename;
use lib '../lib';
use File::Path;
use File::Basename;
use lib '../lib';
if (eval "require XML::LibXML") {
plan tests => 11;
@@ -12,9 +12,9 @@ if (eval "require XML::LibXML") {
else {
plan skip_all => "Cannot test without XML::LibXML";
}
my $path = dirname __FILE__;
my $path = dirname __FILE__;
use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
@@ -36,41 +36,41 @@ else
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 $element = $definitions->first_types()->find_element('urn:Test', 'TestElement');
my $output;
ok $element->to_class({ wsdl => $definitions, prefix => 'Test::', output => \$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');
ok eval $output, 'eval generated code';
$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' });
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';

36
t/098_pod.t
View File

@@ -1,19 +1,19 @@
use Test::More;
eval "use Test::Pod 1.00";
plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
# perl Build test or make test run from top-level dir.
if ( -d '../t/' ) {
@directories = ('../lib/');
}
else {
@directories = (); # empty - will work automatically
}
my @files = all_pod_files(@directories);
plan tests => scalar(@files);
foreach my $module (@files){
pod_file_ok( $module )
use Test::More;
eval "use Test::Pod 1.00";
plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
# perl Build test or make test run from top-level dir.
if ( -d '../t/' ) {
@directories = ('../lib/');
}
else {
@directories = (); # empty - will work automatically
}
my @files = all_pod_files(@directories);
plan tests => scalar(@files);
foreach my $module (@files){
pod_file_ok( $module )
}

670
t/Expat/02_sub_parser.t
View File

@@ -1,335 +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 ); }
};
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 ); }
};

20
t/Expat/03_wsdl.t
View File

@@ -33,15 +33,15 @@ 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 $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,
@@ -116,7 +116,7 @@ sub xml {
targetNamespace="http://www.example.org/MessageGateway2/">
<xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage"
xmlns:tns="http://www.example.org/MessageGateway2/"
xmlns:tns="http://www.example.org/MessageGateway2/"
>
<xsd:annotation>
<xsd:documentation>Enqueue message request element</xsd:documentation>

6
t/SOAP/WSDL/01_use.t
View File

@@ -1,4 +1,4 @@
use Test::More tests => 2;
use lib '../lib';
use_ok(qw/SOAP::WSDL/);
use Test::More tests => 2;
use lib '../lib';
use_ok(qw/SOAP::WSDL/);
ok( SOAP::WSDL->new(), 'Instantiated object' );

2
t/SOAP/WSDL/02_port.t
View File

@@ -28,7 +28,7 @@ ok( $soap = SOAP::WSDL->new(
ok( ($soap->servicename('testService') ), 'set service' );
ok( ($soap->portname('testPort2') ) ,'set portname');
ok( $soap->wsdlinit(), 'parsed WSDL' );
ok( $soap->wsdlinit(), 'parsed WSDL' );
ok( $soap->wsdlinit( servicename => 'testService', portname => 'testPort'), 'parsed WSDL' );

164
t/SOAP/WSDL/03_complexType-all.t
View File

@@ -1,83 +1,83 @@
use Test::More tests => 7;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. ";
}
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,
), 'Instantiated object' );
#3
ok $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parse WSDL';
ok $soap->no_dispatch(1), 'set no dispatch';
ok ($xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
), 'Serialized complexType' );
# print $xml;
# $soap->wsdl_checkoccurs(1);
TODO: {
local $TODO = "not implemented yet";
eval
{
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
}
);
};
ok($@, 'Died on illegal number of elements (not enough)');
use Test::More tests => 7;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. ";
}
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,
), 'Instantiated object' );
#3
ok $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parse WSDL';
ok $soap->no_dispatch(1), 'set no dispatch';
ok ($xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
), 'Serialized complexType' );
# print $xml;
# $soap->wsdl_checkoccurs(1);
TODO: {
local $TODO = "not implemented yet";
eval
{
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
}
);
};
ok($@, 'Died on illegal number of elements (not enough)');
}

22
t/SOAP/WSDL/03_complexType-choice.t
View File

@@ -1,12 +1,12 @@
use Test::More tests => 2;
use lib '../lib';
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <choice> support";
fail "serialize choice element";
use Test::More tests => 2;
use lib '../lib';
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <choice> support";
fail "serialize choice element";
}

42
t/SOAP/WSDL/03_complexType-complexContent.t
View File

@@ -1,22 +1,22 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <complexContent> support";
fail "serialize complexContent element";
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <complexContent> support";
fail "serialize complexContent element";
}

86
t/SOAP/WSDL/03_complexType-element-ref.t
View File

@@ -1,43 +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';
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';

42
t/SOAP/WSDL/03_complexType-group.t
View File

@@ -1,22 +1,22 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <group> support";
fail "serialize group element";
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <group> support";
fail "serialize group element";
}

148
t/SOAP/WSDL/03_complexType-sequence.t
View File

@@ -1,75 +1,75 @@
BEGIN {
use Test::More tests => 6;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. $@";
}
}
use_ok(qw/SOAP::WSDL/);
my $xml;
my $path = cwd();
my $name = basename $0;
$name =~s/\.t$//;
$path=~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
ok( $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => 'Test 2',
}
), 'Serialized complexType';
TODO: {
local $TODO = "not implemented yet";
#5
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
#6
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => [ 1, 2, 3, ]
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
BEGIN {
use Test::More tests => 6;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. $@";
}
}
use_ok(qw/SOAP::WSDL/);
my $xml;
my $path = cwd();
my $name = basename $0;
$name =~s/\.t$//;
$path=~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
ok( $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => 'Test 2',
}
), 'Serialized complexType';
TODO: {
local $TODO = "not implemented yet";
#5
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
#6
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => [ 1, 2, 3, ]
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
};

42
t/SOAP/WSDL/03_complexType-simpleContent.t
View File

@@ -1,22 +1,22 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <simpleContent> support";
fail "serialize simpleContent element";
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <simpleContent> support";
fail "serialize simpleContent element";
}

8
t/SOAP/WSDL/04_element-complexType.t
View File

@@ -1,4 +1,4 @@
use Test::More skip_all => 'TODO: implement tests';
use lib '../lib';
use Test::More skip_all => 'TODO: implement tests';
use lib '../lib';

100
t/SOAP/WSDL/04_element-simpleType.t
View File

@@ -1,50 +1,50 @@
use Test::More tests => 6;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
use_ok(qw/SOAP::WSDL/);
my $xml;
my $soap = undef;
my $name = basename $0;
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ( $xml = $soap->call('test', testElement1 => 1 ) ,
'Serialized (simpler) element' );
# print $xml, "\n";
TODO: {
local $TODO="implement min/maxOccurs checks";
eval { $soap->call('test', testAll => [ 2, 3 ] ); };
like $@, qr{illegal\snumber\sof\selements}, "Died on illegal number of elements (too many)";
eval { $soap->call('test', testAll => undef ) };
ok $@, 'Died on illegal number of elements (not enough)';
}
use Test::More tests => 6;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
use_ok(qw/SOAP::WSDL/);
my $xml;
my $soap = undef;
my $name = basename $0;
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ( $xml = $soap->call('test', testElement1 => 1 ) ,
'Serialized (simpler) element' );
# print $xml, "\n";
TODO: {
local $TODO="implement min/maxOccurs checks";
eval { $soap->call('test', testAll => [ 2, 3 ] ); };
like $@, qr{illegal\snumber\sof\selements}, "Died on illegal number of elements (too many)";
eval { $soap->call('test', testAll => undef ) };
ok $@, 'Died on illegal number of elements (not enough)';
}

140
t/SOAP/WSDL/04_element.t
View File

@@ -1,70 +1,70 @@
use Test::More tests => 8;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing.";
}
use_ok(qw/SOAP::WSDL/);
my $soap;
my $xml;
my $path = cwd();
my $name = basename $0;
$name =~s/\.t$//;
$path =~s{(/t)?/SOAP/WSDL}{}xsm;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ($xml = $soap->call('test',
testElement1 => 'Test'
), 'Serialized (simple) element' );
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>}
, 'element ref serialization result'
;
TODO: {
local $TODO="implement min/maxOccurs checks";
eval {
$xml = $soap->call('test',
testAll => [ 'Test 2', 'Test 3' ]
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test', testAll => undef );
};
ok($@, 'Died on illegal number of elements (not enough)');
}
use Test::More tests => 8;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing.";
}
use_ok(qw/SOAP::WSDL/);
my $soap;
my $xml;
my $path = cwd();
my $name = basename $0;
$name =~s/\.t$//;
$path =~s{(/t)?/SOAP/WSDL}{}xsm;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ($xml = $soap->call('test',
testElement1 => 'Test'
), 'Serialized (simple) element' );
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>}
, 'element ref serialization result'
;
TODO: {
local $TODO="implement min/maxOccurs checks";
eval {
$xml = $soap->call('test',
testAll => [ 'Test 2', 'Test 3' ]
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test', testAll => undef );
};
ok($@, 'Died on illegal number of elements (not enough)');
}

106
t/SOAP/WSDL/05_simpleType-list.t
View File

@@ -1,53 +1,53 @@
use Test::More tests => 8;
use strict;
use lib '../lib';
use lib 'lib';
use lib 't/lib';
use Cwd;
use File::Basename;
use_ok(qw/SOAP::WSDL/);
my ($soap, $xml, $xml2);
# chdir to my location
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
$soap->readable(1);
#3
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ), 'Serialize list call';
#5
ok ( $xml2 = $soap->call('test', testAll => "1 2" ) , 'Serialized scalar call' );
#6
ok( $xml eq $xml2, 'Got expected result');
#7
TODO: {
local $TODO = "implement minLength check";
eval { $xml = $soap->call('test', testAll => undef ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
#8
TODO: {
local $TODO = "maxLength test not implemented";
eval { $xml = $soap->call('test', testAll => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] ) };
ok($@, 'Died on illegal number of elements (more than maxLength)');
}
use Test::More tests => 8;
use strict;
use lib '../lib';
use lib 'lib';
use lib 't/lib';
use Cwd;
use File::Basename;
use_ok(qw/SOAP::WSDL/);
my ($soap, $xml, $xml2);
# chdir to my location
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)/SOAP/WSDL}{}xms;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
$soap->readable(1);
#3
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ), 'Serialize list call';
#5
ok ( $xml2 = $soap->call('test', testAll => "1 2" ) , 'Serialized scalar call' );
#6
ok( $xml eq $xml2, 'Got expected result');
#7
TODO: {
local $TODO = "implement minLength check";
eval { $xml = $soap->call('test', testAll => undef ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
#8
TODO: {
local $TODO = "maxLength test not implemented";
eval { $xml = $soap->call('test', testAll => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] ) };
ok($@, 'Died on illegal number of elements (more than maxLength)');
}

118
t/SOAP/WSDL/05_simpleType-restriction.t
View File

@@ -1,59 +1,59 @@
use Test::More tests => 8;
use strict;
use warnings;
use diagnostics;
use Cwd;
use File::Basename;
use lib '../lib';
use lib 'lib';
use lib 't/lib';
use_ok(qw/SOAP::WSDL/);
my $xml;
my $name = basename $0;
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)/SOAP/WSDL}{}xms;
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
$soap->autotype(0);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ) , 'Serialize list call';
# print $xml, "\n";
TODO: {
local $TODO = "implement minLength/maxLength checks";
eval { $soap->call('test', testAll => [ 1, 2, 3 ] ) };
ok($@, 'Died on illegal number of elements (too many)');
eval { $soap->call('test', testAll => [] ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
TODO: {
local $TODO = "minValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 0 ) };
ok($@, 'Died on illegal value');
}
TODO: {
local $TODO = "maxValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 100 ) };
ok($@, 'Died on illegal value');
}
use Test::More tests => 8;
use strict;
use warnings;
use diagnostics;
use Cwd;
use File::Basename;
use lib '../lib';
use lib 'lib';
use lib 't/lib';
use_ok(qw/SOAP::WSDL/);
my $xml;
my $name = basename $0;
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)/SOAP/WSDL}{}xms;
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
$soap->autotype(0);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ) , 'Serialize list call';
# print $xml, "\n";
TODO: {
local $TODO = "implement minLength/maxLength checks";
eval { $soap->call('test', testAll => [ 1, 2, 3 ] ) };
ok($@, 'Died on illegal number of elements (too many)');
eval { $soap->call('test', testAll => [] ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
TODO: {
local $TODO = "minValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 0 ) };
ok($@, 'Died on illegal value');
}
TODO: {
local $TODO = "maxValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 100 ) };
ok($@, 'Died on illegal value');
}

132
t/SOAP/WSDL/05_simpleType-union.t
View File

@@ -1,66 +1,66 @@
use Test::More skip_all => 'Not supported yet';
use strict;
use warnings;
use Cwd;
use File::Basename;
use lib '../lib';
use_ok qw/SOAP::WSDL/;
my $xml;
my $soap = undef;
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object';
#3
$soap->readable(1);
ok $soap->wsdlinit(), 'parsed WSDL';
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test', testAll => 1 ) , 'Serialized call';
# 6
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => undef
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
#8
ok ( $xml = $soap->serializer->method( $soap->call('test2',
testAll => 1 )
),
'Serialized (simple) call (list)' );
#9
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
use Test::More skip_all => 'Not supported yet';
use strict;
use warnings;
use Cwd;
use File::Basename;
use lib '../lib';
use_ok qw/SOAP::WSDL/;
my $xml;
my $soap = undef;
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
#2
ok $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/' . $name . '.wsdl'
), 'Instantiated object';
#3
$soap->readable(1);
ok $soap->wsdlinit(), 'parsed WSDL';
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test', testAll => 1 ) , 'Serialized call';
# 6
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => undef
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
#8
ok ( $xml = $soap->serializer->method( $soap->call('test2',
testAll => 1 )
),
'Serialized (simple) call (list)' );
#9
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');

108
t/SOAP/WSDL/11_helloworld.NET.t
View File

@@ -1,54 +1,54 @@
#!/usr/bin/perl -w
#######################################################################################
#
# 2_helloworld.t
#
# Acceptance test for message encoding, based on .NET wsdl and example code.
# SOAP::WSDL's encoding doesn't I<exactly> match the .NET example, because
# .NET doesn't always specify types (SOAP::WSDL does), and the namespace
# prefixes chosen are different (maybe the encoding style, too ? this would be a bug !)
#
########################################################################################
use strict;
use Test::More tests => 4;
use lib '../..';
use Cwd;
use File::Basename;
use_ok q/SOAP::WSDL/;
### test vars END
print "# Testing SOAP::WSDL ". $SOAP::WSDL::VERSION."\n";
print "# Acceptance test against sample output with simple WSDL\n";
my $data = {
name => 'test',
givenName => 'test',
};
my $soap = undef;
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
ok $soap = SOAP::WSDL->new(
wsdl => 'file:///'.$path.'/t/acceptance/wsdl/11_helloworld.wsdl',
no_dispatch => 1
), 'Create SOAP::WSDL object';
$soap->proxy('http://helloworld/helloworld.asmx');
ok $soap->wsdlinit(
servicename => 'Service1',
), 'wsdlinit';
ok $soap->call('sayHello', 'sayHello' => $data), 'soap call';
#!/usr/bin/perl -w
#######################################################################################
#
# 2_helloworld.t
#
# Acceptance test for message encoding, based on .NET wsdl and example code.
# SOAP::WSDL's encoding doesn't I<exactly> match the .NET example, because
# .NET doesn't always specify types (SOAP::WSDL does), and the namespace
# prefixes chosen are different (maybe the encoding style, too ? this would be a bug !)
#
########################################################################################
use strict;
use Test::More tests => 4;
use lib '../../../lib/';
use Cwd;
use File::Basename;
use_ok q/SOAP::WSDL/;
### test vars END
print "# Testing SOAP::WSDL ". $SOAP::WSDL::VERSION."\n";
print "# Acceptance test against sample output with simple WSDL\n";
my $data = {
name => 'test',
givenName => 'test',
};
my $soap = undef;
my $name = basename( $0 );
$name =~s/\.(t|pl)$//;
my $path = cwd;
$path =~s{(/t)?/SOAP/WSDL}{}xms;
ok $soap = SOAP::WSDL->new(
wsdl => 'file:///'.$path.'/t/acceptance/wsdl/11_helloworld.wsdl',
no_dispatch => 1
), 'Create SOAP::WSDL object';
$soap->proxy('http://helloworld/helloworld.asmx');
ok $soap->wsdlinit(
servicename => 'Service1',
), 'wsdlinit';
ok $soap->call('sayHello', 'sayHello' => $data), 'soap call';

36
t/SOAP/WSDL/XSD/Typelib/Builtin/001_string.t
View File

@@ -1,19 +1,19 @@
use Test::More tests => 4;
use strict;
use warnings;
use lib '../lib';
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::string');
my $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new();
$obj->set_value( '& "Aber" <test>');
is $obj->get_value() , '& "Aber" <test>';
is $obj, '&amp; &qout;Aber&qout; &lt;test&gt;'
, 'escape text on serialization';
is $obj->serialize({ name => 'test'})
, '<test >&amp; &qout;Aber&qout; &lt;test&gt;</test >'
use Test::More tests => 4;
use strict;
use warnings;
use lib '../lib';
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::string');
my $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new();
$obj->set_value( '& "Aber" <test>');
is $obj->get_value() , '& "Aber" <test>';
is $obj, '&amp; &qout;Aber&qout; &lt;test&gt;'
, 'escape text on serialization';
is $obj->serialize({ name => 'test'})
, '<test >&amp; &qout;Aber&qout; &lt;test&gt;</test >'
, 'Serialization with name';

2
t/SOAP/WSDL/XSD/Typelib/Builtin/002_dateTime.t
View File

@@ -12,7 +12,7 @@ sub timezone {
return $tz;
}
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::dateTime');
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::dateTime');
print "# timezone is " . timezone( scalar localtime(time) ) . "\n";
my $obj;

54
t/SOAP/WSDL/XSD/Typelib/Builtin/003_date.t
View File

@@ -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');
is $obj->get_value() , '2007-12-31+01:00', 'conversion from XML dateTime';
$obj->set_value( '2037-12-31' );
is $obj->get_value() , '2037-12-31', 'no conversion on match';
$obj->set_value( '2037-12-31+12:00' );
is $obj->get_value() , '2037-12-31+12:00', 'no conversion on match';

25
t/SOAP/WSDL/XSD/Typelib/Builtin/004_time.t Normal file
View File

@@ -0,0 +1,25 @@
use Test::More tests => 3;
use strict;
use warnings;
use lib '../lib';
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::time');
my $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new();
$obj->set_value( '12:23:03' );
is $obj->get_value() , '12:23:03+01:00', 'conversion';
$obj->set_value( '12:23:03.12345+01:00' ), ;
is $obj->get_value() , '12:23:03.12345+01:00', 'no conversion';
# 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') },
#~ }

220
t/acceptance/wsdl/02_port.wsdl
View File

@@ -1,110 +1,110 @@
<?xml version="1.0"?>
<definitions name="urn:simpleType"
targetNamespace="urn:simpleType"
xmlns:tns="urn:simpleType"
xmlns:wsd="http://www.w3c.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
>
<types>
<xsd:schema targetNamespace="simpleType">
<xsd:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType Test
</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="int">
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="test" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<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>
</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">
<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:testPort3" name="testBinding3">
<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>
</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>
<port name="testPort3" binding="tns:testBinding3">
<soap:address location="http://127.0.0.1/testPort3" />
</port>
</service>
</definitions>
<?xml version="1.0"?>
<definitions name="urn:simpleType"
targetNamespace="urn:simpleType"
xmlns:tns="urn:simpleType"
xmlns:xsd="http://www.w3c.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
>
<types>
<xsd:schema targetNamespace="simpleType">
<xsd:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType Test
</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="int">
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="test" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<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>
</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">
<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:testPort3" name="testBinding3">
<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>
</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>
<port name="testPort3" binding="tns:testBinding3">
<soap:address location="http://127.0.0.1/testPort3" />
</port>
</service>
</definitions>

2
t/acceptance/wsdl/03_complexType-element-ref.wsdl
View File

@@ -5,7 +5,7 @@
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
<types>
<xsd:schema targetNamespace="urn:Test">
<xsd:element name="TestElement" type="xsd:string" />
<xsd:element name="TestElement" type="xsd:string" />
<xsd:element name="TestRef" ref="tns:TestElement" />
<xsd:complexType name="testComplexTypeRef">
<xsd:annotation>

16
t/acceptance/wsdl/03_complexType-sequence.wsdl
View File

@@ -58,8 +58,8 @@
</operation>
</portType>
<binding type="tns:testPort" name="testBinding">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<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>
@@ -68,12 +68,12 @@
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
</soap:operation>
</operation>
</binding>
<binding type="tns:testPort2" name="testBinding2">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="test">
<operation name="test">
<soap:operation soapAction="test">
<input>
<soap:body use="literal"/>
@@ -81,12 +81,12 @@
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
</soap:operation>
</operation>
</binding>
<binding type="tns:testPort3" name="testBinding3">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="test">
<soap:operation soapAction="test">
<input>
@@ -96,7 +96,7 @@
<soap:body use="literal"/>
</output>
</soap:operation>
</operation>
</operation>
</binding>
<service name="testService">
<port name="testPort" binding="tns:testBinding">

116
t/acceptance/wsdl/04_element-simpleType.wsdl
View File

@@ -1,58 +1,58 @@
<?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="testElement1">
<xsd:simpleType>
<xsd:annotation>
<xsd:documentation> SimpleType: Integer between 1 and 9
(Inclusive constraints) </xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:int" minInclusive="1"
maxInclusive="9"/>
</xsd:simpleType>
</xsd:element>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" element="tns:testElement1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testElement1"/>
</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">
<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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>
<?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="testElement1">
<xsd:simpleType>
<xsd:annotation>
<xsd:documentation> SimpleType: Integer between 1 and 9
(Inclusive constraints) </xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:int" minInclusive="1"
maxInclusive="9"/>
</xsd:simpleType>
</xsd:element>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" element="tns:testElement1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testElement1"/>
</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">
<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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>

100
t/acceptance/wsdl/04_element.wsdl
View File

@@ -1,37 +1,37 @@
<?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="testElement1" type="xsd:string" />
<?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="testElement1" type="xsd:string" />
<xsd:element name="testElement2" type="xsd:int" />
<xsd:element name="testElementRef" ref="tns:testElement1" />
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" element="tns:testElement1"/>
</message>
<xsd:element name="testElementRef" ref="tns:testElement1" />
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" element="tns:testElement1"/>
</message>
<message name="testRefRequest">
<part name="testAll" element="tns:testElementRef"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testElement1"/>
</message>
<portType name="testPort">
<operation name="test">
<documentation>
Test-Methode
</documentation>
<input message="tns:testRequest"/>
<output message="tns:testResponse"/>
</operation>
<message name="testResponse">
<part name="testAll" type="tns:testElement1"/>
</message>
<portType name="testPort">
<operation name="test">
<documentation>
Test-Methode
</documentation>
<input message="tns:testRequest"/>
<output message="tns:testResponse"/>
</operation>
<operation name="testRef">
<documentation>
Test-Methode
@@ -40,19 +40,19 @@
<input message="tns:testRefRequest"/>
<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>
</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>
<operation name="testRef">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
@@ -64,11 +64,11 @@
<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>
</operation>
</binding>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>

140
t/acceptance/wsdl/05_simpleType-list.wsdl
View File

@@ -1,70 +1,70 @@
<?xml version="1.0"?>
<definitions name="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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer (length 2-4)
</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="xsd:int">
<xsd:minLength value="2"/>
<xsd:maxLength value="4"/>
</xsd:list>
</xsd:simpleType>
<xsd:simpleType name="testSimpleType1" itemType="xsd:string">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer (length 2)
</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="xsd:int">
<xsd:length value="2"/>
</xsd:list>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType1"/>
</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">
<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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>
<?xml version="1.0"?>
<definitions name="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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer (length 2-4)
</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="xsd:int">
<xsd:minLength value="2"/>
<xsd:maxLength value="4"/>
</xsd:list>
</xsd:simpleType>
<xsd:simpleType name="testSimpleType1" itemType="xsd:string">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer (length 2)
</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="xsd:int">
<xsd:length value="2"/>
</xsd:list>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType1"/>
</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">
<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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>

118
t/acceptance/wsdl/05_simpleType-restriction.wsdl
View File

@@ -1,59 +1,59 @@
<?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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: Integer between 1 and 9 (Exclusive constrains)
</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:int">
<xsd:minExclusive value="0"/>
<xsd:maxExclusive value="10"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<portType name="testPort">
<operation name="test">
<documentation>
Test-Methode
</documentation>
<input message="tns:testRequest"/>
<output message="tnstestResponse"/>
</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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>
<?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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: Integer between 1 and 9 (Exclusive constrains)
</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:int">
<xsd:minExclusive value="0"/>
<xsd:maxExclusive value="10"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<portType name="testPort">
<operation name="test">
<documentation>
Test-Methode
</documentation>
<input message="tns:testRequest"/>
<output message="tnstestResponse"/>
</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>
<service name="testService">
<port name="testPort" binding="tns:testBinding">
<soap:address location="http://127.0.0.1/testPort" />
</port>
</service>
</definitions>

206
t/acceptance/wsdl/05_simpleType-union.wsdl
View File

@@ -1,103 +1,103 @@
<?xml version="1.0"?>
<definitions name="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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer and a string
</xsd:documentation>
</xsd:annotation>
<xsd:union memberTypes="xsd:int xsd:string"/>
</xsd:simpleType>
<xsd:simpleType name="testSimpleType2">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer and a string
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:int">
<xsd:minInclusive value="1"/>
<xsd:maxInclusive value="3"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="union"/>
<xsd:enumeration value="test"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType1"/>
</message>
<message name="testRequest2">
<part name="testAll" type="tns:testSimpleType2"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType2"/>
</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>
<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>
<operation name="test2">
<soap:operation soapAction="test2">
<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>
<?xml version="1.0"?>
<definitions name="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:simpleType name="testSimpleType1">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer and a string
</xsd:documentation>
</xsd:annotation>
<xsd:union memberTypes="xsd:int xsd:string"/>
</xsd:simpleType>
<xsd:simpleType name="testSimpleType2">
<xsd:annotation>
<xsd:documentation>
SimpleType: List with an integer and a string
</xsd:documentation>
</xsd:annotation>
<xsd:union>
<xsd:simpleType>
<xsd:restriction base="xsd:int">
<xsd:minInclusive value="1"/>
<xsd:maxInclusive value="3"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="union"/>
<xsd:enumeration value="test"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
</xsd:schema>
</types>
<message name="testRequest">
<part name="testAll" type="tns:testSimpleType1"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType1"/>
</message>
<message name="testRequest2">
<part name="testAll" type="tns:testSimpleType2"/>
</message>
<message name="testResponse">
<part name="testAll" type="tns:testComplexType2"/>
</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>
<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>
<operation name="test2">
<soap:operation soapAction="test2">
<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>

150
t/acceptance/wsdl/10_helloworld.asmx.xml
View File

@@ -1,75 +1,75 @@
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:s="http://www.w3.org/2001/XMLSchema"
xmlns:s0="urn:HelloWorld"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
targetNamespace="urn:HelloWorld"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<types>
<s:schema elementFormDefault="qualified"
targetNamespace="urn:HelloWorld">
<s:element name="sayHello">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
<s:element name="sayHelloResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1"
name="sayHelloResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
</s:schema>
</types>
<message name="sayHelloSoapIn">
<part name="parameters" element="s0:sayHello" />
</message>
<message name="sayHelloSoapOut">
<part name="parameters" element="s0:sayHelloResponse" />
</message>
<portType name="Service1Soap">
<operation name="sayHello">
<input message="s0:sayHelloSoapIn" />
<output message="s0:sayHelloSoapOut" />
</operation>
</portType>
<binding name="Service1Soap" type="s0:Service1Soap">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<operation name="sayHello">
<soap:operation soapAction="urn:HelloWorld#sayHello"
style="document" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
<service name="Service1">
<port name="Service1Soap" binding="s0:Service1Soap">
<soap:address
location="http://helloworld/helloworld.asmx" />
</port>
</service>
</definitions>
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:s="http://www.w3.org/2001/XMLSchema"
xmlns:s0="urn:HelloWorld"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
targetNamespace="urn:HelloWorld"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<types>
<s:schema elementFormDefault="qualified"
targetNamespace="urn:HelloWorld">
<s:element name="sayHello">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
<s:element name="sayHelloResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1"
name="sayHelloResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
</s:schema>
</types>
<message name="sayHelloSoapIn">
<part name="parameters" element="s0:sayHello" />
</message>
<message name="sayHelloSoapOut">
<part name="parameters" element="s0:sayHelloResponse" />
</message>
<portType name="Service1Soap">
<operation name="sayHello">
<input message="s0:sayHelloSoapIn" />
<output message="s0:sayHelloSoapOut" />
</operation>
</portType>
<binding name="Service1Soap" type="s0:Service1Soap">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<operation name="sayHello">
<soap:operation soapAction="urn:HelloWorld#sayHello"
style="document" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
<service name="Service1">
<port name="Service1Soap" binding="s0:Service1Soap">
<soap:address
location="http://helloworld/helloworld.asmx" />
</port>
</service>
</definitions>

210
t/acceptance/wsdl/11_helloworld.wsdl
View File

@@ -1,105 +1,105 @@
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:s="http://www.w3.org/2001/XMLSchema"
xmlns:s0="urn:HelloWorld"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
targetNamespace="urn:HelloWorld"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<types>
<s:schema elementFormDefault="qualified"
targetNamespace="urn:HelloWorld">
<s:element name="sayHello">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" nillable="1"/>
<!-- <s:element minOccurs="0" maxOccurs="1" name="test"
type="s0:test2" /> //-->
</s:sequence>
</s:complexType>
</s:element>
<s:element name="sayHelloResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1"
name="sayHelloResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
<s:complexType name="test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" />
</s:sequence>
</s:complexType>
<s:complexType name="testExtended">
<s:extension base="s0:test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="extend"
type="s:string" />
</s:sequence>
</s:extension>
</s:complexType>
</s:schema>
</types>
<message name="sayHelloSoapIn">
<part name="parameters" element="s0:sayHello" />
<!-- <part name="test1" type="s0:testExtended" />
<part name="test2" type="s0:test2"
targetNamespace="urn:test2" /> //-->
</message>
<message name="sayHelloSoapOut">
<part name="parameters" element="s0:sayHelloResponse" />
</message>
<portType name="Service1Soap">
<operation name="sayHello">
<input message="s0:sayHelloSoapIn" />
<output message="s0:sayHelloSoapOut" />
</operation>
</portType>
<binding name="Service1Soap" type="s0:Service1Soap">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<operation name="sayHello">
<soap:operation soapAction="urn:HelloWorld#sayHello"
style="document" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
<service name="Service1">
<port name="Service1Soap" binding="s0:Service1Soap">
<soap:address
location="http://helloworld/helloworld.asmx" />
</port>
</service>
</definitions>
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:s="http://www.w3.org/2001/XMLSchema"
xmlns:s0="urn:HelloWorld"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
targetNamespace="urn:HelloWorld"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<types>
<s:schema elementFormDefault="qualified"
targetNamespace="urn:HelloWorld">
<s:element name="sayHello">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" nillable="1"/>
<!-- <s:element minOccurs="0" maxOccurs="1" name="test"
type="s0:test2" /> //-->
</s:sequence>
</s:complexType>
</s:element>
<s:element name="sayHelloResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1"
name="sayHelloResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
<s:complexType name="test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" />
</s:sequence>
</s:complexType>
<s:complexType name="testExtended">
<s:extension base="s0:test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="extend"
type="s:string" />
</s:sequence>
</s:extension>
</s:complexType>
</s:schema>
</types>
<message name="sayHelloSoapIn">
<part name="parameters" element="s0:sayHello" />
<!-- <part name="test1" type="s0:testExtended" />
<part name="test2" type="s0:test2"
targetNamespace="urn:test2" /> //-->
</message>
<message name="sayHelloSoapOut">
<part name="parameters" element="s0:sayHelloResponse" />
</message>
<portType name="Service1Soap">
<operation name="sayHello">
<input message="s0:sayHelloSoapIn" />
<output message="s0:sayHelloSoapOut" />
</operation>
</portType>
<binding name="Service1Soap" type="s0:Service1Soap">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<operation name="sayHello">
<soap:operation soapAction="urn:HelloWorld#sayHello"
style="document" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
<service name="Service1">
<port name="Service1Soap" binding="s0:Service1Soap">
<soap:address
location="http://helloworld/helloworld.asmx" />
</port>
</service>
</definitions>

134
t/acceptance/wsdl/contributed/Axis.wsdl
View File

@@ -1,81 +1,81 @@
<?xml version="1.0" encoding="UTF-8"?>
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://order.soap.services"
xmlns:impl="http://order.soap.services" xmlns:intf="http://order.soap.services"
xmlns:apachesoap="http://xml.apache.org/xml-soap"
xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns1="http://database.services"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
<!--WSDL created by Apache Axis version: 1.2RC3
Built on Feb 28, 2005 (10:15:14 EST)-->
<wsdl:types>
Built on Feb 28, 2005 (10:15:14 EST)-->
<wsdl:types>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://database.services">
<import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
<complexType name="ProcedureResponse">
<sequence>
<element name="message" nillable="true" type="soapenc:string" />
<element name="status" type="xsd:int" />
</sequence>
</complexType>
</schema>
</wsdl:types>
<wsdl:message name="confirmRequest">
<wsdl:part name="language_id" type="soapenc:string" />
<wsdl:part name="user_id" type="soapenc:string" />
<wsdl:part name="supplier_code" type="soapenc:string" />
<wsdl:part name="customer_no" type="soapenc:string" />
<wsdl:part name="author" type="soapenc:string" />
<wsdl:part name="title" type="soapenc:string" />
<wsdl:part name="isbn" type="soapenc:string" />
<wsdl:part name="classification" type="soapenc:string" />
<wsdl:part name="purchase_note" type="soapenc:string" />
<wsdl:part name="article_no" type="soapenc:string" />
<wsdl:part name="price" type="xsd:double" />
<wsdl:part name="currency_id" type="soapenc:string" />
<wsdl:part name="delivery_date" type="xsd:dateTime" />
<wsdl:part name="info_note" type="soapenc:string" />
<wsdl:part name="no_of_copies" type="xsd:int" />
<wsdl:part name="order_no" type="soapenc:string" />
<wsdl:part name="order_date" type="xsd:dateTime" />
<wsdl:part name="title_no" type="soapenc:string" />
</wsdl:message>
targetNamespace="http://database.services">
<import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
<complexType name="ProcedureResponse">
<sequence>
<element name="message" nillable="true" type="soapenc:string" />
<element name="status" type="xsd:int" />
</sequence>
</complexType>
</schema>
</wsdl:types>
<wsdl:message name="confirmResponse">
<wsdl:part name="confirmReturn" type="tns1:ProcedureResponse" />
</wsdl:message>
<wsdl:portType name="OrderImpl">
<wsdl:message name="confirmRequest">
<wsdl:part name="language_id" type="soapenc:string" />
<wsdl:part name="user_id" type="soapenc:string" />
<wsdl:part name="supplier_code" type="soapenc:string" />
<wsdl:part name="customer_no" type="soapenc:string" />
<wsdl:part name="author" type="soapenc:string" />
<wsdl:part name="title" type="soapenc:string" />
<wsdl:part name="isbn" type="soapenc:string" />
<wsdl:part name="classification" type="soapenc:string" />
<wsdl:part name="purchase_note" type="soapenc:string" />
<wsdl:part name="article_no" type="soapenc:string" />
<wsdl:part name="price" type="xsd:double" />
<wsdl:part name="currency_id" type="soapenc:string" />
<wsdl:part name="delivery_date" type="xsd:dateTime" />
<wsdl:part name="info_note" type="soapenc:string" />
<wsdl:part name="no_of_copies" type="xsd:int" />
<wsdl:part name="order_no" type="soapenc:string" />
<wsdl:part name="order_date" type="xsd:dateTime" />
<wsdl:part name="title_no" type="soapenc:string" />
</wsdl:message>
<wsdl:message name="confirmResponse">
<wsdl:part name="confirmReturn" type="tns1:ProcedureResponse" />
</wsdl:message>
<wsdl:portType name="OrderImpl">
<wsdl:operation name="confirm"
parameterOrder="language_id user_id supplier_code customer_no author title isbn classification purchase_note article_no price currency_id delivery_date info_note no_of_copies order_no order_date title_no">
<wsdl:input name="confirmRequest" message="impl:confirmRequest" />
<wsdl:output name="confirmResponse" message="impl:confirmResponse" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="OrderSoapBinding" type="impl:OrderImpl">
<wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="confirm">
<wsdlsoap:operation soapAction="" />
<wsdl:input name="confirmRequest">
parameterOrder="language_id user_id supplier_code customer_no author title isbn classification purchase_note article_no price currency_id delivery_date info_note no_of_copies order_no order_date title_no">
<wsdl:input name="confirmRequest" message="impl:confirmRequest" />
<wsdl:output name="confirmResponse" message="impl:confirmResponse" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="OrderSoapBinding" type="impl:OrderImpl">
<wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="confirm">
<wsdlsoap:operation soapAction="" />
<wsdl:input name="confirmRequest">
<wsdlsoap:body use="encoded"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="http://order.soap.services" />
</wsdl:input>
<wsdl:output name="confirmResponse">
namespace="http://order.soap.services" />
</wsdl:input>
<wsdl:output name="confirmResponse">
<wsdlsoap:body use="encoded"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="http://order.soap.services" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="OrderImplService">
<wsdl:port name="Order" binding="impl:OrderSoapBinding">
<wsdlsoap:address location="http://example.com/services/services/Order" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
namespace="http://order.soap.services" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="OrderImplService">
<wsdl:port name="Order" binding="impl:OrderSoapBinding">
<wsdlsoap:address location="http://example.com/services/services/Order" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

314
t/acceptance/wsdl/contributed/ETest.wsdl
View File

@@ -1,4 +1,4 @@
<?xml version="1.0" encoding="UTF-8"?>
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://example.com/soap/services/ETest"
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:apachesoap="http://xml.apache.org/xml-soap"
@@ -10,193 +10,193 @@
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" />
<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" />
</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" />
</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>
</complexType>
<complexType name="EProductInformation">
<sequence>
<element name="acquisitions" nillable="true"
type="impl:ArrayOf_tns2_AcquisitionData" />
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" />
</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" />
</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" />
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" />
type="xsd:string" />
<element name="renewallOrCancellationNoteForILS" nillable="true"
type="xsd:string" />
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" />
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>
<schema targetNamespace="http://example.com/soap/services/ETest"
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">
<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: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">
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://ETest.webservice.api.verde.exlibris.com" use="encoded" />
</wsdl:input>
<wsdl:output name="getETestResponse">
namespace="http://ETest.webservice.api.verde.exlibris.com" 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">
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://ETest.webservice.api.verde.exlibris.com" use="encoded" />
</wsdl:input>
<wsdl:output name="getFixedETestResponse">
namespace="http://ETest.webservice.api.verde.exlibris.com" 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>
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>

302
t/acceptance/wsdl/contributed/OITest.wsdl
View File

@@ -4,157 +4,157 @@
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://example.com/OITest/ws/">
<wsdl:types>
targetNamespace="http://example.com/OITest/ws/">
<wsdl:types>
<xsi:schema targetNamespace="http://example.com/OITest/ws/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema"
xmlns="http://example.com/OITest/ws/" elementFormDefault="unqualified"
attributeFormDefault="unqualified">
</xsi:schema>
</wsdl:types>
<wsdl:message name="AvailableToSellRequest">
<wsdl:part name="atsInquiry" element="oi:atsInquiry" />
</wsdl:message>
<wsdl:message name="AvailableToSellResponse">
<wsdl:part name="availableToSell" element="oi:availableToSell" />
</wsdl:message>
<wsdl:message name="POResponse">
<wsdl:part name="acknowledgement" element="oi:acknowledgement" />
</wsdl:message>
<wsdl:message name="OITestWebServicesFault">
<wsdl:part name="OITestFault" element="oi:OITestFault" />
</wsdl:message>
<wsdl:message name="CatalogRequest">
<wsdl:part name="catalogRequest" element="oi:catalogRequest" />
</wsdl:message>
<wsdl:message name="CatalogReponse">
<wsdl:part name="catalog" element="oi:catalog" />
</wsdl:message>
<wsdl:message name="CatalogListRequest">
<wsdl:part name="catalogListInfo" element="oi:catalogListRequest" />
</wsdl:message>
<wsdl:message name="CatalogListResponse">
<wsdl:part name="catalogList" element="oi:catalogList" />
</wsdl:message>
<wsdl:message name="POSubmitRequest">
<wsdl:part name="submitPO" element="oi:submitPO" />
</wsdl:message>
<wsdl:message name="POCancelRequest">
<wsdl:part name="cancelPO" element="oi:cancelPO" />
</wsdl:message>
<wsdl:message name="POChangeRequest">
<wsdl:part name="changePO" element="oi:changePO" />
</wsdl:message>
<wsdl:portType name="OITestPort">
<wsdl:operation name="ATSCheck">
<wsdl:input message="ws:AvailableToSellRequest" />
<wsdl:output message="ws:AvailableToSellResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POSubmit">
<wsdl:input message="ws:POSubmitRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POCancel">
<wsdl:input message="ws:POCancelRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POChange">
<wsdl:input message="ws:POChangeRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="CatalogRequest">
<wsdl:input message="ws:CatalogRequest" />
<wsdl:output message="ws:CatalogReponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="CatalogListRequest">
<wsdl:input message="ws:CatalogListRequest" />
<wsdl:output message="ws:CatalogListResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="OITestBinding" type="ws:OITestPort">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="ATSCheck">
<soap:operation soapAction="http://example.com/OITest/ATSCheck" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POSubmit">
<soap:operation soapAction="http://example.com/OITest/POSubmit" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POCancel">
<soap:operation soapAction="http://example.com/OITest/POCancel" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POChange">
<soap:operation soapAction="http://example.com/OITest/POChange" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="CatalogRequest">
<soap:operation soapAction="http://example.com/OITest/CatalogRequest" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="CatalogListRequest">
<soap:operation soapAction="http://example.com/OITest/CatalogListRequest" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="OITestService">
<wsdl:port name="OITestService" binding="ws:OITestBinding">
<soap:address location="http://localhost:8080/ws/services/OITestService" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
attributeFormDefault="unqualified">
</xsi:schema>
</wsdl:types>
<wsdl:message name="AvailableToSellRequest">
<wsdl:part name="atsInquiry" element="oi:atsInquiry" />
</wsdl:message>
<wsdl:message name="AvailableToSellResponse">
<wsdl:part name="availableToSell" element="oi:availableToSell" />
</wsdl:message>
<wsdl:message name="POResponse">
<wsdl:part name="acknowledgement" element="oi:acknowledgement" />
</wsdl:message>
<wsdl:message name="OITestWebServicesFault">
<wsdl:part name="OITestFault" element="oi:OITestFault" />
</wsdl:message>
<wsdl:message name="CatalogRequest">
<wsdl:part name="catalogRequest" element="oi:catalogRequest" />
</wsdl:message>
<wsdl:message name="CatalogReponse">
<wsdl:part name="catalog" element="oi:catalog" />
</wsdl:message>
<wsdl:message name="CatalogListRequest">
<wsdl:part name="catalogListInfo" element="oi:catalogListRequest" />
</wsdl:message>
<wsdl:message name="CatalogListResponse">
<wsdl:part name="catalogList" element="oi:catalogList" />
</wsdl:message>
<wsdl:message name="POSubmitRequest">
<wsdl:part name="submitPO" element="oi:submitPO" />
</wsdl:message>
<wsdl:message name="POCancelRequest">
<wsdl:part name="cancelPO" element="oi:cancelPO" />
</wsdl:message>
<wsdl:message name="POChangeRequest">
<wsdl:part name="changePO" element="oi:changePO" />
</wsdl:message>
<wsdl:portType name="OITestPort">
<wsdl:operation name="ATSCheck">
<wsdl:input message="ws:AvailableToSellRequest" />
<wsdl:output message="ws:AvailableToSellResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POSubmit">
<wsdl:input message="ws:POSubmitRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POCancel">
<wsdl:input message="ws:POCancelRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="POChange">
<wsdl:input message="ws:POChangeRequest" />
<wsdl:output message="ws:POResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="CatalogRequest">
<wsdl:input message="ws:CatalogRequest" />
<wsdl:output message="ws:CatalogReponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
<wsdl:operation name="CatalogListRequest">
<wsdl:input message="ws:CatalogListRequest" />
<wsdl:output message="ws:CatalogListResponse" />
<wsdl:fault name="OITestFault" message="ws:OITestWebServicesFault" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="OITestBinding" type="ws:OITestPort">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="ATSCheck">
<soap:operation soapAction="http://example.com/OITest/ATSCheck" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POSubmit">
<soap:operation soapAction="http://example.com/OITest/POSubmit" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POCancel">
<soap:operation soapAction="http://example.com/OITest/POCancel" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="POChange">
<soap:operation soapAction="http://example.com/OITest/POChange" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="CatalogRequest">
<soap:operation soapAction="http://example.com/OITest/CatalogRequest" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="CatalogListRequest">
<soap:operation soapAction="http://example.com/OITest/CatalogListRequest" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
<wsdl:fault name="OITestFault">
<soap:fault name="OITestFault" use="literal" />
</wsdl:fault>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="OITestService">
<wsdl:port name="OITestService" binding="ws:OITestBinding">
<soap:address location="http://localhost:8080/ws/services/OITestService" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

348
t/acceptance/wsdl/email_account.wsdl
View File

@@ -1,174 +1,174 @@
<?xml version="1.0"?>
<definitions name="email_account"
targetNamespace="email_account"
xmlns:tns="email_account"
xmlns:wsd="http://www.w3c.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl"
>
<types>
<xsd:schema targetNamespace="email_account">
<xsd:complexType name="imapAccount">
<xsd:annotation>
<xsd:documentation>
Ein (evtl. unvollständiger) Account-Datensatz.
Alle Felder des Datensatzes können, müssen aber nicht
gefüllt sein.
</xsd:documentation>
</xsd:annotation>
<xsd:any>
<xsd:element name="email" type="xsd:string" />
<xsd:element name="uid" type="xsd:string" />
<xsd:element name="password" type="xsd:string" />
<xsd:element name="host" type="xsd:string" />
<xsd:element name="sendQuota" type="xsd:int" />
<xsd:element name="receiveQuota" type="xsd:int" />
<xsd:element name="enabled" type="xsd:boolean" default="true"/>
</xsd:any>
</xsd:complexType>
<xsd:complexType name="imapAccountList">
<xsd:annotation>
<xsd:documentation>
Eine Liste von Account-Datensätzen. Die Liste kann leer sein.
</xsd:documentation>
</xsd:annotation>
<xsd:any maxOccurs="unbounded">
<xsd:element name="account" type="tns:imapAccount"/>
</xsd:any>
</xsd:complexType>
</xsd:schema>
</types>
<message name="getRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="getResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="createRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="createResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="modifyRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="modifyResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="searchRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="searchResponse">
<part name="accountList" type="tns:imapAccountList"/>
</message>
<message name="deleteRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="deleteResponse">
<part name="accountList" type="tns:imapAccountList"/>
</message>
<portType name="email_account">
<operation name="get">
<documentation>
Methode zum Anzeigen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="getRequest"/>
<output message="getResponse"/>
</operation>
<operation name="create">
<documentation>
Methode zum Anlegen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="createRequest"/>
<output message="createResponse"/>
</operation>
<operation name="modify">
<documentation>
Methode zum Ändern eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="modifyRequest"/>
<output message="modifyResponse"/>
</operation>
<operation name="delete">
<documentation>
Methode zum Löschen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="deleteRequest"/>
<output message="deleteResponse"/>
</operation>
<operation name="search">
<documentation>
Methode zum Suchen eines oder mehrerer Account-Datensätze.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert eine Liste an (vollständigen)
passenden Datensätzen zurück. Die Liste kann leer sein.
</documentation>
<input message="searchRequest"/>
<output message="searchResponse"/>
</operation>
</portType>
<binding type="email_account" name="soap">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<soap:operation soapAction="email_account/get">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/create">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/modify">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/delete">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/search">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
</binding>
<service name="email_account">
<port name="email_account" binding="soap">
<address location="https://127.0.0.1/email_account" />
</port>
</service>
</definitions>
<?xml version="1.0"?>
<definitions name="email_account"
targetNamespace="email_account"
xmlns:tns="email_account"
xmlns:wsd="http://www.w3c.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl"
>
<types>
<xsd:schema targetNamespace="email_account">
<xsd:complexType name="imapAccount">
<xsd:annotation>
<xsd:documentation>
Ein (evtl. unvollständiger) Account-Datensatz.
Alle Felder des Datensatzes können, müssen aber nicht
gefüllt sein.
</xsd:documentation>
</xsd:annotation>
<xsd:any>
<xsd:element name="email" type="xsd:string" />
<xsd:element name="uid" type="xsd:string" />
<xsd:element name="password" type="xsd:string" />
<xsd:element name="host" type="xsd:string" />
<xsd:element name="sendQuota" type="xsd:int" />
<xsd:element name="receiveQuota" type="xsd:int" />
<xsd:element name="enabled" type="xsd:boolean" default="true"/>
</xsd:any>
</xsd:complexType>
<xsd:complexType name="imapAccountList">
<xsd:annotation>
<xsd:documentation>
Eine Liste von Account-Datensätzen. Die Liste kann leer sein.
</xsd:documentation>
</xsd:annotation>
<xsd:any maxOccurs="unbounded">
<xsd:element name="account" type="tns:imapAccount"/>
</xsd:any>
</xsd:complexType>
</xsd:schema>
</types>
<message name="getRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="getResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="createRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="createResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="modifyRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="modifyResponse">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="searchRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="searchResponse">
<part name="accountList" type="tns:imapAccountList"/>
</message>
<message name="deleteRequest">
<part name="account" type="tns:imapAccount"/>
</message>
<message name="deleteResponse">
<part name="accountList" type="tns:imapAccountList"/>
</message>
<portType name="email_account">
<operation name="get">
<documentation>
Methode zum Anzeigen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="getRequest"/>
<output message="getResponse"/>
</operation>
<operation name="create">
<documentation>
Methode zum Anlegen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="createRequest"/>
<output message="createResponse"/>
</operation>
<operation name="modify">
<documentation>
Methode zum Ändern eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="modifyRequest"/>
<output message="modifyResponse"/>
</operation>
<operation name="delete">
<documentation>
Methode zum Löschen eines Account-Datensatzes.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert den (vollständigen)
Datensatz zurück.
</documentation>
<input message="deleteRequest"/>
<output message="deleteResponse"/>
</operation>
<operation name="search">
<documentation>
Methode zum Suchen eines oder mehrerer Account-Datensätze.
Erwartet als Input einen (potentiell unvollständigen)
Account-Datensatz und liefert eine Liste an (vollständigen)
passenden Datensätzen zurück. Die Liste kann leer sein.
</documentation>
<input message="searchRequest"/>
<output message="searchResponse"/>
</operation>
</portType>
<binding type="email_account" name="soap">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<soap:operation soapAction="email_account/get">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/create">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/modify">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/delete">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
<soap:operation soapAction="email_account/search">
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</soap:operation>
</binding>
<service name="email_account">
<port name="email_account" binding="soap">
<address location="https://127.0.0.1/email_account" />
</port>
</service>
</definitions>

12
t/lib/MyElement.pm
View File

@@ -9,8 +9,8 @@ use base (
);
__PACKAGE__->__set_name('MyElementName');
sub get_xmlns { 'urn:Test' };
sub get_xmlns { 'urn:Test' };
package MyComplexTypeElement;
use strict;
use SOAP::WSDL::XSD::Typelib::Element;
@@ -32,8 +32,8 @@ use base (
'SOAP::WSDL::XSD::Typelib::Builtin::string',
);
__PACKAGE__->__set_name('MyTestElement');
__PACKAGE__->__set_name('MyTestElement');
sub get_xmlns { 'urn:Test' };
package MyTestElement2;
@@ -60,7 +60,7 @@ use base (
'SOAP::WSDL::XSD::Typelib::Element',
'SOAP::WSDL::XSD::Typelib::ComplexType',
);
my %test_of :ATTR(:get<test>);
my %test2_of :ATTR(:get<test2>);
@@ -80,5 +80,5 @@ __PACKAGE__->_factory(
);
__PACKAGE__->__set_name('MyAtomicComplexTypeElement');
1;

126
t/lib/Test/SOAPMessage.pm
View File

@@ -1,64 +1,64 @@
package Test::SOAPMessage;
use strict;
use SOAP::Lite;
use Test::Differences;
use Tie::IxHash;
use base qw/Exporter/;
our @EXPORT = qw/soap_eq_or_diff/;
sub soap_eq_or_diff
{
my $got = shift;
my $expected = shift;
my $message = shift;
my $soapGot = SOAP::Deserializer->deserialize( $got );
my $soapExpected = SOAP::Deserializer->deserialize( $expected );
return eq_or_diff(
unlather( $soapGot ),
unlather( $soapExpected ),
$message
);
}
sub unlather
{
my $som = shift;
my $path = shift || '/Envelope/Body/[1]';
my $data = shift;
unless ( $data )
{
my %hashData = ();
tie (%hashData, q/Tie::IxHash/);
$data = \%hashData;
}
my $value;
my $tag;
my $i = 1;
while( $som->match("$path/[$i]") )
{
$tag = $som->dataof->name();
$data ||= {};
$value = unlather($som,$path.'/'. '[' . $i . ']' ) || $som->valueof("$path/[$i]");
if ($data->{ $tag })
{
$data->{ $tag } = [ $data->{ $tag } ] unless ( ref ( $data->{ $tag } ) eq 'ARRAY' );
push @{ $data->{ $tag } }, $value;
}
else
{
$data->{ $tag } = $value;
}
$i++;
}
$data ||= $som->valueof($path);
return $data;
}
package Test::SOAPMessage;
use strict;
use SOAP::Lite;
use Test::Differences;
use Tie::IxHash;
use base qw/Exporter/;
our @EXPORT = qw/soap_eq_or_diff/;
sub soap_eq_or_diff
{
my $got = shift;
my $expected = shift;
my $message = shift;
my $soapGot = SOAP::Deserializer->deserialize( $got );
my $soapExpected = SOAP::Deserializer->deserialize( $expected );
return eq_or_diff(
unlather( $soapGot ),
unlather( $soapExpected ),
$message
);
}
sub unlather
{
my $som = shift;
my $path = shift || '/Envelope/Body/[1]';
my $data = shift;
unless ( $data )
{
my %hashData = ();
tie (%hashData, q/Tie::IxHash/);
$data = \%hashData;
}
my $value;
my $tag;
my $i = 1;
while( $som->match("$path/[$i]") )
{
$tag = $som->dataof->name();
$data ||= {};
$value = unlather($som,$path.'/'. '[' . $i . ']' ) || $som->valueof("$path/[$i]");
if ($data->{ $tag })
{
$data->{ $tag } = [ $data->{ $tag } ] unless ( ref ( $data->{ $tag } ) eq 'ARRAY' );
push @{ $data->{ $tag } }, $value;
}
else
{
$data->{ $tag } = $value;
}
$i++;
}
$data ||= $som->valueof($path);
return $data;
}
1;

2
t/lib/Typelib/Base.pm
View File

@@ -1,5 +1,5 @@
package Typelib::Base;
use Class::Std::Storable;
use Class::Std::Storable;
sub mk_add_mutators {
my $class = shift;

34
t/lib/Typelib/TEnqueueMessage.pm
View File

@@ -1,17 +1,17 @@
package Typelib::TEnqueueMessage;
use strict;
use base qw(Typelib::Base);
my %MMessage_of :ATTR(:name<MMessage> :default<()>);
my %attributes_of :ATTR();
%attributes_of = (
MMessage => \%MMessage_of,
);
# make a add_BLA method for every attribute
__PACKAGE__->mk_add_mutators( \%attributes_of );
1;
package Typelib::TEnqueueMessage;
use strict;
use base qw(Typelib::Base);
my %MMessage_of :ATTR(:name<MMessage> :default<()>);
my %attributes_of :ATTR();
%attributes_of = (
MMessage => \%MMessage_of,
);
# make a add_BLA method for every attribute
__PACKAGE__->mk_add_mutators( \%attributes_of );
1;

50
t/lib/Typelib/TMessage.pm
View File

@@ -1,26 +1,26 @@
package Typelib::TMessage;
use strict;
use base qw(Typelib::Base);
my %MRecipientURI_of :ATTR(:name<MRecipientURI> :default<()>);
my %MMessageContent_of :ATTR(:name<MMessageContent> :default<()>);
my %MSenderAddress_of :ATTR(:name<MSenderAddress> :default<()>);
my %MSubject_of :ATTR(:name<MSubject> :default<()>);
my %MDeliveryReportRecipientURI_of :ATTR(:name<MDeliveryReportRecipientURI> :default<()>);
my %MKeepalive_of :ATTR(:name<MKeepalive> :default<()>);
my %attributes_of :ATTR();
%attributes_of = (
MRecipientURI => \%MRecipientURI_of,
MMessageContent => \%MMessageContent_of,
MSenderAddress => \%MSenderAddress_of,
MSubject => \%MSubject_of,
MDeliveryReportRecipientURI => \%MDeliveryReportRecipientURI_of,
MKeepalive => \%MKeepalive_of,
);
# make a add_BLA method for every attribute
__PACKAGE__->mk_add_mutators( \%attributes_of );
package Typelib::TMessage;
use strict;
use base qw(Typelib::Base);
my %MRecipientURI_of :ATTR(:name<MRecipientURI> :default<()>);
my %MMessageContent_of :ATTR(:name<MMessageContent> :default<()>);
my %MSenderAddress_of :ATTR(:name<MSenderAddress> :default<()>);
my %MSubject_of :ATTR(:name<MSubject> :default<()>);
my %MDeliveryReportRecipientURI_of :ATTR(:name<MDeliveryReportRecipientURI> :default<()>);
my %MKeepalive_of :ATTR(:name<MKeepalive> :default<()>);
my %attributes_of :ATTR();
%attributes_of = (
MRecipientURI => \%MRecipientURI_of,
MMessageContent => \%MMessageContent_of,
MSenderAddress => \%MSenderAddress_of,
MSubject => \%MSubject_of,
MDeliveryReportRecipientURI => \%MDeliveryReportRecipientURI_of,
MKeepalive => \%MKeepalive_of,
);
# make a add_BLA method for every attribute
__PACKAGE__->mk_add_mutators( \%attributes_of );
1;

15
t/test.pl Normal file
View File

@@ -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' );