summaryrefslogtreecommitdiff
path: root/indra/llmessage/tests
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llmessage/tests')
-rw-r--r--indra/llmessage/tests/llhost_test.cpp247
-rw-r--r--indra/llmessage/tests/llmime_test.cpp451
-rw-r--r--indra/llmessage/tests/llnamevalue_test.cpp412
3 files changed, 1110 insertions, 0 deletions
diff --git a/indra/llmessage/tests/llhost_test.cpp b/indra/llmessage/tests/llhost_test.cpp
new file mode 100644
index 0000000000..5dc9ce42ee
--- /dev/null
+++ b/indra/llmessage/tests/llhost_test.cpp
@@ -0,0 +1,247 @@
+/**
+ * @file llhost_tut.cpp
+ * @author Adroit
+ * @date 2007-02
+ * @brief llhost test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ *
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab. Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "../llhost.h"
+
+#include "../test/lltut.h"
+
+namespace tut
+{
+ struct host_data
+ {
+ };
+ typedef test_group<host_data> host_test;
+ typedef host_test::object host_object;
+ tut::host_test host_testcase("llhost");
+
+
+ template<> template<>
+ void host_object::test<1>()
+ {
+ LLHost host;
+ ensure("IP address is not NULL", (0 == host.getAddress()) && (0 == host.getPort()) && !host.isOk());
+ }
+ template<> template<>
+ void host_object::test<2>()
+ {
+ U32 ip_addr = 0xc098017d;
+ U32 port = 8080;
+ LLHost host(ip_addr, port);
+ ensure("IP address is invalid", ip_addr == host.getAddress());
+ ensure("Port Number is invalid", port == host.getPort());
+ ensure("IP address and port number both should be ok", host.isOk());
+ }
+
+ template<> template<>
+ void host_object::test<3>()
+ {
+ const char* str = "192.168.1.1";
+ U32 port = 8080;
+ LLHost host(str, port);
+ ensure("IP address could not be processed", (host.getAddress() == ip_string_to_u32(str)));
+ ensure("Port Number is invalid", (port == host.getPort()));
+ }
+
+ template<> template<>
+ void host_object::test<4>()
+ {
+ U32 ip = ip_string_to_u32("192.168.1.1");
+ U32 port = 22;
+ U64 ip_port = (((U64) ip) << 32) | port;
+ LLHost host(ip_port);
+ ensure("IP address is invalid", ip == host.getAddress());
+ ensure("Port Number is invalid", port == host.getPort());
+ }
+
+ template<> template<>
+ void host_object::test<5>()
+ {
+ std::string ip_port_string = "192.168.1.1:8080";
+ U32 ip = ip_string_to_u32("192.168.1.1");
+ U32 port = 8080;
+
+ LLHost host(ip_port_string);
+ ensure("IP address from IP:port is invalid", ip == host.getAddress());
+ ensure("Port Number from from IP:port is invalid", port == host.getPort());
+ }
+
+ template<> template<>
+ void host_object::test<6>()
+ {
+ U32 ip = 0xc098017d, port = 8080;
+ LLHost host;
+ host.set(ip,port);
+ ensure("IP address is invalid", (ip == host.getAddress()));
+ ensure("Port Number is invalid", (port == host.getPort()));
+ }
+
+ template<> template<>
+ void host_object::test<7>()
+ {
+ const char* str = "192.168.1.1";
+ U32 port = 8080, ip;
+ LLHost host;
+ host.set(str,port);
+ ip = ip_string_to_u32(str);
+ ensure("IP address is invalid", (ip == host.getAddress()));
+ ensure("Port Number is invalid", (port == host.getPort()));
+
+ str = "64.233.187.99";
+ ip = ip_string_to_u32(str);
+ host.setAddress(str);
+ ensure("IP address is invalid", (ip == host.getAddress()));
+
+ ip = 0xc098017b;
+ host.setAddress(ip);
+ ensure("IP address is invalid", (ip == host.getAddress()));
+ // should still use the old port
+ ensure("Port Number is invalid", (port == host.getPort()));
+
+ port = 8084;
+ host.setPort(port);
+ ensure("Port Number is invalid", (port == host.getPort()));
+ // should still use the old address
+ ensure("IP address is invalid", (ip == host.getAddress()));
+ }
+
+ template<> template<>
+ void host_object::test<8>()
+ {
+ const std::string str("192.168.1.1");
+ U32 port = 8080;
+ LLHost host;
+ host.set(str,port);
+
+ std::string ip_string = host.getIPString();
+ ensure("Function Failed", (ip_string == str));
+
+ std::string ip_string_port = host.getIPandPort();
+ ensure("Function Failed", (ip_string_port == "192.168.1.1:8080"));
+ }
+
+
+// getHostName() and setHostByName
+ template<> template<>
+ void host_object::test<9>()
+ {
+ std::string hostStr = "google.com";
+ LLHost host;
+ host.setHostByName(hostStr);
+
+ // reverse DNS will likely result in appending of some
+ // sub-domain to the main hostname. so look for
+ // the main domain name and not do the exact compare
+
+ std::string hostname = host.getHostName();
+ ensure("getHostName failed", hostname.find(hostStr) != std::string::npos);
+ }
+
+// setHostByName for dotted IP
+ template<> template<>
+ void host_object::test<10>()
+ {
+ std::string hostStr = "64.233.167.99";
+ LLHost host;
+ host.setHostByName(hostStr);
+ ensure("SetHostByName for dotted IP Address failed", host.getAddress() == ip_string_to_u32(hostStr.c_str()));
+ }
+
+ template<> template<>
+ void host_object::test<11>()
+ {
+ LLHost host1(0xc098017d, 8080);
+ LLHost host2 = host1;
+ ensure("Both IP addresses are not same", (host1.getAddress() == host2.getAddress()));
+ ensure("Both port numbers are not same", (host1.getPort() == host2.getPort()));
+ }
+
+ template<> template<>
+ void host_object::test<12>()
+ {
+ LLHost host1("192.168.1.1", 8080);
+ std::string str1 = "192.168.1.1:8080";
+ std::ostringstream stream;
+ stream << host1;
+ ensure("Operator << failed", ( stream.str()== str1));
+
+ // There is no istream >> llhost operator.
+ //std::istringstream is(stream.str());
+ //LLHost host2;
+ //is >> host2;
+ //ensure("Operator >> failed. Not compatible with <<", host1 == host2);
+ }
+
+ // operators ==, !=, <
+ template<> template<>
+ void host_object::test<13>()
+ {
+ U32 ip_addr = 0xc098017d;
+ U32 port = 8080;
+ LLHost host1(ip_addr, port);
+ LLHost host2(ip_addr, port);
+ ensure("operator== failed", host1 == host2);
+
+ // change port
+ host2.setPort(7070);
+ ensure("operator!= failed", host1 != host2);
+
+ // set port back to 8080 and change IP address now
+ host2.setPort(8080);
+ host2.setAddress(ip_addr+10);
+ ensure("operator!= failed", host1 != host2);
+
+ ensure("operator< failed", host1 < host2);
+
+ // set IP address back to same value and change port
+ host2.setAddress(ip_addr);
+ host2.setPort(host1.getPort() + 10);
+ ensure("operator< failed", host1 < host2);
+ }
+
+ // invalid ip address string
+ template<> template<>
+ void host_object::test<14>()
+ {
+ LLHost host1("10.0.1.2", 6143);
+ ensure("10.0.1.2 should be a valid address", host1.isOk());
+
+ LLHost host2("booger-brains", 6143);
+ ensure("booger-brains should be an invalid ip addess", !host2.isOk());
+
+ LLHost host3("255.255.255.255", 6143);
+ ensure("255.255.255.255 should be valid broadcast address", host3.isOk());
+ }
+}
diff --git a/indra/llmessage/tests/llmime_test.cpp b/indra/llmessage/tests/llmime_test.cpp
new file mode 100644
index 0000000000..62a84d34c0
--- /dev/null
+++ b/indra/llmessage/tests/llmime_test.cpp
@@ -0,0 +1,451 @@
+/**
+ * @file llmime_tut.cpp
+ * @author Phoenix
+ * @date 2006-12-24
+ * @brief BRIEF_DESC of llmime_tut.cpp
+ *
+ * $LicenseInfo:firstyear=2006&license=viewergpl$
+ *
+ * Copyright (c) 2006-2009, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab. Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llsdserialize.h"
+
+#include "../llmime.h"
+
+#include "../test/lltut.h"
+
+namespace tut
+{
+ struct mime_index
+ {
+ };
+ typedef test_group<mime_index> mime_index_t;
+ typedef mime_index_t::object mime_index_object_t;
+ tut::mime_index_t tut_mime_index("mime_index");
+
+ template<> template<>
+ void mime_index_object_t::test<1>()
+ {
+ LLMimeIndex mime;
+ ensure("no headers", mime.headers().isUndefined());
+ ensure_equals("invalid offset", mime.offset(), -1);
+ ensure_equals("invalid content length", mime.contentLength(), -1);
+ ensure("no content type", mime.contentType().empty());
+ ensure("not multipart", !mime.isMultipart());
+ ensure_equals("no attachments", mime.subPartCount(), 0);
+ }
+
+ template<> template<>
+ void mime_index_object_t::test<2>()
+ {
+ const S32 CONTENT_LENGTH = 6000;
+ const S32 CONTENT_OFFSET = 100;
+ const std::string CONTENT_TYPE = std::string("image/j2c");
+ LLSD headers;
+ headers["Content-Length"] = CONTENT_LENGTH;
+ headers["Content-Type"] = CONTENT_TYPE;
+ LLMimeIndex mime(headers, CONTENT_OFFSET);
+ ensure("headers are map", mime.headers().isMap());
+ ensure_equals("offset", mime.offset(), CONTENT_OFFSET);
+ ensure_equals("content length", mime.contentLength(), CONTENT_LENGTH);
+ ensure_equals("type is image/j2c", mime.contentType(), CONTENT_TYPE);
+ ensure("not multipart", !mime.isMultipart());
+ ensure_equals("no attachments", mime.subPartCount(), 0);
+ }
+
+ template<> template<>
+ void mime_index_object_t::test<3>()
+ {
+ const S32 MULTI_CONTENT_LENGTH = 8000;
+ const S32 MULTI_CONTENT_OFFSET = 100;
+ const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
+ LLSD headers;
+ headers["Content-Length"] = MULTI_CONTENT_LENGTH;
+ headers["Content-Type"] = MULTI_CONTENT_TYPE;
+ LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
+ llinfos << "headers: " << LLSDOStreamer<LLSDNotationFormatter>(headers)
+ << llendl;
+
+
+ const S32 META_CONTENT_LENGTH = 700;
+ const S32 META_CONTENT_OFFSET = 69;
+ const std::string META_CONTENT_TYPE = std::string(
+ "text/llsd+xml");
+ headers = LLSD::emptyMap();
+ headers["Content-Length"] = META_CONTENT_LENGTH;
+ headers["Content-Type"] = META_CONTENT_TYPE;
+ LLMimeIndex meta(headers, META_CONTENT_OFFSET);
+ mime.attachSubPart(meta);
+
+ const S32 IMAGE_CONTENT_LENGTH = 6000;
+ const S32 IMAGE_CONTENT_OFFSET = 200;
+ const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
+ headers = LLSD::emptyMap();
+ headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
+ headers["Content-Type"] = IMAGE_CONTENT_TYPE;
+ LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
+ mime.attachSubPart(image);
+
+ // make sure we have a valid multi-part
+ ensure("is multipart", mime.isMultipart());
+ ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
+ ensure_equals(
+ "multi content length",
+ mime.contentLength(),
+ MULTI_CONTENT_LENGTH);
+ ensure_equals("two attachments", mime.subPartCount(), 2);
+
+ // make sure ranged gets do the right thing with out of bounds
+ // sub-parts.
+ LLMimeIndex invalid_child(mime.subPart(-1));
+ ensure("no headers", invalid_child.headers().isUndefined());
+ ensure_equals("invalid offset", invalid_child.offset(), -1);
+ ensure_equals(
+ "invalid content length", invalid_child.contentLength(), -1);
+ ensure("no content type", invalid_child.contentType().empty());
+ ensure("not multipart", !invalid_child.isMultipart());
+ ensure_equals("no attachments", invalid_child.subPartCount(), 0);
+
+ invalid_child = mime.subPart(2);
+ ensure("no headers", invalid_child.headers().isUndefined());
+ ensure_equals("invalid offset", invalid_child.offset(), -1);
+ ensure_equals(
+ "invalid content length", invalid_child.contentLength(), -1);
+ ensure("no content type", invalid_child.contentType().empty());
+ ensure("not multipart", !invalid_child.isMultipart());
+ ensure_equals("no attachments", invalid_child.subPartCount(), 0);
+ }
+
+ template<> template<>
+ void mime_index_object_t::test<4>()
+ {
+ const S32 MULTI_CONTENT_LENGTH = 8000;
+ const S32 MULTI_CONTENT_OFFSET = 100;
+ const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
+ LLSD headers;
+ headers["Content-Length"] = MULTI_CONTENT_LENGTH;
+ headers["Content-Type"] = MULTI_CONTENT_TYPE;
+ LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
+
+ const S32 META_CONTENT_LENGTH = 700;
+ const S32 META_CONTENT_OFFSET = 69;
+ const std::string META_CONTENT_TYPE = std::string(
+ "application/llsd+xml");
+ headers = LLSD::emptyMap();
+ headers["Content-Length"] = META_CONTENT_LENGTH;
+ headers["Content-Type"] = META_CONTENT_TYPE;
+ LLMimeIndex meta(headers, META_CONTENT_OFFSET);
+ mime.attachSubPart(meta);
+
+ const S32 IMAGE_CONTENT_LENGTH = 6000;
+ const S32 IMAGE_CONTENT_OFFSET = 200;
+ const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
+ headers = LLSD::emptyMap();
+ headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
+ headers["Content-Type"] = IMAGE_CONTENT_TYPE;
+ LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
+ mime.attachSubPart(image);
+
+ // check what we have
+ ensure("is multipart", mime.isMultipart());
+ ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
+ ensure_equals(
+ "multi content length",
+ mime.contentLength(),
+ MULTI_CONTENT_LENGTH);
+ ensure_equals("two attachments", mime.subPartCount(), 2);
+
+ LLMimeIndex actual_meta = mime.subPart(0);
+ ensure_equals(
+ "meta type", actual_meta.contentType(), META_CONTENT_TYPE);
+ ensure_equals(
+ "meta offset", actual_meta.offset(), META_CONTENT_OFFSET);
+ ensure_equals(
+ "meta content length",
+ actual_meta.contentLength(),
+ META_CONTENT_LENGTH);
+
+ LLMimeIndex actual_image = mime.subPart(1);
+ ensure_equals(
+ "image type", actual_image.contentType(), IMAGE_CONTENT_TYPE);
+ ensure_equals(
+ "image offset", actual_image.offset(), IMAGE_CONTENT_OFFSET);
+ ensure_equals(
+ "image content length",
+ actual_image.contentLength(),
+ IMAGE_CONTENT_LENGTH);
+ }
+
+/*
+ template<> template<>
+ void mime_index_object_t::test<5>()
+ {
+ }
+ template<> template<>
+ void mime_index_object_t::test<6>()
+ {
+ }
+ template<> template<>
+ void mime_index_object_t::test<7>()
+ {
+ }
+ template<> template<>
+ void mime_index_object_t::test<8>()
+ {
+ }
+ template<> template<>
+ void mime_index_object_t::test<>()
+ {
+ }
+*/
+}
+
+
+namespace tut
+{
+ struct mime_parse
+ {
+ };
+ typedef test_group<mime_parse> mime_parse_t;
+ typedef mime_parse_t::object mime_parse_object_t;
+ tut::mime_parse_t tut_mime_parse("mime_parse");
+
+ template<> template<>
+ void mime_parse_object_t::test<1>()
+ {
+ // parse one mime object
+ const std::string SERIALIZED_MIME("Content-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure_equals("content type", mime.contentType(), "text/plain");
+ ensure_equals("content length", mime.contentLength(), 200);
+ ensure_equals("offset", mime.offset(), 49);
+ }
+
+ template<> template<>
+ void mime_parse_object_t::test<2>()
+ {
+ // make sure we only parse one.
+ const std::string SERIALIZED_MIME("Content-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n\r\nContent-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure("not multipart.", !mime.isMultipart());
+ ensure_equals("content type", mime.contentType(), "text/plain");
+ ensure_equals("content length", mime.contentLength(), 200);
+ ensure_equals("offset", mime.offset(), 49);
+ }
+
+ template<> template<>
+ void mime_parse_object_t::test<3>()
+ {
+ // test multi-part and lack of content length for some of it.
+ /*
+Content-Type: multipart/mixed; boundary="segment"rnContent-Length: 148rnrn--segmentrnContent-Type: text/plainrnrnsome datarnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
+ */
+ const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=\"segment\"\r\nContent-Length: 150\r\n\r\n--segment\r\nContent-Type: text/plain\r\n\r\nsome data\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure("is multipart.", mime.isMultipart());
+ ensure_equals("sub-part count", mime.subPartCount(), 2);
+ ensure_equals("content length", mime.contentLength(), 150);
+ ensure_equals("data offset for multipart", mime.offset(), 74);
+
+ LLMimeIndex mime_plain(mime.subPart(0));
+ ensure_equals(
+ "first part type",
+ mime_plain.contentType(),
+ "text/plain");
+ ensure_equals(
+ "first part content length not known.",
+ mime_plain.contentLength(),
+ -1);
+ ensure_equals("first part offset", mime_plain.offset(), 113);
+
+ LLMimeIndex mime_xml(mime.subPart(1));
+ ensure_equals(
+ "second part type",
+ mime_xml.contentType(),
+ "text/xml; charset=UTF-8");
+ ensure_equals(
+ "second part content length",
+ mime_xml.contentLength(),
+ 22);
+ ensure_equals("second part offset", mime_xml.offset(), 198);
+ }
+
+ template<> template<>
+ void mime_parse_object_t::test<4>()
+ {
+ // test multi-part, unquoted separator, and premature eof conditions
+ /*
+Content-Type: multipart/mixed; boundary=segmentrnContent-Length: 220rnrn--segmentrnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn */
+ const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segment\r\nContent-Length: 220\r\n\r\n--segment\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure("is multipart.", mime.isMultipart());
+ ensure_equals("sub-part count", mime.subPartCount(), 2);
+ ensure_equals("content length", mime.contentLength(), 220);
+ ensure_equals("data offset for multipart", mime.offset(), 72);
+
+ LLMimeIndex mime_plain(mime.subPart(0));
+ ensure_equals(
+ "first part type",
+ mime_plain.contentType(),
+ "text/plain");
+ ensure_equals(
+ "first part content length",
+ mime_plain.contentLength(),
+ 55);
+ ensure_equals("first part offset", mime_plain.offset(), 131);
+
+ LLMimeIndex mime_xml(mime.subPart(1));
+ ensure_equals(
+ "second part type",
+ mime_xml.contentType(),
+ "text/xml; charset=UTF-8");
+ ensure_equals(
+ "second part content length",
+ mime_xml.contentLength(),
+ 22);
+ ensure_equals("second part offset", mime_xml.offset(), 262);
+ }
+
+ template<> template<>
+ void mime_parse_object_t::test<5>()
+ {
+ // test multi-part with multiple params
+ const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segment; comment=\"testing multiple params.\"\r\nContent-Length: 220\r\n\r\n--segment\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure("is multipart.", mime.isMultipart());
+ ensure_equals("sub-part count", mime.subPartCount(), 2);
+ ensure_equals("content length", mime.contentLength(), 220);
+
+ LLMimeIndex mime_plain(mime.subPart(0));
+ ensure_equals(
+ "first part type",
+ mime_plain.contentType(),
+ "text/plain");
+ ensure_equals(
+ "first part content length",
+ mime_plain.contentLength(),
+ 55);
+
+ LLMimeIndex mime_xml(mime.subPart(1));
+ ensure_equals(
+ "second part type",
+ mime_xml.contentType(),
+ "text/xml; charset=UTF-8");
+ ensure_equals(
+ "second part content length",
+ mime_xml.contentLength(),
+ 22);
+ }
+
+ template<> template<>
+ void mime_parse_object_t::test<6>()
+ {
+ // test multi-part with no specified boundary and eof
+/*
+Content-Type: multipart/relatedrnContent-Length: 220rnrn--rnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--rnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
+*/
+ const std::string SERIALIZED_MIME("Content-Type: multipart/related\r\nContent-Length: 500\r\n\r\n--\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
+ std::stringstream istr;
+ istr.str(SERIALIZED_MIME);
+ LLMimeIndex mime;
+ LLMimeParser parser;
+ bool ok = parser.parseIndex(istr, mime);
+ ensure("Parse successful.", ok);
+ ensure("is multipart.", mime.isMultipart());
+ ensure_equals("sub-part count", mime.subPartCount(), 2);
+ ensure_equals("content length", mime.contentLength(), 500);
+ ensure_equals("data offset for multipart", mime.offset(), 56);
+
+ LLMimeIndex mime_plain(mime.subPart(0));
+ ensure_equals(
+ "first part type",
+ mime_plain.contentType(),
+ "text/plain");
+ ensure_equals(
+ "first part content length",
+ mime_plain.contentLength(),
+ 55);
+ ensure_equals("first part offset", mime_plain.offset(), 108);
+
+ LLMimeIndex mime_xml(mime.subPart(1));
+ ensure_equals(
+ "second part type",
+ mime_xml.contentType(),
+ "text/xml; charset=UTF-8");
+ ensure_equals(
+ "second part content length",
+ mime_xml.contentLength(),
+ 22);
+ ensure_equals("second part offset", mime_xml.offset(), 232);
+ }
+
+/*
+ template<> template<>
+ void mime_parse_object_t::test<>()
+ {
+ }
+ template<> template<>
+ void mime_parse_object_t::test<>()
+ {
+ }
+ template<> template<>
+ void mime_parse_object_t::test<>()
+ {
+ }
+ template<> template<>
+ void mime_parse_object_t::test<>()
+ {
+ }
+*/
+}
diff --git a/indra/llmessage/tests/llnamevalue_test.cpp b/indra/llmessage/tests/llnamevalue_test.cpp
new file mode 100644
index 0000000000..3146e7f979
--- /dev/null
+++ b/indra/llmessage/tests/llnamevalue_test.cpp
@@ -0,0 +1,412 @@
+/**
+ * @file llnamevalue_tut.cpp
+ * @author Adroit
+ * @date 2007-02
+ * @brief LLNameValue unit test
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ *
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab. Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llsdserialize.h"
+
+#include "../llnamevalue.h"
+
+#include "../test/lltut.h"
+
+
+#if LL_WINDOWS
+// disable unreachable code warnings
+#pragma warning(disable: 4702)
+#endif
+
+namespace tut
+{
+ struct namevalue_test
+ {
+ namevalue_test()
+ {
+ }
+ };
+ typedef test_group<namevalue_test> namevalue_t;
+ typedef namevalue_t::object namevalue_object_t;
+ tut::namevalue_t tut_namevalue("namevalue_test");
+
+
+ template<> template<>
+ void namevalue_object_t::test<1>()
+ {
+ // LLNameValue()
+ LLNameValue nValue;
+ ensure("mName should have been NULL", nValue.mName == NULL);
+ ensure("getTypeEnum failed",nValue.getTypeEnum() == NVT_NULL);
+ ensure("getClassEnum failed",nValue.getClassEnum() == NVC_NULL);
+ ensure("getSendtoEnum failed",nValue.getSendtoEnum() == NVS_NULL);
+
+ LLNameValue nValue1(" SecondLife ASSET RW SIM 232324343");
+
+ }
+
+ // LLNameValue(const char* data);
+ // LLNameValue(const char* name, const char* data, const char* type, const char* nvclass, const char* nvsendto,
+ // TNameValueCallback nvcb = NULL, void** user_data = NULL);
+ template<> template<>
+ void namevalue_object_t::test<2>()
+ {
+ LLNameValue nValue(" SecondLife ASSET RW S 232324343");
+ ensure("mName not set correctly", (0 == strcmp(nValue.mName,"SecondLife")));
+ ensure("getTypeEnum failed", nValue.getTypeEnum() == NVT_ASSET);
+ ensure("getClassEnum failed", nValue.getClassEnum() == NVC_READ_WRITE);
+ ensure("getSendtoEnum failed", nValue.getSendtoEnum() == NVS_SIM);
+ ensure("getString failed", (0==strcmp(nValue.getAsset(),"232324343")));
+ ensure("sendToData or sendToViewer failed", !nValue.sendToData() && !nValue.sendToViewer());
+
+ LLNameValue nValue1("\n\r SecondLife_1 STRING READ_WRITE SIM 232324343");
+ ensure("1. mName not set correctly", (0 == strcmp(nValue1.mName,"SecondLife_1")));
+ ensure("1. getTypeEnum failed", nValue1.getTypeEnum() == NVT_STRING);
+ ensure("1. getClassEnum failed", nValue1.getClassEnum() == NVC_READ_WRITE);
+ ensure("1. getSendtoEnum failed", nValue1.getSendtoEnum() == NVS_SIM);
+ ensure("1. getString failed", (0==strcmp(nValue1.getString(),"232324343")));
+ ensure("1. sendToData or sendToViewer failed", !nValue1.sendToData() && !nValue1.sendToViewer());
+
+ LLNameValue nValue2("SecondLife", "23.5", "F32", "R", "DS");
+ ensure("2. getTypeEnum failed", nValue2.getTypeEnum() == NVT_F32);
+ ensure("2. getClassEnum failed", nValue2.getClassEnum() == NVC_READ_ONLY);
+ ensure("2. getSendtoEnum failed", nValue2.getSendtoEnum() == NVS_DATA_SIM);
+ ensure("2. getF32 failed", *nValue2.getF32() == 23.5f);
+ ensure("2. sendToData or sendToViewer failed", nValue2.sendToData() && !nValue2.sendToViewer());
+
+ LLNameValue nValue3("SecondLife", "-43456787", "S32", "READ_ONLY", "SIM_SPACE");
+ ensure("3. getTypeEnum failed", nValue3.getTypeEnum() == NVT_S32);
+ ensure("3. getClassEnum failed", nValue3.getClassEnum() == NVC_READ_ONLY);
+ ensure("3. getSendtoEnum failed", nValue3.getSendtoEnum() == NVS_DATA_SIM);
+ ensure("3. getS32 failed", *nValue3.getS32() == -43456787);
+ ensure("sendToData or sendToViewer failed", nValue3.sendToData() && !nValue3.sendToViewer());
+
+ LLNameValue nValue4("SecondLife", "<1.0, 2.0, 3.0>", "VEC3", "RW", "SV");
+ LLVector3 llvec4(1.0, 2.0, 3.0);
+ ensure("4. getTypeEnum failed", nValue4.getTypeEnum() == NVT_VEC3);
+ ensure("4. getClassEnum failed", nValue4.getClassEnum() == NVC_READ_WRITE);
+ ensure("4. getSendtoEnum failed", nValue4.getSendtoEnum() == NVS_SIM_VIEWER);
+ ensure("4. getVec3 failed", *nValue4.getVec3() == llvec4);
+ ensure("4. sendToData or sendToViewer failed", !nValue4.sendToData() && nValue4.sendToViewer());
+
+ LLNameValue nValue5("SecondLife", "-1.0, 2.4, 3", "VEC3", "RW", "SIM_VIEWER");
+ LLVector3 llvec5(-1.0f, 2.4f, 3);
+ ensure("5. getTypeEnum failed", nValue5.getTypeEnum() == NVT_VEC3);
+ ensure("5. getClassEnum failed", nValue5.getClassEnum() == NVC_READ_WRITE);
+ ensure("5. getSendtoEnum failed", nValue5.getSendtoEnum() == NVS_SIM_VIEWER);
+ ensure("5. getVec3 failed", *nValue5.getVec3() == llvec5);
+ ensure("5. sendToData or sendToViewer failed", !nValue5.sendToData() && nValue5.sendToViewer());
+
+ LLNameValue nValue6("SecondLife", "89764323", "U32", "RW", "DSV");
+ ensure("6. getTypeEnum failed", nValue6.getTypeEnum() == NVT_U32);
+ ensure("6. getClassEnum failed", nValue6.getClassEnum() == NVC_READ_WRITE);
+ ensure("6. getSendtoEnum failed", nValue6.getSendtoEnum() == NVS_DATA_SIM_VIEWER);
+ ensure("6. getU32 failed", *nValue6.getU32() == 89764323);
+ ensure("6. sendToData or sendToViewer failed", nValue6.sendToData() && nValue6.sendToViewer());
+
+ LLNameValue nValue7("SecondLife", "89764323323232", "U64", "RW", "SIM_SPACE_VIEWER");
+ U64 u64_7 = U64L(89764323323232);
+ ensure("7. getTypeEnum failed", nValue7.getTypeEnum() == NVT_U64);
+ ensure("7. getClassEnum failed", nValue7.getClassEnum() == NVC_READ_WRITE);
+ ensure("7. getSendtoEnum failed", nValue7.getSendtoEnum() == NVS_DATA_SIM_VIEWER);
+ ensure("7. getU32 failed", *nValue7.getU64() == u64_7);
+ ensure("7. sendToData or sendToViewer failed", nValue7.sendToData() && nValue7.sendToViewer());
+ }
+
+ // LLNameValue(const char* name, const char* data, const char* type, const char* nvclass,
+ // TNameValueCallback nvcb = NULL, void** user_data = NULL);
+ template<> template<>
+ void namevalue_object_t::test<3>()
+ {
+ LLNameValue nValue("SecondLife", "232324343", "ASSET", "READ_WRITE");
+ ensure("mName not set correctly", (0 == strcmp(nValue.mName,"SecondLife")));
+ ensure("getTypeEnum failed", nValue.getTypeEnum() == NVT_ASSET);
+ ensure("getClassEnum failed", nValue.getClassEnum() == NVC_READ_WRITE);
+ ensure("getSendtoEnum failed", nValue.getSendtoEnum() == NVS_SIM);
+ ensure("getString failed", (0==strcmp(nValue.getAsset(),"232324343")));
+
+ LLNameValue nValue1("SecondLife", "232324343", "STRING", "READ_WRITE");
+ ensure("1. mName not set correctly", (0 == strcmp(nValue1.mName,"SecondLife")));
+ ensure("1. getTypeEnum failed", nValue1.getTypeEnum() == NVT_STRING);
+ ensure("1. getClassEnum failed", nValue1.getClassEnum() == NVC_READ_WRITE);
+ ensure("1. getSendtoEnum failed", nValue1.getSendtoEnum() == NVS_SIM);
+ ensure("1. getString failed", (0==strcmp(nValue1.getString(),"232324343")));
+
+ LLNameValue nValue2("SecondLife", "23.5", "F32", "R");
+ ensure("2. getTypeEnum failed", nValue2.getTypeEnum() == NVT_F32);
+ ensure("2. getClassEnum failed", nValue2.getClassEnum() == NVC_READ_ONLY);
+ ensure("2. getSendtoEnum failed", nValue2.getSendtoEnum() == NVS_SIM);
+ ensure("2. getF32 failed", *nValue2.getF32() == 23.5f);
+
+ LLNameValue nValue3("SecondLife", "-43456787", "S32", "READ_ONLY");
+ ensure("3. getTypeEnum failed", nValue3.getTypeEnum() == NVT_S32);
+ ensure("3. getClassEnum failed", nValue3.getClassEnum() == NVC_READ_ONLY);
+ ensure("3. getSendtoEnum failed", nValue3.getSendtoEnum() == NVS_SIM);
+ ensure("3. getS32 failed", *nValue3.getS32() == -43456787);
+
+ LLNameValue nValue4("SecondLife", "<1.0, 2.0, 3.0>", "VEC3", "RW");
+ LLVector3 llvec4(1.0, 2.0, 3.0);
+ ensure("4. getTypeEnum failed", nValue4.getTypeEnum() == NVT_VEC3);
+ ensure("4. getClassEnum failed", nValue4.getClassEnum() == NVC_READ_WRITE);
+ ensure("4. getSendtoEnum failed", nValue4.getSendtoEnum() == NVS_SIM);
+ ensure("4. getVec3 failed", *nValue4.getVec3() == llvec4);
+
+ LLNameValue nValue5("SecondLife", "-1.0, 2.4, 3", "VEC3", "RW");
+ LLVector3 llvec5(-1.0f, 2.4f, 3);
+ ensure("5. getTypeEnum failed", nValue5.getTypeEnum() == NVT_VEC3);
+ ensure("5. getClassEnum failed", nValue5.getClassEnum() == NVC_READ_WRITE);
+ ensure("5. getSendtoEnum failed", nValue5.getSendtoEnum() == NVS_SIM);
+ ensure("5. getVec3 failed", *nValue5.getVec3() == llvec5);
+
+ LLNameValue nValue6("SecondLife", "89764323", "U32", "RW");
+ ensure("6. getTypeEnum failed", nValue6.getTypeEnum() == NVT_U32);
+ ensure("6. getClassEnum failed", nValue6.getClassEnum() == NVC_READ_WRITE);
+ ensure("6. getSendtoEnum failed", nValue6.getSendtoEnum() == NVS_SIM);
+ ensure("6. getU32 failed", *nValue6.getU32() == 89764323);
+
+ LLNameValue nValue7("SecondLife", "89764323323232", "U64", "RW");
+ U64 u64_7 = U64L(89764323323232);
+ ensure("7. getTypeEnum failed", nValue7.getTypeEnum() == NVT_U64);
+ ensure("7. getClassEnum failed", nValue7.getClassEnum() == NVC_READ_WRITE);
+ ensure("7. getSendtoEnum failed", nValue7.getSendtoEnum() == NVS_SIM);
+ ensure("7. getU32 failed", *nValue7.getU64() == u64_7);
+ }
+
+ // LLNameValue(const char* name, const char* type, const char* nvclass,
+ // TNameValueCallback nvcb = NULL, void** user_data = NULL);
+ template<> template<>
+ void namevalue_object_t::test<4>()
+ {
+ LLNameValue nValue("SecondLife", "STRING", "READ_WRITE");
+ ensure("mName not set correctly", (0 == strcmp(nValue.mName,"SecondLife")));
+ ensure("getTypeEnum failed", nValue.getTypeEnum() == NVT_STRING);
+ ensure("getClassEnum failed", nValue.getClassEnum() == NVC_READ_WRITE);
+ ensure("getSendtoEnum failed", nValue.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue1("SecondLife", "ASSET", "READ_WRITE");
+ ensure("1. mName not set correctly", (0 == strcmp(nValue1.mName,"SecondLife")));
+ ensure("1. getTypeEnum for RW failed", nValue1.getTypeEnum() == NVT_ASSET);
+ ensure("1. getClassEnum for RW failed", nValue1.getClassEnum() == NVC_READ_WRITE);
+ ensure("1. getSendtoEnum for RW failed", nValue1.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue2("SecondLife", "F32", "READ_ONLY");
+ ensure("2. getTypeEnum failed", nValue2.getTypeEnum() == NVT_F32);
+ ensure("2. getClassEnum failed", nValue2.getClassEnum() == NVC_READ_ONLY);
+ ensure("2. getSendtoEnum failed", nValue2.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue3("SecondLife", "S32", "READ_ONLY");
+ ensure("3. getTypeEnum failed", nValue3.getTypeEnum() == NVT_S32);
+ ensure("3. getClassEnum failed", nValue3.getClassEnum() == NVC_READ_ONLY);
+ ensure("3. getSendtoEnum failed", nValue3.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue4("SecondLife", "VEC3", "READ_WRITE");
+ ensure("4. getTypeEnum failed", nValue4.getTypeEnum() == NVT_VEC3);
+ ensure("4. getClassEnum failed", nValue4.getClassEnum() == NVC_READ_WRITE);
+ ensure("4. getSendtoEnum failed", nValue4.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue6("SecondLife", "U32", "READ_WRITE");
+ ensure("6. getTypeEnum failed", nValue6.getTypeEnum() == NVT_U32);
+ ensure("6. getClassEnum failed", nValue6.getClassEnum() == NVC_READ_WRITE);
+ ensure("6. getSendtoEnum failed", nValue6.getSendtoEnum() == NVS_SIM);
+
+ LLNameValue nValue7("SecondLife", "U64", "READ_WRITE");
+ ensure("7. getTypeEnum failed", nValue7.getTypeEnum() == NVT_U64);
+ ensure("7. getClassEnum failed", nValue7.getClassEnum() == NVC_READ_WRITE);
+ ensure("7. getSendtoEnum failed", nValue7.getSendtoEnum() == NVS_SIM);
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<5>()
+ {
+ LLNameValue nValue("SecondLife", "This is a test", "STRING", "RW", "SIM");
+
+ ensure("getString failed", (0 == strcmp(nValue.getString(),"This is a test")));
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<6>()
+ {
+ LLNameValue nValue("SecondLife", "This is a test", "ASSET", "RW", "S");
+ ensure("getAsset failed", (0 == strcmp(nValue.getAsset(),"This is a test")));
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<7>()
+ {
+ LLNameValue nValue("SecondLife", "555555", "F32", "RW", "SIM");
+
+ ensure("getF32 failed",*nValue.getF32() == 555555.f);
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<8>()
+ {
+ LLNameValue nValue("SecondLife", "-5555", "S32", "RW", "SIM");
+
+ ensure("getS32 failed", *nValue.getS32() == -5555);
+
+ S32 sVal = 0x7FFFFFFF;
+ nValue.setS32(sVal);
+ ensure("getS32 failed", *nValue.getS32() == sVal);
+
+ sVal = -0x7FFFFFFF;
+ nValue.setS32(sVal);
+ ensure("getS32 failed", *nValue.getS32() == sVal);
+
+ sVal = 0;
+ nValue.setS32(sVal);
+ ensure("getS32 failed", *nValue.getS32() == sVal);
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<9>()
+ {
+ LLNameValue nValue("SecondLife", "<-3, 2, 1>", "VEC3", "RW", "SIM");
+ LLVector3 vecExpected(-3, 2, 1);
+ LLVector3 vec;
+ nValue.getVec3(vec);
+ ensure("getVec3 failed", vec == vecExpected);
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<10>()
+ {
+ LLNameValue nValue("SecondLife", "12345678", "U32", "RW", "SIM");
+
+ ensure("getU32 failed",*nValue.getU32() == 12345678);
+
+ U32 val = 0xFFFFFFFF;
+ nValue.setU32(val);
+ ensure("U32 max", *nValue.getU32() == val);
+
+ val = 0;
+ nValue.setU32(val);
+ ensure("U32 min", *nValue.getU32() == val);
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<11>()
+ {
+ //skip_fail("incomplete support for U64.");
+ LLNameValue nValue("SecondLife", "44444444444", "U64", "RW", "SIM");
+
+ ensure("getU64 failed",*nValue.getU64() == U64L(44444444444));
+
+ // there is no LLNameValue::setU64()
+ }
+
+
+ template<> template<>
+ void namevalue_object_t::test<12>()
+ {
+ //skip_fail("incomplete support for U64.");
+ LLNameValue nValue("SecondLife U64 RW DSV 44444444444");
+ std::string ret_str = nValue.printNameValue();
+
+ ensure_equals("1:printNameValue failed",ret_str,"SecondLife U64 RW DSV 44444444444");
+
+ LLNameValue nValue1(ret_str.c_str());
+ ensure_equals("Serialization of printNameValue failed", *nValue.getU64(), *nValue1.getU64());
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<13>()
+ {
+ LLNameValue nValue("SecondLife STRING RW DSV 44444444444");
+ std::string ret_str = nValue.printData();
+ ensure_equals("1:printData failed",ret_str,"44444444444");
+
+ LLNameValue nValue1("SecondLife S32 RW DSV 44444");
+ ret_str = nValue1.printData();
+ ensure_equals("2:printData failed",ret_str,"44444");
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<14>()
+ {
+ LLNameValue nValue("SecodLife STRING RW SIM 22222");
+ std::ostringstream stream1,stream2,stream3, stream4, stream5;
+ stream1 << nValue;
+ ensure_equals("STRING << failed",stream1.str(),"22222");
+
+ LLNameValue nValue1("SecodLife F32 RW SIM 22222");
+ stream2 << nValue1;
+ ensure_equals("F32 << failed",stream2.str(),"22222");
+
+ LLNameValue nValue2("SecodLife S32 RW SIM 22222");
+ stream3<< nValue2;
+ ensure_equals("S32 << failed",stream3.str(),"22222");
+
+ LLNameValue nValue3("SecodLife U32 RW SIM 122222");
+ stream4<< nValue3;
+ ensure_equals("U32 << failed",stream4.str(),"122222");
+
+ // I don't think we use U64 name value pairs. JC
+ //skip_fail("incomplete support for U64.");
+ //LLNameValue nValue4("SecodLife U64 RW SIM 22222");
+ //stream5<< nValue4;
+ //ensure("U64 << failed",0 == strcmp((stream5.str()).c_str(),"22222"));
+ }
+
+ template<> template<>
+ void namevalue_object_t::test<15>()
+ {
+ LLNameValue nValue("SecondLife", "This is a test", "ASSET", "R", "S");
+
+ ensure("getAsset failed", (0 == strcmp(nValue.getAsset(),"This is a test")));
+ // this should not have updated as it is read only.
+ nValue.setAsset("New Value should not be updated");
+ ensure("setAsset on ReadOnly failed", (0 == strcmp(nValue.getAsset(),"This is a test")));
+
+ LLNameValue nValue1("SecondLife", "1234", "U32", "R", "S");
+ // this should not have updated as it is read only.
+ nValue1.setU32(4567);
+ ensure("setU32 on ReadOnly failed", *nValue1.getU32() == 1234);
+
+ LLNameValue nValue2("SecondLife", "1234", "S32", "R", "S");
+ // this should not have updated as it is read only.
+ nValue2.setS32(4567);
+ ensure("setS32 on ReadOnly failed", *nValue2.getS32() == 1234);
+
+ LLNameValue nValue3("SecondLife", "1234", "F32", "R", "S");
+ // this should not have updated as it is read only.
+ nValue3.setF32(4567);
+ ensure("setF32 on ReadOnly failed", *nValue3.getF32() == 1234);
+
+ LLNameValue nValue4("SecondLife", "<1,2,3>", "VEC3", "R", "S");
+ // this should not have updated as it is read only.
+ LLVector3 vec(4,5,6);
+ nValue3.setVec3(vec);
+ LLVector3 vec1(1,2,3);
+ ensure("setVec3 on ReadOnly failed", *nValue4.getVec3() == vec1);
+
+ // cant test for U64 as no set64 exists nor any operators support U64 type
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 14:49:05 +0000