diff options
Diffstat (limited to 'tests/cxx/serializer/built-in/driver.cxx')
| -rw-r--r-- | tests/cxx/serializer/built-in/driver.cxx | 1304 |
1 files changed, 1304 insertions, 0 deletions
diff --git a/tests/cxx/serializer/built-in/driver.cxx b/tests/cxx/serializer/built-in/driver.cxx new file mode 100644 index 0000000..f1d17a1 --- /dev/null +++ b/tests/cxx/serializer/built-in/driver.cxx @@ -0,0 +1,1304 @@ +// file : tests/cxx/serializer/built-in/driver.cxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2006-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +// Test built-in type serialization. +// + +#include <stdlib.h> // strtof, strtod +#include <string.h> // memcpy +#include <iostream> + +#include "test-sskel.hxx" + +using namespace std; +using namespace test; + +struct any_type_simpl: xml_schema::any_type_simpl +{ + virtual void + _serialize_attributes () + { + _attribute ("foo", "one"); + _attribute ("test", "foo", "two"); + } + + virtual void + _serialize_content () + { + _start_element ("test", "inner"); + _characters ("hello"); + _end_element (); + } +}; + +struct any_simple_type_simpl: xml_schema::any_simple_type_simpl +{ + virtual void + _serialize_content () + { + _characters ("hello"); + } +}; + +struct root_simpl: root_sskel +{ + virtual void + pre () + { + boolean_ = 0; + byte_ = 0; + unsigned_byte_ = 0; + short__ = 0; + unsigned_short_ = 0; + int__ = 0; + unsigned_int_ = 0; + long__ = 0; + unsigned_long_ = 0; + + integer_ = 0; + negative_integer_ = 0; + non_positive_integer_ = 0; + positive_integer_ = 0; + non_negative_integer_ = 0; + + float__ = 0; + double__ = 0; + decimal_ = 0; + + string_ = 0; + normalized_string_ = 0; + token_ = 0; + name_ = 0; + nmtoken_ = 0; + nmtokens_ = 0; + ncname_ = 0; + id_ = 0; + idref_ = 0; + idrefs_ = 0; + language_ = 0; + uri_ = 0; + qname_ = 0; + + base64_binary_ = 0; + hex_binary_ = 0; + + gday_ = 0; + gmonth_ = 0; + gyear_ = 0; + gmonth_day_ = 0; + gyear_month_ = 0; + date_ = 0; + time_ = 0; + date_time_ = 0; + duration_ = 0; + } + + virtual bool + boolean_next () + { + return boolean_ < 2; + } + + virtual bool + boolean () + { + static const bool v[] = {true, false}; + return v[boolean_++]; + } + + virtual bool + byte_next () + { + return byte_ < 4; + } + + virtual signed char + byte () + { + static const signed char v[] = {-128, -123, 0, 127}; + return v[byte_++]; + } + + virtual bool + unsigned_byte_next () + { + return unsigned_byte_ < 3; + } + + virtual unsigned char + unsigned_byte () + { + static const unsigned char v[] = {0, 123, 255}; + return v[unsigned_byte_++]; + } + + virtual bool + short__next () + { + return short__ < 4; + } + + virtual short + short_ () + { + static const short v[] = {-32768, -12345, 0, 32767}; + return v[short__++]; + } + + virtual bool + unsigned_short_next () + { + return unsigned_short_ < 3; + } + + virtual unsigned short + unsigned_short () + { + static const unsigned short v[] = {0, 12345, 65535}; + return v[unsigned_short_++]; + } + + virtual bool + int__next () + { + return int__ < 4; + } + + virtual int + int_ () + { + static const int v[] = {-2147483648, -1234567890, 0, 2147483647}; + return v[int__++]; + } + + virtual bool + unsigned_int_next () + { + return unsigned_int_ < 3; + } + + virtual unsigned int + unsigned_int () + { + static const unsigned int v[] = {0, 1234567890, 4294967295}; + return v[unsigned_int_++]; + } + + virtual bool + long__next () + { + return long__ < 4; + } + + virtual bool + unsigned_long_next () + { + return unsigned_long_ < 3; + } + +#ifdef XSDE_LONGLONG + virtual long long + long_ () + { + static const long long v[] = + { + -9223372036854775807LL, -1234567890123456789LL, + 0LL, 9223372036854775807LL + }; + + return long__ == 0 ? (v[long__++] - 1) : v[long__++]; + } + + virtual unsigned long long + unsigned_long () + { + static const unsigned long long v[] = + { + 0ULL, 12345678901234567890ULL, 18446744073709551615ULL + }; + + return v[unsigned_long_++]; + } +#else + virtual long + long_ () + { + static const long v[] = {-2147483647L, -1234567890L, 0L, 2147483647L}; + return long__ == 0 ? (v[long__++] - 1) : v[long__++]; + } + + virtual unsigned long + unsigned_long () + { + static const unsigned long v[] = {0UL, 1234567890UL, 4294967295UL}; + return v[unsigned_long_++]; + } +#endif + + // + // + virtual bool + integer_next () + { + return integer_ < 4; + } + + virtual long + integer () + { + static const long v[] = {-2147483647L, -1234567890L, 0L, 2147483647L}; + return integer_ == 0 ? (v[integer_++] - 1) : v[integer_++]; + } + + virtual bool + negative_integer_next () + { + return negative_integer_ < 2; + } + + virtual long + negative_integer () + { + static const long v[] = {-2147483647L, -1234567890L}; + return negative_integer_ == 0 + ? (v[negative_integer_++] - 1) + : v[negative_integer_++]; + } + + virtual bool + non_positive_integer_next () + { + return non_positive_integer_ < 3; + } + + virtual long + non_positive_integer () + { + static const long v[] = {-2147483647L, -1234567890L, 0L}; + return non_positive_integer_ == 0 + ? (v[non_positive_integer_++] - 1) + : v[non_positive_integer_++]; + } + + virtual bool + positive_integer_next () + { + return positive_integer_ < 2; + } + + virtual unsigned long + positive_integer () + { + static const unsigned long v[] = {1234567890UL, 4294967295UL}; + return v[positive_integer_++]; + } + + virtual bool + non_negative_integer_next () + { + return non_negative_integer_ < 3; + } + + virtual unsigned long + non_negative_integer () + { + static const unsigned long v[] = {0UL, 1234567890UL, 4294967295UL}; + return v[non_negative_integer_++]; + } + + // + // + virtual bool + float__next () + { + return float__ < 9; + } + + virtual float + float_ () + { + static const float v[] = {0.0, 0.0, 0.0, 0.0, 1.0, -1.0, + 123.567, -123.567e5, -0.45e-5}; + + switch (float__) + { + case 0: + { + float__++; + return strtof ("INF", 0); + } + case 1: + { + float__++; + return strtof ("-INF", 0); + } + case 2: + { + float__++; + return strtof ("NAN", 0); + } + default: + { + return v[float__++]; + } + } + } + + virtual bool + double__next () + { + return double__ < 9; + } + + virtual double + double_ () + { + static const double v[] = {0.0, 0.0, 0.0, 0.0, 1.0, -1.0, + 123.56789, -123.56789e8, -0.45E-5}; + + switch (double__) + { + case 0: + { + double__++; + return strtod ("INF", 0); + } + case 1: + { + double__++; + return strtod ("-INF", 0); + } + case 2: + { + double__++; + return strtod ("NAN", 0); + } + default: + { + return v[double__++]; + } + } + } + + virtual bool + decimal_next () + { + return decimal_ < 5; + } + + virtual double + decimal () + { + static const double v[] = {0.0, 1.0, -1.0, 123.56789, -123.56789}; + return v[decimal_++]; + } + + // + // + +#ifdef XSDE_STL + + virtual bool + string_next () + { + return string_++ < 1; + } + + virtual std::string + string () + { + return " test \n string "; + } + + virtual bool + normalized_string_next () + { + return normalized_string_++ < 1; + } + + virtual std::string + normalized_string () + { + return "test normalized string"; + } + + virtual bool + token_next () + { + return token_++ < 1; + } + + virtual std::string + token () + { + return "test token"; + } + + virtual bool + name_next () + { + return name_++ < 1; + } + + virtual std::string + name () + { + return "as123:345-.abs"; + } + + virtual bool + nmtoken_next () + { + return nmtoken_++ < 1; + } + + virtual std::string + nmtoken () + { + return "1as123:345-.abs"; + } + + virtual bool + nmtokens_next () + { + return nmtokens_ < 2; + } + + virtual xml_schema::string_sequence* + nmtokens () + { + using xml_schema::string_sequence; + + switch (nmtokens_++) + { + case 0: + { + string_sequence* r = new string_sequence; + r->push_back ("one"); + return r; + } + case 1: + { + string_sequence* r = new string_sequence; + r->push_back ("one"); + r->push_back ("two"); + r->push_back ("three"); + return r; + } + default: + return 0; + } + } + + virtual bool + ncname_next () + { + return ncname_++ < 1; + } + + virtual std::string + ncname () + { + return "as123_345-.abs"; + } + + virtual bool + id_next () + { + return id_ < 4; + } + + virtual std::string + id () + { + static const char* v[] = {"as123_345-.abs", "one", "two", "three"}; + return v[id_++]; + } + + virtual bool + idref_next () + { + return idref_++ < 1; + } + + virtual std::string + idref () + { + return "as123_345-.abs"; + } + + virtual bool + idrefs_next () + { + return idrefs_ < 2; + } + + virtual xml_schema::string_sequence* + idrefs () + { + using xml_schema::string_sequence; + + switch (idrefs_++) + { + case 0: + { + string_sequence* r = new string_sequence; + r->push_back ("one"); + return r; + } + case 1: + { + string_sequence* r = new string_sequence; + r->push_back ("two"); + r->push_back ("three"); + return r; + } + default: + return 0; + } + } + + virtual bool + language_next () + { + return language_++ < 1; + } + + virtual std::string + language () + { + return "en-us"; + } + + virtual bool + uri_next () + { + return uri_++ < 1; + } + + virtual std::string + uri () + { + return "http://www.example.com/foo#bar"; + } + + virtual bool + qname_next () + { + return qname_ < 2; + } + + virtual xml_schema::qname + qname () + { + using xml_schema::qname; + + switch (qname_++) + { + case 0: + { + qname r ("g1", "qname"); + return r; + } + case 1: + { + qname r ("qname"); + return r; + } + default: + return qname ("bad"); + } + } + +#else + + virtual bool + string_next () + { + return string_++ < 1; + } + + virtual const char* + string () + { + return " test \n string "; + } + + virtual bool + normalized_string_next () + { + return normalized_string_++ < 1; + } + + virtual const char* + normalized_string () + { + return "test normalized string"; + } + + virtual bool + token_next () + { + return token_++ < 1; + } + + virtual const char* + token () + { + return "test token"; + } + + virtual bool + name_next () + { + return name_++ < 1; + } + + virtual const char* + name () + { + return "as123:345-.abs"; + } + + virtual bool + nmtoken_next () + { + return nmtoken_++ < 1; + } + + virtual const char* + nmtoken () + { + return "1as123:345-.abs"; + } + + virtual bool + nmtokens_next () + { + return nmtokens_ < 2; + } + + virtual const xml_schema::string_sequence* + nmtokens () + { + using xml_schema::string_sequence; + + switch (nmtokens_++) + { + case 0: + { + string_sequence* r = new string_sequence (); + r->push_back_copy ("one"); + return r; + } + case 1: + { + string_sequence* r = new string_sequence (); + r->push_back_copy ("one"); + r->push_back_copy ("two"); + r->push_back_copy ("three"); + return r; + } + default: + return 0; + } + } + + virtual bool + ncname_next () + { + return ncname_++ < 1; + } + + virtual const char* + ncname () + { + return "as123_345-.abs"; + } + + virtual bool + id_next () + { + return id_ < 4; + } + + virtual const char* + id () + { + static const char* v[] = {"as123_345-.abs", "one", "two", "three"}; + return v[id_++]; + } + + virtual bool + idref_next () + { + return idref_++ < 1; + } + + virtual const char* + idref () + { + return "as123_345-.abs"; + } + + virtual bool + idrefs_next () + { + return idrefs_ < 2; + } + + virtual const xml_schema::string_sequence* + idrefs () + { + using xml_schema::string_sequence; + + switch (idrefs_++) + { + case 0: + { + string_sequence* r = new string_sequence (); + r->push_back_copy ("one"); + return r; + } + case 1: + { + string_sequence* r = new string_sequence (); + r->push_back_copy ("two"); + r->push_back_copy ("three"); + return r; + } + default: + return 0; + } + } + + virtual bool + language_next () + { + return language_++ < 1; + } + + virtual const char* + language () + { + return "en-us"; + } + + virtual bool + uri_next () + { + return uri_++ < 1; + } + + virtual const char* + uri () + { + return "http://www.example.com/foo#bar"; + } + + virtual bool + qname_next () + { + return qname_ < 2; + } + + virtual const xml_schema::qname* + qname () + { + using xml_schema::qname; + + switch (qname_++) + { + case 0: + { + qname* r = new qname (); + r->prefix_copy ("g1"); + r->name_copy ("qname"); + return r; + } + case 1: + { + qname* r = new qname (); + r->name_copy ("qname"); + return r; + } + default: + return 0; + } + } +#endif + + // + // + virtual bool + base64_binary_next () + { + return base64_binary_ < 6; + } + + virtual const xml_schema::buffer* + base64_binary () + { + xml_schema::buffer* r = new xml_schema::buffer (); + + switch (base64_binary_++) + { + case 0: + { + // Empty buffer. + // + break; + } + case 1: + { + const char data[] = "12345abcjk"; + const size_t size = sizeof (data) - 1; + r->size (size); + memcpy (r->data (), data, size); + break; + } + case 2: + { + const char data[] = "a"; + const size_t size = sizeof (data) - 1; + r->size (size); + memcpy (r->data (), data, size); + break; + } + case 3: + { + const char data[] = "ab"; + const size_t size = sizeof (data) -1; + r->size (size); + memcpy (r->data (), data, size); + break; + } + case 4: + { + const char data[] = "abc"; + const size_t size = sizeof (data) - 1; + r->size (size); + memcpy (r->data (), data, size); + break; + } + case 5: + { + const size_t size = 345; + + r->size (size); + unsigned char v = 0; + + for (size_t i = 0; i < size; ++i) + { + r->data ()[i] = static_cast<char> (v++); + } + + break; + } + } + + return r; + } + + virtual bool + hex_binary_next () + { + return hex_binary_ < 3; + } + + virtual const xml_schema::buffer* + hex_binary () + { + xml_schema::buffer* r = new xml_schema::buffer (); + + switch (hex_binary_++) + { + case 0: + { + // Empty buffer. + // + break; + } + case 1: + { + const char data[] = "12345abcjk"; + const size_t size = sizeof (data) - 1; + r->size (size); + memcpy (r->data (), data, size); + break; + } + case 2: + { + const size_t size = 345; + + r->size (size); + unsigned char v = 0; + + for (size_t i = 0; i < size; ++i) + { + r->data ()[i] = static_cast<char> (v++); + } + + break; + } + } + + return r; + } + + virtual bool + gday_next () + { + return gday_ < 3; + } + + virtual xml_schema::gday + gday () + { + using xml_schema::gday; + + switch (gday_++) + { + case 0: + return gday (23); + case 1: + return gday (31, 2, 30); + case 2: + return gday (15, 0, 0); + } + } + + virtual bool + gmonth_next () + { + return gmonth_ < 2; + } + + virtual ::xml_schema::gmonth + gmonth () + { + using xml_schema::gmonth; + + switch (gmonth_++) + { + case 0: + return gmonth (6); + case 1: + return gmonth (12, 2, 30); + } + } + + virtual bool + gyear_next () + { + return gyear_ < 2; + } + + virtual ::xml_schema::gyear + gyear () + { + using xml_schema::gyear; + + switch (gyear_++) + { + case 0: + return gyear (2007); + case 1: + return gyear (-2007, -2, -30); + } + } + + virtual bool + gmonth_day_next () + { + return gmonth_day_ < 2; + } + + virtual ::xml_schema::gmonth_day + gmonth_day () + { + using xml_schema::gmonth_day; + + switch (gmonth_day_++) + { + case 0: + return gmonth_day (6, 15); + case 1: + return gmonth_day (12, 31, 2, 30); + } + } + + virtual bool + gyear_month_next () + { + return gyear_month_ < 2; + } + + virtual ::xml_schema::gyear_month + gyear_month () + { + using xml_schema::gyear_month; + + switch (gyear_month_++) + { + case 0: + return gyear_month (2007, 10); + case 1: + return gyear_month (-2007, 12, -2, -30); + } + } + + virtual bool + date_next () + { + return date_ < 2; + } + + virtual ::xml_schema::date + date () + { + using xml_schema::date; + + switch (date_++) + { + case 0: + return date (2007, 6, 15); + case 1: + return date (-2007, 12, 31, -2, -30); + } + } + + virtual bool + time_next () + { + return time_ < 2; + } + + virtual ::xml_schema::time + time () + { + using xml_schema::time; + + switch (time_++) + { + case 0: + return time (12, 30, 30.0); + case 1: + return time (23, 59, 59.55, 2, 30); + } + } + + virtual bool + date_time_next () + { + return date_time_ < 2; + } + + virtual ::xml_schema::date_time + date_time () + { + using xml_schema::date_time; + + switch (date_time_++) + { + case 0: + return date_time (2007, 6, 15, 12, 30, 30.0); + case 1: + return date_time (-2007, 12, 31, 23, 59, 59.55, -2, -30); + } + } + + virtual bool + duration_next () + { + return duration_ < 7; + } + + virtual ::xml_schema::duration + duration () + { + using xml_schema::duration; + + switch (duration_++) + { + case 0: + return duration (false, 1, 0, 0, 0, 0, 0.0); + case 1: + return duration (true, 0, 1, 0, 0, 0, 0.0); + case 2: + return duration (false, 0, 0, 1, 0, 0, 0.0); + case 3: + return duration (true, 0, 0, 0, 1, 0, 0.0); + case 4: + return duration (false, 0, 0, 0, 0, 1, 0.0); + case 5: + return duration (true, 0, 0, 0, 0, 0, 1.1); + case 6: + return duration (false, 1, 2, 3, 4, 5, 6.7); + } + } + +private: + int boolean_; + int byte_; + int unsigned_byte_; + int short__; + int unsigned_short_; + int int__; + int unsigned_int_; + int long__; + int unsigned_long_; + + int integer_; + int negative_integer_; + int non_positive_integer_; + int positive_integer_; + int non_negative_integer_; + + int float__; + int double__; + int decimal_; + + int string_; + int normalized_string_; + int token_; + int name_; + int nmtoken_; + int nmtokens_; + int ncname_; + int id_; + int idref_; + int idrefs_; + int language_; + int uri_; + int qname_; + + int base64_binary_; + int hex_binary_; + + int gday_; + int gmonth_; + int gyear_; + int gmonth_day_; + int gyear_month_; + int date_; + int time_; + int date_time_; + int duration_; +}; + +int +main () +{ + any_type_simpl any_type_s; + any_simple_type_simpl any_simple_type_s; + + xml_schema::boolean_simpl boolean_s; + + xml_schema::byte_simpl byte_s; + xml_schema::unsigned_byte_simpl unsigned_byte_s; + xml_schema::short_simpl short_s; + xml_schema::unsigned_short_simpl unsigned_short_s; + xml_schema::int_simpl int_s; + xml_schema::unsigned_int_simpl unsigned_int_s; + xml_schema::long_simpl long_s; + xml_schema::unsigned_long_simpl unsigned_long_s; + + xml_schema::integer_simpl integer_s; + xml_schema::negative_integer_simpl negative_integer_s; + xml_schema::non_positive_integer_simpl non_sositive_integer_s; + xml_schema::positive_integer_simpl positive_integer_s; + xml_schema::non_negative_integer_simpl non_negative_integer_s; + + xml_schema::float_simpl float_s; + xml_schema::double_simpl double_s; + xml_schema::decimal_simpl decimal_s; + + xml_schema::string_simpl string_s; + xml_schema::normalized_string_simpl normalized_string_s; + xml_schema::token_simpl token_s; + xml_schema::name_simpl name_s; + xml_schema::nmtoken_simpl nmtoken_s; + xml_schema::ncname_simpl ncname_s; + xml_schema::id_simpl id_s; + xml_schema::idref_simpl idref_s; + + xml_schema::language_simpl language_s; + xml_schema::uri_simpl uri_s; + +#ifdef XSDE_STL + xml_schema::qname_simpl qname_s; +#else + xml_schema::qname_simpl qname_s (true); +#endif + + xml_schema::idrefs_simpl idrefs_s (true); + xml_schema::nmtokens_simpl nmtokens_s (true); + + xml_schema::base64_binary_simpl base64_binary_s (true); + xml_schema::hex_binary_simpl hex_binary_s (true); + + xml_schema::gday_simpl gday_s; + xml_schema::gmonth_simpl gmonth_s; + xml_schema::gyear_simpl gyear_s; + xml_schema::gmonth_day_simpl gmonth_day_s; + xml_schema::gyear_month_simpl gyear_month_s; + xml_schema::date_simpl date_s; + xml_schema::time_simpl time_s; + xml_schema::date_time_simpl date_time_s; + xml_schema::duration_simpl duration_s; + + root_simpl root_s; + + root_s.serializers (any_type_s, + any_simple_type_s, + boolean_s, + byte_s, + unsigned_byte_s, + short_s, + unsigned_short_s, + int_s, + unsigned_int_s, + long_s, + unsigned_long_s, + integer_s, + negative_integer_s, + non_sositive_integer_s, + positive_integer_s, + non_negative_integer_s, + float_s, + double_s, + decimal_s, + string_s, + normalized_string_s, + token_s, + name_s, + nmtoken_s, + nmtokens_s, + ncname_s, + id_s, + idref_s, + idrefs_s, + language_s, + uri_s, + qname_s, + base64_binary_s, + hex_binary_s, + gday_s, + gmonth_s, + gyear_s, + gmonth_day_s, + gyear_month_s, + date_s, + time_s, + date_time_s, + duration_s); + + xml_schema::document_simpl doc_s (root_s, "test", "root"); + + root_s.pre (); + doc_s.serialize (cout); + root_s.post (); +} |