/** * @file llsdserialize_test.cpp * @date 2006-04 * @brief LLSDSerialize unit tests * * $LicenseInfo:firstyear=2006&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "linden_common.h" #if LL_WINDOWS #include <winsock2.h> typedef U32 uint32_t; #include <process.h> #include <io.h> #else #include <unistd.h> #include <netinet/in.h> #include <errno.h> #include <fcntl.h> #include <sys/stat.h> #include <sys/wait.h> #include "llprocess.h" #include "llstring.h" #endif #include "boost/range.hpp" #include "llsd.h" #include "llsdserialize.h" #include "llsdutil.h" #include "llformat.h" #include "llmemorystream.h" #include "../test/hexdump.h" #include "../test/lltut.h" #include "../test/namedtempfile.h" #include "stringize.h" #include "StringVec.h" #include <functional> typedef std::function<void(const LLSD& data, std::ostream& str)> FormatterFunction; typedef std::function<bool(std::istream& istr, LLSD& data, llssize max_bytes)> ParserFunction; std::vector<U8> string_to_vector(const std::string& str) { return std::vector<U8>(str.begin(), str.end()); } namespace tut { struct sd_xml_data { sd_xml_data() { mFormatter = new LLSDXMLFormatter; } LLSD mSD; LLPointer<LLSDXMLFormatter> mFormatter; void xml_test(const char* name, const std::string& expected) { std::ostringstream ostr; mFormatter->format(mSD, ostr); ensure_equals(name, ostr.str(), expected); } }; typedef test_group<sd_xml_data> sd_xml_test; typedef sd_xml_test::object sd_xml_object; tut::sd_xml_test sd_xml_stream("LLSDXMLFormatter"); template<> template<> void sd_xml_object::test<1>() { // random atomic tests std::string expected; expected = "<llsd><undef /></llsd>\n"; xml_test("undef", expected); mSD = 3463; expected = "<llsd><integer>3463</integer></llsd>\n"; xml_test("integer", expected); mSD = ""; expected = "<llsd><string /></llsd>\n"; xml_test("empty string", expected); mSD = "foobar"; expected = "<llsd><string>foobar</string></llsd>\n"; xml_test("string", expected); mSD = LLUUID::null; expected = "<llsd><uuid /></llsd>\n"; xml_test("null uuid", expected); mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed"); expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>\n"; xml_test("uuid", expected); mSD = LLURI("https://secondlife.com/login"); expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>\n"; xml_test("uri", expected); mSD = LLDate("2006-04-24T16:11:33Z"); expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>\n"; xml_test("date", expected); // Generated by: echo -n 'hello' | openssl enc -e -base64 std::vector<U8> hello; hello.push_back('h'); hello.push_back('e'); hello.push_back('l'); hello.push_back('l'); hello.push_back('o'); mSD = hello; expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n"; xml_test("binary", expected); } template<> template<> void sd_xml_object::test<2>() { // tests with boolean values. std::string expected; mFormatter->boolalpha(true); mSD = true; expected = "<llsd><boolean>true</boolean></llsd>\n"; xml_test("bool alpha true", expected); mSD = false; expected = "<llsd><boolean>false</boolean></llsd>\n"; xml_test("bool alpha false", expected); mFormatter->boolalpha(false); mSD = true; expected = "<llsd><boolean>1</boolean></llsd>\n"; xml_test("bool true", expected); mSD = false; expected = "<llsd><boolean>0</boolean></llsd>\n"; xml_test("bool false", expected); } template<> template<> void sd_xml_object::test<3>() { // tests with real values. std::string expected; mFormatter->realFormat("%.2f"); mSD = 1.0; expected = "<llsd><real>1.00</real></llsd>\n"; xml_test("real 1", expected); mSD = -34379.0438; expected = "<llsd><real>-34379.04</real></llsd>\n"; xml_test("real reduced precision", expected); mFormatter->realFormat("%.4f"); expected = "<llsd><real>-34379.0438</real></llsd>\n"; xml_test("higher precision", expected); mFormatter->realFormat("%.0f"); mSD = 0.0; expected = "<llsd><real>0</real></llsd>\n"; xml_test("no decimal 0", expected); mSD = 3287.4387; expected = "<llsd><real>3287</real></llsd>\n"; xml_test("no decimal real number", expected); } template<> template<> void sd_xml_object::test<4>() { // tests with arrays std::string expected; mSD = LLSD::emptyArray(); expected = "<llsd><array /></llsd>\n"; xml_test("empty array", expected); mSD.append(LLSD()); expected = "<llsd><array><undef /></array></llsd>\n"; xml_test("1 element array", expected); mSD.append(1); expected = "<llsd><array><undef /><integer>1</integer></array></llsd>\n"; xml_test("2 element array", expected); } template<> template<> void sd_xml_object::test<5>() { // tests with arrays std::string expected; mSD = LLSD::emptyMap(); expected = "<llsd><map /></llsd>\n"; xml_test("empty map", expected); mSD["foo"] = "bar"; expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>\n"; xml_test("1 element map", expected); mSD["baz"] = LLSD(); expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>\n"; xml_test("2 element map", expected); } template<> template<> void sd_xml_object::test<6>() { // tests with binary std::string expected; // Generated by: echo -n 'hello' | openssl enc -e -base64 mSD = string_to_vector("hello"); expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n"; xml_test("binary", expected); mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0"); expected = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n"; xml_test("binary", expected); } class TestLLSDSerializeData { public: TestLLSDSerializeData(); ~TestLLSDSerializeData(); void doRoundTripTests(const std::string&); void checkRoundTrip(const std::string&, const LLSD& v); void setFormatterParser(LLPointer<LLSDFormatter> formatter, LLPointer<LLSDParser> parser) { mFormatter = [formatter](const LLSD& data, std::ostream& str) { formatter->format(data, str); }; // this lambda must be mutable since otherwise the bound 'parser' // is assumed to point to a const LLSDParser mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) mutable { // reset() call is needed since test code re-uses parser object parser->reset(); return (parser->parse(istr, data, max_bytes) > 0); }; } void setParser(bool (*parser)(LLSD&, std::istream&, llssize)) { // why does LLSDSerialize::deserialize() reverse the parse() params?? mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) { return parser(data, istr, max_bytes); }; } FormatterFunction mFormatter; ParserFunction mParser; }; TestLLSDSerializeData::TestLLSDSerializeData() { } TestLLSDSerializeData::~TestLLSDSerializeData() { } void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v) { std::stringstream stream; mFormatter(v, stream); //LL_INFOS() << "checkRoundTrip: length " << stream.str().length() << LL_ENDL; LLSD w; mParser(stream, w, stream.str().size()); try { ensure_equals(msg, w, v); } catch (...) { std::cerr << "the serialized string was:" << std::endl; std::cerr << stream.str() << std::endl; throw; } } static void fillmap(LLSD& root, U32 width, U32 depth) { if(depth == 0) { root["foo"] = "bar"; return; } for(U32 i = 0; i < width; ++i) { std::string key = llformat("child %d", i); root[key] = LLSD::emptyMap(); fillmap(root[key], width, depth - 1); } } void TestLLSDSerializeData::doRoundTripTests(const std::string& msg) { LLSD v; checkRoundTrip(msg + " undefined", v); v = true; checkRoundTrip(msg + " true bool", v); v = false; checkRoundTrip(msg + " false bool", v); v = 1; checkRoundTrip(msg + " positive int", v); v = 0; checkRoundTrip(msg + " zero int", v); v = -1; checkRoundTrip(msg + " negative int", v); v = 1234.5f; checkRoundTrip(msg + " positive float", v); v = 0.0f; checkRoundTrip(msg + " zero float", v); v = -1234.5f; checkRoundTrip(msg + " negative float", v); // FIXME: need a NaN test v = LLUUID::null; checkRoundTrip(msg + " null uuid", v); LLUUID newUUID; newUUID.generate(); v = newUUID; checkRoundTrip(msg + " new uuid", v); v = ""; checkRoundTrip(msg + " empty string", v); v = "some string"; checkRoundTrip(msg + " non-empty string", v); v = "Second Life is a 3-D virtual world entirely built and owned by its residents. " "Since opening to the public in 2003, it has grown explosively and today is " "inhabited by nearly 100,000 people from around the globe.\n" "\n" "From the moment you enter the World you'll discover a vast digital continent, " "teeming with people, entertainment, experiences and opportunity. Once you've " "explored a bit, perhaps you'll find a perfect parcel of land to build your " "house or business.\n" "\n" "You'll also be surrounded by the Creations of your fellow residents. Because " "residents retain the rights to their digital creations, they can buy, sell " "and trade with other residents.\n" "\n" "The Marketplace currently supports millions of US dollars in monthly " "transactions. This commerce is handled with the in-world currency, the Linden " "dollar, which can be converted to US dollars at several thriving online " "currency exchanges.\n" "\n" "Welcome to Second Life. We look forward to seeing you in-world!\n" ; checkRoundTrip(msg + " long string", v); static const U32 block_size = 0x000020; for (U32 block = 0x000000; block <= 0x10ffff; block += block_size) { std::ostringstream out; for (U32 c = block; c < block + block_size; ++c) { if (c <= 0x000001f && c != 0x000009 && c != 0x00000a) { // see XML standard, sections 2.2 and 4.1 continue; } if (0x00d800 <= c && c <= 0x00dfff) { continue; } if (0x00fdd0 <= c && c <= 0x00fdef) { continue; } if ((c & 0x00fffe) == 0x00fffe) { continue; } // see Unicode standard, section 15.8 if (c <= 0x00007f) { out << (char)(c & 0x7f); } else if (c <= 0x0007ff) { out << (char)(0xc0 | ((c >> 6) & 0x1f)); out << (char)(0x80 | ((c >> 0) & 0x3f)); } else if (c <= 0x00ffff) { out << (char)(0xe0 | ((c >> 12) & 0x0f)); out << (char)(0x80 | ((c >> 6) & 0x3f)); out << (char)(0x80 | ((c >> 0) & 0x3f)); } else { out << (char)(0xf0 | ((c >> 18) & 0x07)); out << (char)(0x80 | ((c >> 12) & 0x3f)); out << (char)(0x80 | ((c >> 6) & 0x3f)); out << (char)(0x80 | ((c >> 0) & 0x3f)); } } v = out.str(); std::ostringstream blockmsg; blockmsg << msg << " unicode string block 0x" << std::hex << block; checkRoundTrip(blockmsg.str(), v); } LLDate epoch; v = epoch; checkRoundTrip(msg + " epoch date", v); LLDate aDay("2002-12-07T05:07:15.00Z"); v = aDay; checkRoundTrip(msg + " date", v); LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/"); v = path; checkRoundTrip(msg + " url", v); const char source[] = "it must be a blue moon again"; std::vector<U8> data; // note, includes terminating '\0' copy(&source[0], &source[sizeof(source)], back_inserter(data)); v = data; checkRoundTrip(msg + " binary", v); v = LLSD::emptyMap(); checkRoundTrip(msg + " empty map", v); v = LLSD::emptyMap(); v["name"] = "luke"; //v.insert("name", "luke"); v["age"] = 3; //v.insert("age", 3); checkRoundTrip(msg + " map", v); v.clear(); v["a"]["1"] = true; v["b"]["0"] = false; checkRoundTrip(msg + " nested maps", v); v = LLSD::emptyArray(); checkRoundTrip(msg + " empty array", v); v = LLSD::emptyArray(); v.append("ali"); v.append(28); checkRoundTrip(msg + " array", v); v.clear(); v[0][0] = true; v[1][0] = false; checkRoundTrip(msg + " nested arrays", v); v = LLSD::emptyMap(); fillmap(v, 10, 3); // 10^6 maps checkRoundTrip(msg + " many nested maps", v); } typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerializeGroup; typedef TestLLSDSerializeGroup::object TestLLSDSerializeObject; TestLLSDSerializeGroup gTestLLSDSerializeGroup("llsd serialization"); template<> template<> void TestLLSDSerializeObject::test<1>() { setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_PRETTY_BINARY), new LLSDNotationParser()); doRoundTripTests("pretty binary notation serialization"); } template<> template<> void TestLLSDSerializeObject::test<2>() { setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE), new LLSDNotationParser()); doRoundTripTests("raw binary notation serialization"); } template<> template<> void TestLLSDSerializeObject::test<3>() { setFormatterParser(new LLSDXMLFormatter(), new LLSDXMLParser()); doRoundTripTests("xml serialization"); } template<> template<> void TestLLSDSerializeObject::test<4>() { setFormatterParser(new LLSDBinaryFormatter(), new LLSDBinaryParser()); doRoundTripTests("binary serialization"); } template<> template<> void TestLLSDSerializeObject::test<5>() { mFormatter = [](const LLSD& sd, std::ostream& str) { LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_BINARY); }; setParser(LLSDSerialize::deserialize); doRoundTripTests("serialize(LLSD_BINARY)"); }; template<> template<> void TestLLSDSerializeObject::test<6>() { mFormatter = [](const LLSD& sd, std::ostream& str) { LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_XML); }; setParser(LLSDSerialize::deserialize); doRoundTripTests("serialize(LLSD_XML)"); }; template<> template<> void TestLLSDSerializeObject::test<7>() { mFormatter = [](const LLSD& sd, std::ostream& str) { LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_NOTATION); }; setParser(LLSDSerialize::deserialize); // In this test, serialize(LLSD_NOTATION) emits a header recognized by // deserialize(). doRoundTripTests("serialize(LLSD_NOTATION)"); }; template<> template<> void TestLLSDSerializeObject::test<8>() { setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE), new LLSDNotationParser()); setParser(LLSDSerialize::deserialize); // This is an interesting test because LLSDNotationFormatter does not // emit an llsd/notation header. doRoundTripTests("LLSDNotationFormatter -> deserialize"); }; template<> template<> void TestLLSDSerializeObject::test<9>() { setFormatterParser(new LLSDXMLFormatter(false, "", LLSDFormatter::OPTIONS_NONE), new LLSDXMLParser()); setParser(LLSDSerialize::deserialize); // This is an interesting test because LLSDXMLFormatter does not // emit an LLSD/XML header. doRoundTripTests("LLSDXMLFormatter -> deserialize"); }; /*==========================================================================*| // We do not expect this test to succeed. Without a header, neither // notation LLSD nor binary LLSD reliably start with a distinct character, // the way XML LLSD starts with '<'. By convention, we default to notation // rather than binary. template<> template<> void TestLLSDSerializeObject::test<10>() { setFormatterParser(new LLSDBinaryFormatter(false, "", LLSDFormatter::OPTIONS_NONE), new LLSDBinaryParser()); setParser(LLSDSerialize::deserialize); // This is an interesting test because LLSDBinaryFormatter does not // emit an LLSD/Binary header. doRoundTripTests("LLSDBinaryFormatter -> deserialize"); }; |*==========================================================================*/ /** * @class TestLLSDParsing * @brief Base class for of a parse tester. */ template <class parser_t> class TestLLSDParsing { public: TestLLSDParsing() { mParser = new parser_t; } void ensureParse( const std::string& msg, const std::string& in, const LLSD& expected_value, S32 expected_count, S32 depth_limit = -1) { std::stringstream input; input.str(in); LLSD parsed_result; mParser->reset(); // reset() call is needed since test code re-uses mParser S32 parsed_count = mParser->parse(input, parsed_result, in.size(), depth_limit); ensure_equals(msg.c_str(), parsed_result, expected_value); // This count check is really only useful for expected // parse failures, since the ensures equal will already // require equality. std::string count_msg(msg); count_msg += " (count)"; ensure_equals(count_msg, parsed_count, expected_count); } LLPointer<parser_t> mParser; }; /** * @class TestLLSDXMLParsing * @brief Concrete instance of a parse tester. */ class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser> { public: TestLLSDXMLParsing() {} }; typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup; typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject; TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing"); template<> template<> void TestLLSDXMLParsingObject::test<1>() { // test handling of xml not recognized as llsd results in an // LLSD Undefined ensureParse( "malformed xml", "<llsd><string>ha ha</string>", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "not llsd", "<html><body><p>ha ha</p></body></html>", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "value without llsd", "<string>ha ha</string>", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "key without llsd", "<key>ha ha</key>", LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDXMLParsingObject::test<2>() { // test handling of unrecognized or unparseable llsd values LLSD v; v["amy"] = 23; v["bob"] = LLSD(); v["cam"] = 1.23; ensureParse( "unknown data type", "<llsd><map>" "<key>amy</key><integer>23</integer>" "<key>bob</key><bigint>99999999999999999</bigint>" "<key>cam</key><real>1.23</real>" "</map></llsd>", v, v.size() + 1); } template<> template<> void TestLLSDXMLParsingObject::test<3>() { // test handling of nested bad data LLSD v; v["amy"] = 23; v["cam"] = 1.23; ensureParse( "map with html", "<llsd><map>" "<key>amy</key><integer>23</integer>" "<html><body>ha ha</body></html>" "<key>cam</key><real>1.23</real>" "</map></llsd>", v, v.size() + 1); v.clear(); v["amy"] = 23; v["cam"] = 1.23; ensureParse( "map with value for key", "<llsd><map>" "<key>amy</key><integer>23</integer>" "<string>ha ha</string>" "<key>cam</key><real>1.23</real>" "</map></llsd>", v, v.size() + 1); v.clear(); v["amy"] = 23; v["bob"] = LLSD::emptyMap(); v["cam"] = 1.23; ensureParse( "map with map of html", "<llsd><map>" "<key>amy</key><integer>23</integer>" "<key>bob</key>" "<map>" "<html><body>ha ha</body></html>" "</map>" "<key>cam</key><real>1.23</real>" "</map></llsd>", v, v.size() + 1); v.clear(); v[0] = 23; v[1] = LLSD(); v[2] = 1.23; ensureParse( "array value of html", "<llsd><array>" "<integer>23</integer>" "<html><body>ha ha</body></html>" "<real>1.23</real>" "</array></llsd>", v, v.size() + 1); v.clear(); v[0] = 23; v[1] = LLSD::emptyMap(); v[2] = 1.23; ensureParse( "array with map of html", "<llsd><array>" "<integer>23</integer>" "<map>" "<html><body>ha ha</body></html>" "</map>" "<real>1.23</real>" "</array></llsd>", v, v.size() + 1); } template<> template<> void TestLLSDXMLParsingObject::test<4>() { // test handling of binary object in XML std::string xml; LLSD expected; // Generated by: echo -n 'hello' | openssl enc -e -base64 expected = string_to_vector("hello"); xml = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n"; ensureParse( "the word 'hello' packed in binary encoded base64", xml, expected, 1); expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0"); xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n"; ensureParse( "a common binary blob for object -> agent offline inv transfer", xml, expected, 1); expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0"); xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBl\n"; xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5\n"; xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZm\n"; xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMy\n"; xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n"; ensureParse( "a common binary blob for object -> agent offline inv transfer", xml, expected, 1); } template<> template<> void TestLLSDXMLParsingObject::test<5>() { // test deeper nested levels LLSD level_5 = LLSD::emptyMap(); level_5["level_5"] = 42.f; LLSD level_4 = LLSD::emptyMap(); level_4["level_4"] = level_5; LLSD level_3 = LLSD::emptyMap(); level_3["level_3"] = level_4; LLSD level_2 = LLSD::emptyMap(); level_2["level_2"] = level_3; LLSD level_1 = LLSD::emptyMap(); level_1["level_1"] = level_2; LLSD level_0 = LLSD::emptyMap(); level_0["level_0"] = level_1; LLSD v; v["deep"] = level_0; ensureParse( "deep llsd xml map", "<llsd><map>" "<key>deep</key><map>" "<key>level_0</key><map>" "<key>level_1</key><map>" "<key>level_2</key><map>" "<key>level_3</key><map>" "<key>level_4</key><map>" "<key>level_5</key><real>42.0</real>" "</map>" "</map>" "</map>" "</map>" "</map>" "</map>" "</map></llsd>", v, 8); } /* TODO: test XML parsing binary with unrecognized encoding nested LLSD tags multiple values inside an LLSD */ /** * @class TestLLSDNotationParsing * @brief Concrete instance of a parse tester. */ class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser> { public: TestLLSDNotationParsing() {} }; typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup; typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject; TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup( "llsd notation parsing"); template<> template<> void TestLLSDNotationParsingObject::test<1>() { // test handling of xml not recognized as llsd results in an // LLSD Undefined ensureParse( "malformed notation map", "{'ha ha'", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "malformed notation array", "['ha ha'", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "malformed notation string", "'ha ha", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "bad notation noise", "g48ejlnfr", LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<2>() { ensureParse("valid undef", "!", LLSD(), 1); } template<> template<> void TestLLSDNotationParsingObject::test<3>() { LLSD val = false; ensureParse("valid boolean false 0", "false", val, 1); ensureParse("valid boolean false 1", "f", val, 1); ensureParse("valid boolean false 2", "0", val, 1); ensureParse("valid boolean false 3", "F", val, 1); ensureParse("valid boolean false 4", "FALSE", val, 1); val = true; ensureParse("valid boolean true 0", "true", val, 1); ensureParse("valid boolean true 1", "t", val, 1); ensureParse("valid boolean true 2", "1", val, 1); ensureParse("valid boolean true 3", "T", val, 1); ensureParse("valid boolean true 4", "TRUE", val, 1); val.clear(); ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE); ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<4>() { LLSD val = 123; ensureParse("valid integer", "i123", val, 1); val.clear(); ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<5>() { LLSD val = 456.7; ensureParse("valid real", "r456.7", val, 1); val.clear(); ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<6>() { LLUUID id; LLSD val = id; ensureParse( "unparseable uuid", "u123", LLSD(), LLSDParser::PARSE_FAILURE); id.generate(); val = id; std::string uuid_str("u"); uuid_str += id.asString(); ensureParse("valid uuid", uuid_str.c_str(), val, 1); } template<> template<> void TestLLSDNotationParsingObject::test<7>() { LLSD val = std::string("foolish"); ensureParse("valid string 1", "\"foolish\"", val, 1); val = std::string("g'day"); ensureParse("valid string 2", "\"g'day\"", val, 1); val = std::string("have a \"nice\" day"); ensureParse("valid string 3", "'have a \"nice\" day'", val, 1); val = std::string("whatever"); ensureParse("valid string 4", "s(8)\"whatever\"", val, 1); } template<> template<> void TestLLSDNotationParsingObject::test<8>() { ensureParse( "invalid string 1", "s(7)\"whatever\"", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "invalid string 2", "s(9)\"whatever\"", LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<9>() { LLSD val = LLURI("http://www.google.com"); ensureParse("valid uri", "l\"http://www.google.com\"", val, 1); } template<> template<> void TestLLSDNotationParsingObject::test<10>() { LLSD val = LLDate("2007-12-28T09:22:53.10Z"); ensureParse("valid date", "d\"2007-12-28T09:22:53.10Z\"", val, 1); } template<> template<> void TestLLSDNotationParsingObject::test<11>() { std::vector<U8> vec; vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c'); vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1'); LLSD val = vec; ensureParse("valid binary b64", "b64\"YWJjMzIx\"", val, 1); ensureParse("valid bainry b16", "b16\"616263333231\"", val, 1); ensureParse("valid bainry raw", "b(6)\"abc321\"", val, 1); } template<> template<> void TestLLSDNotationParsingObject::test<12>() { ensureParse( "invalid -- binary length specified too long", "b(7)\"abc321\"", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "invalid -- binary length specified way too long", "b(1000000)\"abc321\"", LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<13>() { LLSD val; val["amy"] = 23; val["bob"] = LLSD(); val["cam"] = 1.23; ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4); val["bob"] = LLSD::emptyMap(); val["bob"]["vehicle"] = std::string("bicycle"); ensureParse( "nested map", "{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}", val, 5); } template<> template<> void TestLLSDNotationParsingObject::test<14>() { LLSD val; val.append(23); val.append(LLSD()); val.append(1.23); ensureParse("simple array", "[i23,!,r1.23]", val, 4); val[1] = LLSD::emptyArray(); val[1].append("bicycle"); ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5); } template<> template<> void TestLLSDNotationParsingObject::test<15>() { LLSD val; val["amy"] = 23; val["bob"]["dogs"] = LLSD::emptyArray(); val["bob"]["dogs"].append(LLSD::emptyMap()); val["bob"]["dogs"][0]["name"] = std::string("groove"); val["bob"]["dogs"][0]["breed"] = std::string("samoyed"); val["bob"]["dogs"].append(LLSD::emptyMap()); val["bob"]["dogs"][1]["name"] = std::string("greyley"); val["bob"]["dogs"][1]["breed"] = std::string("chow/husky"); val["cam"] = 1.23; ensureParse( "nested notation", "{'amy':i23," " 'bob':{'dogs':[" "{'name':'groove', 'breed':'samoyed'}," "{'name':'greyley', 'breed':'chow/husky'}]}," " 'cam':r1.23}", val, 11); } template<> template<> void TestLLSDNotationParsingObject::test<16>() { // text to make sure that incorrect sizes bail because std::string bad_str("s(5)\"hi\""); ensureParse( "size longer than bytes left", bad_str, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<17>() { // text to make sure that incorrect sizes bail because std::string bad_bin("b(5)\"hi\""); ensureParse( "size longer than bytes left", bad_bin, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDNotationParsingObject::test<18>() { LLSD level_1 = LLSD::emptyMap(); level_1["level_2"] = 99; LLSD level_0 = LLSD::emptyMap(); level_0["level_1"] = level_1; LLSD deep = LLSD::emptyMap(); deep["level_0"] = level_0; LLSD root = LLSD::emptyMap(); root["deep"] = deep; ensureParse( "nested notation 3 deep", "{'deep' : {'level_0':{'level_1':{'level_2': i99} } } }", root, 5, 5); // 4 '{' plus i99 also counts as llsd, so real depth is 5 } template<> template<> void TestLLSDNotationParsingObject::test<19>() { LLSD level_9 = LLSD::emptyMap(); level_9["level_9"] = (S32)99; LLSD level_8 = LLSD::emptyMap(); level_8["level_8"] = level_9; LLSD level_7 = LLSD::emptyMap(); level_7["level_7"] = level_8; LLSD level_6 = LLSD::emptyMap(); level_6["level_6"] = level_7; LLSD level_5 = LLSD::emptyMap(); level_5["level_5"] = level_6; LLSD level_4 = LLSD::emptyMap(); level_4["level_4"] = level_5; LLSD level_3 = LLSD::emptyMap(); level_3["level_3"] = level_4; LLSD level_2 = LLSD::emptyMap(); level_2["level_2"] = level_3; LLSD level_1 = LLSD::emptyMap(); level_1["level_1"] = level_2; LLSD level_0 = LLSD::emptyMap(); level_0["level_0"] = level_1; LLSD deep = LLSD::emptyMap(); deep["deep"] = level_0; ensureParse( "nested notation 10 deep", "{'deep' : {'level_0':{'level_1':{'level_2':{'level_3':{'level_4':{'level_5':{'level_6':{'level_7':{'level_8':{'level_9':i99}" "} } } } } } } } } }", deep, 12, 15); } template<> template<> void TestLLSDNotationParsingObject::test<20>() { LLSD end = LLSD::emptyMap(); end["end"] = (S32)99; LLSD level_49 = LLSD::emptyMap(); level_49["level_49"] = end; LLSD level_48 = LLSD::emptyMap(); level_48["level_48"] = level_49; LLSD level_47 = LLSD::emptyMap(); level_47["level_47"] = level_48; LLSD level_46 = LLSD::emptyMap(); level_46["level_46"] = level_47; LLSD level_45 = LLSD::emptyMap(); level_45["level_45"] = level_46; LLSD level_44 = LLSD::emptyMap(); level_44["level_44"] = level_45; LLSD level_43 = LLSD::emptyMap(); level_43["level_43"] = level_44; LLSD level_42 = LLSD::emptyMap(); level_42["level_42"] = level_43; LLSD level_41 = LLSD::emptyMap(); level_41["level_41"] = level_42; LLSD level_40 = LLSD::emptyMap(); level_40["level_40"] = level_41; LLSD level_39 = LLSD::emptyMap(); level_39["level_39"] = level_40; LLSD level_38 = LLSD::emptyMap(); level_38["level_38"] = level_39; LLSD level_37 = LLSD::emptyMap(); level_37["level_37"] = level_38; LLSD level_36 = LLSD::emptyMap(); level_36["level_36"] = level_37; LLSD level_35 = LLSD::emptyMap(); level_35["level_35"] = level_36; LLSD level_34 = LLSD::emptyMap(); level_34["level_34"] = level_35; LLSD level_33 = LLSD::emptyMap(); level_33["level_33"] = level_34; LLSD level_32 = LLSD::emptyMap(); level_32["level_32"] = level_33; LLSD level_31 = LLSD::emptyMap(); level_31["level_31"] = level_32; LLSD level_30 = LLSD::emptyMap(); level_30["level_30"] = level_31; LLSD level_29 = LLSD::emptyMap(); level_29["level_29"] = level_30; LLSD level_28 = LLSD::emptyMap(); level_28["level_28"] = level_29; LLSD level_27 = LLSD::emptyMap(); level_27["level_27"] = level_28; LLSD level_26 = LLSD::emptyMap(); level_26["level_26"] = level_27; LLSD level_25 = LLSD::emptyMap(); level_25["level_25"] = level_26; LLSD level_24 = LLSD::emptyMap(); level_24["level_24"] = level_25; LLSD level_23 = LLSD::emptyMap(); level_23["level_23"] = level_24; LLSD level_22 = LLSD::emptyMap(); level_22["level_22"] = level_23; LLSD level_21 = LLSD::emptyMap(); level_21["level_21"] = level_22; LLSD level_20 = LLSD::emptyMap(); level_20["level_20"] = level_21; LLSD level_19 = LLSD::emptyMap(); level_19["level_19"] = level_20; LLSD level_18 = LLSD::emptyMap(); level_18["level_18"] = level_19; LLSD level_17 = LLSD::emptyMap(); level_17["level_17"] = level_18; LLSD level_16 = LLSD::emptyMap(); level_16["level_16"] = level_17; LLSD level_15 = LLSD::emptyMap(); level_15["level_15"] = level_16; LLSD level_14 = LLSD::emptyMap(); level_14["level_14"] = level_15; LLSD level_13 = LLSD::emptyMap(); level_13["level_13"] = level_14; LLSD level_12 = LLSD::emptyMap(); level_12["level_12"] = level_13; LLSD level_11 = LLSD::emptyMap(); level_11["level_11"] = level_12; LLSD level_10 = LLSD::emptyMap(); level_10["level_10"] = level_11; LLSD level_9 = LLSD::emptyMap(); level_9["level_9"] = level_10; LLSD level_8 = LLSD::emptyMap(); level_8["level_8"] = level_9; LLSD level_7 = LLSD::emptyMap(); level_7["level_7"] = level_8; LLSD level_6 = LLSD::emptyMap(); level_6["level_6"] = level_7; LLSD level_5 = LLSD::emptyMap(); level_5["level_5"] = level_6; LLSD level_4 = LLSD::emptyMap(); level_4["level_4"] = level_5; LLSD level_3 = LLSD::emptyMap(); level_3["level_3"] = level_4; LLSD level_2 = LLSD::emptyMap(); level_2["level_2"] = level_3; LLSD level_1 = LLSD::emptyMap(); level_1["level_1"] = level_2; LLSD level_0 = LLSD::emptyMap(); level_0["level_0"] = level_1; LLSD deep = LLSD::emptyMap(); deep["deep"] = level_0; ensureParse( "nested notation deep", "{'deep':" "{'level_0' :{'level_1' :{'level_2' :{'level_3' :{'level_4' :{'level_5' :{'level_6' :{'level_7' :{'level_8' :{'level_9' :" "{'level_10':{'level_11':{'level_12':{'level_13':{'level_14':{'level_15':{'level_16':{'level_17':{'level_18':{'level_19':" "{'level_20':{'level_21':{'level_22':{'level_23':{'level_24':{'level_25':{'level_26':{'level_27':{'level_28':{'level_29':" "{'level_30':{'level_31':{'level_32':{'level_33':{'level_34':{'level_35':{'level_36':{'level_37':{'level_38':{'level_39':" "{'level_40':{'level_41':{'level_42':{'level_43':{'level_44':{'level_45':{'level_46':{'level_47':{'level_48':{'level_49':" "{'end':i99}" "} } } } } } } } } }" "} } } } } } } } } }" "} } } } } } } } } }" "} } } } } } } } } }" "} } } } } } } } } }" "}", deep, 53); } template<> template<> void TestLLSDNotationParsingObject::test<21>() { ensureParse( "nested notation 10 deep", "{'deep' : {'level_0':{'level_1':{'level_2':{'level_3':{'level_4':{'level_5':{'level_6':{'level_7':{'level_8':{'level_9':i99}" "} } } } } } } } } }", LLSD(), LLSDParser::PARSE_FAILURE, 9); } /** * @class TestLLSDBinaryParsing * @brief Concrete instance of a parse tester. */ class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser> { public: TestLLSDBinaryParsing() {} }; typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup; typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject; TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup( "llsd binary parsing"); template<> template<> void TestLLSDBinaryParsingObject::test<1>() { std::vector<U8> vec; vec.resize(6); vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c'; vec[3] = '3'; vec[4] = '2'; vec[5] = '1'; std::string string_expected((char*)&vec[0], vec.size()); LLSD value = string_expected; vec.resize(11); vec[0] = 's'; // for string vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c'; vec[8] = '3'; vec[9] = '2'; vec[10] = '1'; uint32_t size = htonl(6); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_good((char*)&vec[0], vec.size()); ensureParse("correct string parse", str_good, value, 1); size = htonl(7); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_1((char*)&vec[0], vec.size()); ensureParse( "incorrect size string parse", str_bad_1, LLSD(), LLSDParser::PARSE_FAILURE); size = htonl(100000); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_2((char*)&vec[0], vec.size()); ensureParse( "incorrect size string parse", str_bad_2, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<2>() { std::vector<U8> vec; vec.resize(6); vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c'; vec[3] = '3'; vec[4] = '2'; vec[5] = '1'; LLSD value = vec; vec.resize(11); vec[0] = 'b'; // for binary vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c'; vec[8] = '3'; vec[9] = '2'; vec[10] = '1'; uint32_t size = htonl(6); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_good((char*)&vec[0], vec.size()); ensureParse("correct binary parse", str_good, value, 1); size = htonl(7); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_1((char*)&vec[0], vec.size()); ensureParse( "incorrect size binary parse 1", str_bad_1, LLSD(), LLSDParser::PARSE_FAILURE); size = htonl(100000); memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_2((char*)&vec[0], vec.size()); ensureParse( "incorrect size binary parse 2", str_bad_2, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<3>() { // test handling of xml not recognized as llsd results in an // LLSD Undefined ensureParse( "malformed binary map", "{'ha ha'", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "malformed binary array", "['ha ha'", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "malformed binary string", "'ha ha", LLSD(), LLSDParser::PARSE_FAILURE); ensureParse( "bad noise", "g48ejlnfr", LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<4>() { ensureParse("valid undef", "!", LLSD(), 1); } template<> template<> void TestLLSDBinaryParsingObject::test<5>() { LLSD val = false; ensureParse("valid boolean false 2", "0", val, 1); val = true; ensureParse("valid boolean true 2", "1", val, 1); val.clear(); ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE); ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<6>() { std::vector<U8> vec; vec.push_back('{'); vec.resize(vec.size() + 4); uint32_t size = htonl(1); memcpy(&vec[1], &size, sizeof(uint32_t)); vec.push_back('k'); int key_size_loc = vec.size(); size = htonl(1); // 1 too short vec.resize(vec.size() + 4); memcpy(&vec[key_size_loc], &size, sizeof(uint32_t)); vec.push_back('a'); vec.push_back('m'); vec.push_back('y'); vec.push_back('i'); int integer_loc = vec.size(); vec.resize(vec.size() + 4); uint32_t val_int = htonl(23); memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t)); std::string str_bad_1((char*)&vec[0], vec.size()); ensureParse( "invalid key size", str_bad_1, LLSD(), LLSDParser::PARSE_FAILURE); // check with correct size, but unterminated map (missing '}') size = htonl(3); // correct size memcpy(&vec[key_size_loc], &size, sizeof(uint32_t)); std::string str_bad_2((char*)&vec[0], vec.size()); ensureParse( "valid key size, unterminated map", str_bad_2, LLSD(), LLSDParser::PARSE_FAILURE); // check w/ correct size and correct map termination LLSD val; val["amy"] = 23; vec.push_back('}'); std::string str_good((char*)&vec[0], vec.size()); ensureParse( "valid map", str_good, val, 2); // check w/ incorrect sizes and correct map termination size = htonl(0); // 1 too few (for the map entry) memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_3((char*)&vec[0], vec.size()); ensureParse( "invalid map too long", str_bad_3, LLSD(), LLSDParser::PARSE_FAILURE); size = htonl(2); // 1 too many memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_4((char*)&vec[0], vec.size()); ensureParse( "invalid map too short", str_bad_4, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<7>() { std::vector<U8> vec; vec.push_back('['); vec.resize(vec.size() + 4); uint32_t size = htonl(1); // 1 too short memcpy(&vec[1], &size, sizeof(uint32_t)); vec.push_back('"'); vec.push_back('a'); vec.push_back('m'); vec.push_back('y'); vec.push_back('"'); vec.push_back('i'); int integer_loc = vec.size(); vec.resize(vec.size() + 4); uint32_t val_int = htonl(23); memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t)); std::string str_bad_1((char*)&vec[0], vec.size()); ensureParse( "invalid array size", str_bad_1, LLSD(), LLSDParser::PARSE_FAILURE); // check with correct size, but unterminated map (missing ']') size = htonl(2); // correct size memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_2((char*)&vec[0], vec.size()); ensureParse( "unterminated array", str_bad_2, LLSD(), LLSDParser::PARSE_FAILURE); // check w/ correct size and correct map termination LLSD val; val.append("amy"); val.append(23); vec.push_back(']'); std::string str_good((char*)&vec[0], vec.size()); ensureParse( "valid array", str_good, val, 3); // check with too many elements size = htonl(3); // 1 too long memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_bad_3((char*)&vec[0], vec.size()); ensureParse( "array too short", str_bad_3, LLSD(), LLSDParser::PARSE_FAILURE); } template<> template<> void TestLLSDBinaryParsingObject::test<8>() { std::vector<U8> vec; vec.push_back('{'); vec.resize(vec.size() + 4); memset(&vec[1], 0, 4); vec.push_back('}'); std::string str_good((char*)&vec[0], vec.size()); LLSD val = LLSD::emptyMap(); ensureParse( "empty map", str_good, val, 1); } template<> template<> void TestLLSDBinaryParsingObject::test<9>() { std::vector<U8> vec; vec.push_back('['); vec.resize(vec.size() + 4); memset(&vec[1], 0, 4); vec.push_back(']'); std::string str_good((char*)&vec[0], vec.size()); LLSD val = LLSD::emptyArray(); ensureParse( "empty array", str_good, val, 1); } template<> template<> void TestLLSDBinaryParsingObject::test<10>() { std::vector<U8> vec; vec.push_back('l'); vec.resize(vec.size() + 4); uint32_t size = htonl(14); // 1 too long memcpy(&vec[1], &size, sizeof(uint32_t)); vec.push_back('h'); vec.push_back('t'); vec.push_back('t'); vec.push_back('p'); vec.push_back(':'); vec.push_back('/'); vec.push_back('/'); vec.push_back('s'); vec.push_back('l'); vec.push_back('.'); vec.push_back('c'); vec.push_back('o'); vec.push_back('m'); std::string str_bad((char*)&vec[0], vec.size()); ensureParse( "invalid uri length size", str_bad, LLSD(), LLSDParser::PARSE_FAILURE); LLSD val; val = LLURI("http://sl.com"); size = htonl(13); // correct length memcpy(&vec[1], &size, sizeof(uint32_t)); std::string str_good((char*)&vec[0], vec.size()); ensureParse( "valid key size", str_good, val, 1); } /* template<> template<> void TestLLSDBinaryParsingObject::test<11>() { } */ /** * @class TestLLSDCrossCompatible * @brief Miscellaneous serialization and parsing tests */ class TestLLSDCrossCompatible { public: TestLLSDCrossCompatible() {} void ensureBinaryAndNotation( const std::string& msg, const LLSD& input) { // to binary, and back again std::stringstream str1; S32 count1 = LLSDSerialize::toBinary(input, str1); LLSD actual_value_bin; S32 count2 = LLSDSerialize::fromBinary( actual_value_bin, str1, LLSDSerialize::SIZE_UNLIMITED); ensure_equals( "ensureBinaryAndNotation binary count", count2, count1); // to notation and back again std::stringstream str2; S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2); ensure_equals( "ensureBinaryAndNotation notation count1", count3, count2); LLSD actual_value_notation; S32 count4 = LLSDSerialize::fromNotation( actual_value_notation, str2, LLSDSerialize::SIZE_UNLIMITED); ensure_equals( "ensureBinaryAndNotation notation count2", count4, count3); ensure_equals( (msg + " (binaryandnotation)").c_str(), actual_value_notation, input); } void ensureBinaryAndXML( const std::string& msg, const LLSD& input) { // to binary, and back again std::stringstream str1; S32 count1 = LLSDSerialize::toBinary(input, str1); LLSD actual_value_bin; S32 count2 = LLSDSerialize::fromBinary( actual_value_bin, str1, LLSDSerialize::SIZE_UNLIMITED); ensure_equals( "ensureBinaryAndXML binary count", count2, count1); // to xml and back again std::stringstream str2; S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2); ensure_equals( "ensureBinaryAndXML xml count1", count3, count2); LLSD actual_value_xml; S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2); ensure_equals( "ensureBinaryAndXML xml count2", count4, count3); ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input); } }; typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup; typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject; TestLLSDCompatibleGroup gTestLLSDCompatibleGroup( "llsd serialize compatible"); template<> template<> void TestLLSDCompatibleObject::test<1>() { LLSD test; ensureBinaryAndNotation("undef", test); ensureBinaryAndXML("undef", test); test = true; ensureBinaryAndNotation("boolean true", test); ensureBinaryAndXML("boolean true", test); test = false; ensureBinaryAndNotation("boolean false", test); ensureBinaryAndXML("boolean false", test); test = 0; ensureBinaryAndNotation("integer zero", test); ensureBinaryAndXML("integer zero", test); test = 1; ensureBinaryAndNotation("integer positive", test); ensureBinaryAndXML("integer positive", test); test = -234567; ensureBinaryAndNotation("integer negative", test); ensureBinaryAndXML("integer negative", test); test = 0.0; ensureBinaryAndNotation("real zero", test); ensureBinaryAndXML("real zero", test); test = 1.0; ensureBinaryAndNotation("real positive", test); ensureBinaryAndXML("real positive", test); test = -1.0; ensureBinaryAndNotation("real negative", test); ensureBinaryAndXML("real negative", test); } template<> template<> void TestLLSDCompatibleObject::test<2>() { LLSD test; test = "foobar"; ensureBinaryAndNotation("string", test); ensureBinaryAndXML("string", test); } template<> template<> void TestLLSDCompatibleObject::test<3>() { LLSD test; LLUUID id; id.generate(); test = id; ensureBinaryAndNotation("uuid", test); ensureBinaryAndXML("uuid", test); } template<> template<> void TestLLSDCompatibleObject::test<4>() { LLSD test; test = LLDate(12345.0); ensureBinaryAndNotation("date", test); ensureBinaryAndXML("date", test); } template<> template<> void TestLLSDCompatibleObject::test<5>() { LLSD test; test = LLURI("http://www.secondlife.com/"); ensureBinaryAndNotation("uri", test); ensureBinaryAndXML("uri", test); } template<> template<> void TestLLSDCompatibleObject::test<6>() { LLSD test; typedef std::vector<U8> buf_t; buf_t val; for(int ii = 0; ii < 100; ++ii) { srand(ii); /* Flawfinder: ignore */ S32 size = rand() % 100 + 10; std::generate_n( std::back_insert_iterator<buf_t>(val), size, rand); } test = val; ensureBinaryAndNotation("binary", test); ensureBinaryAndXML("binary", test); } template<> template<> void TestLLSDCompatibleObject::test<7>() { LLSD test; test = LLSD::emptyArray(); test.append(1); test.append("hello"); ensureBinaryAndNotation("array", test); ensureBinaryAndXML("array", test); } template<> template<> void TestLLSDCompatibleObject::test<8>() { LLSD test; test = LLSD::emptyArray(); test["foo"] = "bar"; test["baz"] = 100; ensureBinaryAndNotation("map", test); ensureBinaryAndXML("map", test); } // helper for TestPythonCompatible static std::string import_llsd("import os.path\n" "import sys\n" "import llsd\n"); // helper for TestPythonCompatible template <typename CONTENT, typename... ARGS> void python_expect(const std::string& desc, const CONTENT& script, int expect=0, ARGS&&... args) { auto PYTHON(LLStringUtil::getenv("PYTHON")); ensure("Set $PYTHON to the Python interpreter", !PYTHON.empty()); NamedTempFile scriptfile("py", script); #if LL_WINDOWS std::string q("\""); std::string qPYTHON(q + PYTHON + q); std::string qscript(q + scriptfile.getName() + q); int rc = _spawnl(_P_WAIT, PYTHON.c_str(), qPYTHON.c_str(), qscript.c_str(), std::forward<ARGS>(args)..., NULL); if (rc == -1) { char buffer[256]; strerror_s(buffer, errno); // C++ can infer the buffer size! :-O ensure(STRINGIZE("Couldn't run Python " << desc << "script: " << buffer), false); } else { ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, expect); } #else // LL_DARWIN, LL_LINUX LLProcess::Params params; params.executable = PYTHON; params.args.add(scriptfile.getName()); for (const std::string& arg : StringVec{ std::forward<ARGS>(args)... }) { params.args.add(arg); } LLProcessPtr py(LLProcess::create(params)); ensure(STRINGIZE("Couldn't launch " << desc << " script"), bool(py)); // Implementing timeout would mean messing with alarm() and // catching SIGALRM... later maybe... int status(0); if (waitpid(py->getProcessID(), &status, 0) == -1) { int waitpid_errno(errno); ensure_equals(STRINGIZE("Couldn't retrieve rc from " << desc << " script: " "waitpid() errno " << waitpid_errno), waitpid_errno, ECHILD); } else { if (WIFEXITED(status)) { int rc(WEXITSTATUS(status)); ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, expect); } else if (WIFSIGNALED(status)) { ensure(STRINGIZE(desc << " script terminated by signal " << WTERMSIG(status)), false); } else { ensure(STRINGIZE(desc << " script produced impossible status " << status), false); } } #endif } // helper for TestPythonCompatible template <typename CONTENT, typename... ARGS> void python(const std::string& desc, const CONTENT& script, ARGS&&... args) { // plain python() expects rc 0 python_expect(desc, script, 0, std::forward<ARGS>(args)...); } struct TestPythonCompatible { TestPythonCompatible() {} ~TestPythonCompatible() {} }; typedef tut::test_group<TestPythonCompatible> TestPythonCompatibleGroup; typedef TestPythonCompatibleGroup::object TestPythonCompatibleObject; TestPythonCompatibleGroup pycompat("LLSD serialize Python compatibility"); template<> template<> void TestPythonCompatibleObject::test<1>() { set_test_name("verify python()"); python_expect("hello", "import sys\n" "sys.exit(17)\n", 17); // expect nonzero rc } template<> template<> void TestPythonCompatibleObject::test<2>() { set_test_name("verify NamedTempFile"); python("platform", "import sys\n" "print('Running on', sys.platform)\n"); } // helper for test<3> - test<7> static void writeLLSDArray(const FormatterFunction& serialize, std::ostream& out, const LLSD& array) { for (const LLSD& item: llsd::inArray(array)) { // It's important to delimit the entries in this file somehow // because, although Python's llsd.parse() can accept a file // stream, the XML parser expects EOF after a single outer element // -- it doesn't just stop. So we must extract a sequence of bytes // strings from the file. But since one of the serialization // formats we want to test is binary, we can't pick any single // byte value as a delimiter! Use a binary integer length prefix // instead. std::ostringstream buffer; serialize(item, buffer); auto buffstr{ buffer.str() }; int bufflen{ static_cast<int>(buffstr.length()) }; out.write(reinterpret_cast<const char*>(&bufflen), sizeof(bufflen)); LL_DEBUGS() << "Wrote length: " << hexdump(reinterpret_cast<const char*>(&bufflen), sizeof(bufflen)) << LL_ENDL; out.write(buffstr.c_str(), buffstr.length()); LL_DEBUGS() << "Wrote data: " << hexmix(buffstr.c_str(), buffstr.length()) << LL_ENDL; } } // helper for test<3> - test<7> static void toPythonUsing(const std::string& desc, const FormatterFunction& serialize) { LLSD cdata(llsd::array(17, 3.14, "This string\n" "has several\n" "lines.")); const char pydata[] = "def verify(iterable):\n" " it = iter(iterable)\n" " assert next(it) == 17\n" " assert abs(next(it) - 3.14) < 0.01\n" " assert next(it) == '''\\\n" "This string\n" "has several\n" "lines.'''\n" " try:\n" " next(it)\n" " except StopIteration:\n" " pass\n" " else:\n" " raise AssertionError('Too many data items')\n"; // Create an llsdXXXXXX file containing 'data' serialized per // FormatterFunction. NamedTempFile file("llsd", // NamedTempFile's function constructor // takes a callable. To this callable it passes the // std::ostream with which it's writing the // NamedTempFile. [serialize, cdata] (std::ostream& out) { writeLLSDArray(serialize, out, cdata); }); // 'debug' starts empty because it's intended as an output file NamedTempFile debug("debug", ""); try { python("read C++ " + desc, [&](std::ostream& out){ out << import_llsd << "from functools import partial\n" "import io\n" "import struct\n" "lenformat = struct.Struct('i')\n" "def parse_each(inf):\n" " for rawlen in iter(partial(inf.read, lenformat.size), b''):\n" " print('Read length:', ''.join(('%02x' % b) for b in rawlen),\n" " file=debug)\n" " len = lenformat.unpack(rawlen)[0]\n" // Since llsd.parse() has no max_bytes argument, instead of // passing the input stream directly to parse(), read the item // into a distinct bytes object and parse that. " data = inf.read(len)\n" " print('Read data: ', repr(data), file=debug)\n" " try:\n" " frombytes = llsd.parse(data)\n" " except llsd.LLSDParseError as err:\n" " print(f'*** {err}')\n" " print(f'Bad content:\\n{data!r}')\n" " raise\n" // Also try parsing from a distinct stream. " stream = io.BytesIO(data)\n" " fromstream = llsd.parse(stream)\n" " assert frombytes == fromstream\n" " yield frombytes\n" << pydata << // Don't forget raw-string syntax for Windows pathnames. "debug = open(r'" << debug.getName() << "', 'w')\n" "verify(parse_each(open(r'" << file.getName() << "', 'rb')))\n";}); } catch (const failure&) { LL_DEBUGS() << "Script debug output:" << LL_ENDL; debug.peep_log(); throw; } } template<> template<> void TestPythonCompatibleObject::test<3>() { set_test_name("to Python using LLSDSerialize::serialize(LLSD_XML)"); toPythonUsing("LLSD_XML", [](const LLSD& sd, std::ostream& out) { LLSDSerialize::serialize(sd, out, LLSDSerialize::LLSD_XML); }); } template<> template<> void TestPythonCompatibleObject::test<4>() { set_test_name("to Python using LLSDSerialize::serialize(LLSD_NOTATION)"); toPythonUsing("LLSD_NOTATION", [](const LLSD& sd, std::ostream& out) { LLSDSerialize::serialize(sd, out, LLSDSerialize::LLSD_NOTATION); }); } template<> template<> void TestPythonCompatibleObject::test<5>() { set_test_name("to Python using LLSDSerialize::serialize(LLSD_BINARY)"); toPythonUsing("LLSD_BINARY", [](const LLSD& sd, std::ostream& out) { LLSDSerialize::serialize(sd, out, LLSDSerialize::LLSD_BINARY); }); } template<> template<> void TestPythonCompatibleObject::test<6>() { set_test_name("to Python using LLSDSerialize::toXML()"); toPythonUsing("toXML()", LLSDSerialize::toXML); } template<> template<> void TestPythonCompatibleObject::test<7>() { set_test_name("to Python using LLSDSerialize::toNotation()"); toPythonUsing("toNotation()", LLSDSerialize::toNotation); } /*==========================================================================*| template<> template<> void TestPythonCompatibleObject::test<8>() { set_test_name("to Python using LLSDSerialize::toBinary()"); // We don't expect this to work because, without a header, // llsd.parse() will assume notation rather than binary. toPythonUsing("toBinary()", LLSDSerialize::toBinary); } |*==========================================================================*/ // helper for test<8> - test<12> bool itemFromStream(std::istream& istr, LLSD& item, const ParserFunction& parse) { // reset the output value for debugging clarity item.clear(); // We use an int length prefix as a foolproof delimiter even for // binary serialized streams. int length{ 0 }; istr.read(reinterpret_cast<char*>(&length), sizeof(length)); // return parse(istr, item, length); // Sadly, as of 2022-12-01 it seems we can't really trust our LLSD // parsers to honor max_bytes: this test works better when we read // each item into its own distinct LLMemoryStream, instead of passing // the original istr with a max_bytes constraint. std::vector<U8> buffer(length); istr.read(reinterpret_cast<char*>(buffer.data()), length); LLMemoryStream stream(buffer.data(), length); return parse(stream, item, length); } // helper for test<8> - test<12> void fromPythonUsing(const std::string& pyformatter, const ParserFunction& parse= [](std::istream& istr, LLSD& data, llssize max_bytes) { return LLSDSerialize::deserialize(data, istr, max_bytes); }) { // Create an empty data file. This is just a placeholder for our // script to write into. Create it to establish a unique name that // we know. NamedTempFile file("llsd", ""); python("Python " + pyformatter, [&](std::ostream& out){ out << import_llsd << "import struct\n" "lenformat = struct.Struct('i')\n" "DATA = [\n" " 17,\n" " 3.14,\n" " '''\\\n" "This string\n" "has several\n" "lines.''',\n" "]\n" // Don't forget raw-string syntax for Windows pathnames. // N.B. Using 'print' implicitly adds newlines. "with open(r'" << file.getName() << "', 'wb') as f:\n" " for item in DATA:\n" " serialized = llsd." << pyformatter << "(item)\n" " f.write(lenformat.pack(len(serialized)))\n" " f.write(serialized)\n";}); std::ifstream inf(file.getName().c_str()); LLSD item; try { ensure("Failed to read LLSD::Integer from Python", itemFromStream(inf, item, parse)); ensure_equals(item.asInteger(), 17); ensure("Failed to read LLSD::Real from Python", itemFromStream(inf, item, parse)); ensure_approximately_equals("Bad LLSD::Real value from Python", item.asReal(), 3.14, 7); // 7 bits ~= 0.01 ensure("Failed to read LLSD::String from Python", itemFromStream(inf, item, parse)); ensure_equals(item.asString(), "This string\n" "has several\n" "lines."); } catch (const tut::failure& err) { std::cout << "for " << err.what() << ", item = " << item << std::endl; throw; } } template<> template<> void TestPythonCompatibleObject::test<8>() { set_test_name("from Python XML using LLSDSerialize::deserialize()"); fromPythonUsing("format_xml"); } template<> template<> void TestPythonCompatibleObject::test<9>() { set_test_name("from Python notation using LLSDSerialize::deserialize()"); fromPythonUsing("format_notation"); } template<> template<> void TestPythonCompatibleObject::test<10>() { set_test_name("from Python binary using LLSDSerialize::deserialize()"); fromPythonUsing("format_binary"); } template<> template<> void TestPythonCompatibleObject::test<11>() { set_test_name("from Python XML using fromXML()"); // fromXML()'s optional 3rd param isn't max_bytes, it's emit_errors fromPythonUsing("format_xml", [](std::istream& istr, LLSD& data, llssize) { return LLSDSerialize::fromXML(data, istr) > 0; }); } template<> template<> void TestPythonCompatibleObject::test<12>() { set_test_name("from Python notation using fromNotation()"); fromPythonUsing("format_notation", [](std::istream& istr, LLSD& data, llssize max_bytes) { return LLSDSerialize::fromNotation(data, istr, max_bytes) > 0; }); } /*==========================================================================*| template<> template<> void TestPythonCompatibleObject::test<13>() { set_test_name("from Python binary using fromBinary()"); // We don't expect this to work because format_binary() emits a // header, but fromBinary() won't recognize a header. fromPythonUsing("format_binary", [](std::istream& istr, LLSD& data, llssize max_bytes) { return LLSDSerialize::fromBinary(data, istr, max_bytes) > 0; }); } |*==========================================================================*/ }