summaryrefslogtreecommitdiff
path: root/indra/llcommon/tests/commonmisc_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon/tests/commonmisc_test.cpp')
-rw-r--r--indra/llcommon/tests/commonmisc_test.cpp1176
1 files changed, 588 insertions, 588 deletions
diff --git a/indra/llcommon/tests/commonmisc_test.cpp b/indra/llcommon/tests/commonmisc_test.cpp
index 4b3e07fa75..3deb864c0c 100644
--- a/indra/llcommon/tests/commonmisc_test.cpp
+++ b/indra/llcommon/tests/commonmisc_test.cpp
@@ -1,4 +1,4 @@
-/**
+/**
* @file common.cpp
* @author Phoenix
* @date 2005-10-12
@@ -7,27 +7,27 @@
* $LicenseInfo:firstyear=2005&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$
*/
-/**
- *
+/**
+ *
* THOROUGH_DESCRIPTION of common.cpp
*
*/
@@ -54,388 +54,388 @@
namespace tut
{
- struct sd_data
- {
- };
- typedef test_group<sd_data> sd_test;
- typedef sd_test::object sd_object;
- tut::sd_test sd("LLSD");
-
- template<> template<>
- void sd_object::test<1>()
- {
- std::ostringstream resp;
- resp << "{'connect':true, 'position':[r128,r128,r128], 'look_at':[r0,r1,r0], 'agent_access':'M', 'region_x':i8192, 'region_y':i8192}";
- std::string str = resp.str();
- LLMemoryStream mstr((U8*)str.c_str(), str.size());
- LLSD response;
- S32 count = LLSDSerialize::fromNotation(response, mstr, str.size());
- ensure("stream parsed", response.isDefined());
- ensure_equals("stream parse count", count, 13);
- ensure_equals("sd type", response.type(), LLSD::TypeMap);
- ensure_equals("map element count", response.size(), 6);
- ensure_equals("value connect", response["connect"].asBoolean(), true);
- ensure_equals("value region_x", response["region_x"].asInteger(),8192);
- ensure_equals("value region_y", response["region_y"].asInteger(),8192);
- }
-
- template<> template<>
- void sd_object::test<2>()
- {
- const std::string decoded("random");
- //const std::string encoded("cmFuZG9t\n");
- const std::string streamed("b(6)\"random\"");
- typedef std::vector<U8> buf_t;
- buf_t buf;
- std::copy(
- decoded.begin(),
- decoded.end(),
- std::back_insert_iterator<buf_t>(buf));
- LLSD sd;
- sd = buf;
- std::stringstream str;
- S32 count = LLSDSerialize::toNotation(sd, str);
- ensure_equals("output count", count, 1);
- std::string actual(str.str());
- ensure_equals("formatted binary encoding", actual, streamed);
- sd.clear();
- LLSDSerialize::fromNotation(sd, str, str.str().size());
- std::vector<U8> after;
- after = sd.asBinary();
- ensure_equals("binary decoded size", after.size(), decoded.size());
- ensure("binary decoding", (0 == memcmp(
- &after[0],
- decoded.c_str(),
- decoded.size())));
- }
-
- template<> template<>
- void sd_object::test<3>()
- {
- for(S32 i = 0; i < 100; ++i)
- {
- // gen up a starting point
- typedef std::vector<U8> buf_t;
- buf_t source;
- srand(i); /* Flawfinder: ignore */
- S32 size = rand() % 1000 + 10;
- std::generate_n(
- std::back_insert_iterator<buf_t>(source),
- size,
- rand);
- LLSD sd(source);
- std::stringstream str;
- S32 count = LLSDSerialize::toNotation(sd, str);
- sd.clear();
- ensure_equals("format count", count, 1);
- LLSD sd2;
- count = LLSDSerialize::fromNotation(sd2, str, str.str().size());
- ensure_equals("parse count", count, 1);
- buf_t dest = sd2.asBinary();
- str.str("");
- str << "binary encoding size " << i;
- ensure_equals(str.str().c_str(), dest.size(), source.size());
- str.str("");
- str << "binary encoding " << i;
- ensure(str.str().c_str(), (source == dest));
- }
- }
-
- template<> template<>
- void sd_object::test<4>()
- {
- std::ostringstream ostr;
- ostr << "{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}\n"
- << "{\n\tname\tObject|\n}\n";
- std::string expected = ostr.str();
- std::stringstream serialized;
- serialized << "'" << LLSDNotationFormatter::escapeString(expected)
- << "'";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(
- sd,
- serialized,
- serialized.str().size());
- ensure_equals("parse count", count, 1);
- ensure_equals("String streaming", sd.asString(), expected);
- }
-
- template<> template<>
- void sd_object::test<5>()
- {
- for(S32 i = 0; i < 100; ++i)
- {
- // gen up a starting point
- typedef std::vector<U8> buf_t;
- buf_t source;
- srand(666 + i); /* Flawfinder: ignore */
- S32 size = rand() % 1000 + 10;
- std::generate_n(
- std::back_insert_iterator<buf_t>(source),
- size,
- rand);
- std::stringstream str;
- str << "b(" << size << ")\"";
- str.write((const char*)&source[0], size);
- str << "\"";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
- ensure_equals("binary parse", count, 1);
- buf_t actual = sd.asBinary();
- ensure_equals("binary size", actual.size(), (size_t)size);
- ensure("binary data", (0 == memcmp(&source[0], &actual[0], size)));
- }
- }
-
- template<> template<>
- void sd_object::test<6>()
- {
- std::string expected("'{\"task_id\":u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}'\t\n\t\t");
- std::stringstream str;
- str << "s(" << expected.size() << ")'";
- str.write(expected.c_str(), expected.size());
- str << "'";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
- ensure_equals("parse count", count, 1);
- std::string actual = sd.asString();
- ensure_equals("string sizes", actual.size(), expected.size());
- ensure_equals("string content", actual, expected);
- }
-
- template<> template<>
- void sd_object::test<7>()
- {
- std::string msg("come on in");
- std::stringstream stream;
- stream << "{'connect':1, 'message':'" << msg << "',"
- << " 'position':[r45.65,r100.1,r25.5],"
- << " 'look_at':[r0,r1,r0],"
- << " 'agent_access':'PG'}";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(
- sd,
- stream,
- stream.str().size());
- ensure_equals("parse count", count, 12);
- ensure_equals("bool value", sd["connect"].asBoolean(), true);
- ensure_equals("message value", sd["message"].asString(), msg);
- ensure_equals("pos x", sd["position"][0].asReal(), 45.65);
- ensure_equals("pos y", sd["position"][1].asReal(), 100.1);
- ensure_equals("pos z", sd["position"][2].asReal(), 25.5);
- ensure_equals("look x", sd["look_at"][0].asReal(), 0.0);
- ensure_equals("look y", sd["look_at"][1].asReal(), 1.0);
- ensure_equals("look z", sd["look_at"][2].asReal(), 0.0);
- }
-
- template<> template<>
- void sd_object::test<8>()
- {
- std::stringstream resp;
- resp << "{'label':'short string test', 'singlechar':'a', 'empty':'', 'endoftest':'end' }";
- LLSD response;
- S32 count = LLSDSerialize::fromNotation(
- response,
- resp,
- resp.str().size());
- ensure_equals("parse count", count, 5);
- ensure_equals("sd type", response.type(), LLSD::TypeMap);
- ensure_equals("map element count", response.size(), 4);
- ensure_equals("singlechar", response["singlechar"].asString(), "a");
- ensure_equals("empty", response["empty"].asString(), "");
- }
-
- template<> template<>
- void sd_object::test<9>()
- {
- std::ostringstream resp;
- resp << "{'label':'short binary test', 'singlebinary':b(1)\"A\", 'singlerawstring':s(1)\"A\", 'endoftest':'end' }";
- std::string str = resp.str();
- LLSD sd;
- LLMemoryStream mstr((U8*)str.c_str(), str.size());
- S32 count = LLSDSerialize::fromNotation(sd, mstr, str.size());
- ensure_equals("parse count", count, 5);
- ensure("sd created", sd.isDefined());
- ensure_equals("sd type", sd.type(), LLSD::TypeMap);
- ensure_equals("map element count", sd.size(), 4);
- ensure_equals(
- "label",
- sd["label"].asString(),
- "short binary test");
- std::vector<U8> bin = sd["singlebinary"].asBinary();
- std::vector<U8> expected;
- expected.resize(1);
- expected[0] = 'A';
- ensure("single binary", (0 == memcmp(&bin[0], &expected[0], 1)));
- ensure_equals(
- "single string",
- sd["singlerawstring"].asString(),
- std::string("A"));
- ensure_equals("end", sd["endoftest"].asString(), "end");
- }
-
- template<> template<>
- void sd_object::test<10>()
- {
-
- std::string message("parcel '' is naughty.");
- std::stringstream str;
- str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
- << "'}";
- std::string expected_str("{'message':'parcel \\'\\' is naughty.'}");
- std::string actual_str = str.str();
- ensure_equals("stream contents", actual_str, expected_str);
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, actual_str.size());
- ensure_equals("parse count", count, 2);
- ensure("valid parse", sd.isDefined());
- std::string actual = sd["message"].asString();
- ensure_equals("message contents", actual, message);
- }
-
- template<> template<>
- void sd_object::test<11>()
- {
- std::string expected("\"\"\"\"''''''\"");
- std::stringstream str;
- str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
- ensure_equals("parse count", count, 1);
- ensure_equals("string value", sd.asString(), expected);
- }
-
- template<> template<>
- void sd_object::test<12>()
- {
- std::string expected("mytest\\");
- std::stringstream str;
- str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
- ensure_equals("parse count", count, 1);
- ensure_equals("string value", sd.asString(), expected);
- }
-
- template<> template<>
- void sd_object::test<13>()
- {
- for(S32 i = 0; i < 1000; ++i)
- {
- // gen up a starting point
- std::string expected;
- srand(1337 + i); /* Flawfinder: ignore */
- S32 size = rand() % 30 + 5;
- std::generate_n(
- std::back_insert_iterator<std::string>(expected),
- size,
- rand);
- std::stringstream str;
- str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
- LLSD sd;
- S32 count = LLSDSerialize::fromNotation(sd, str, expected.size());
- ensure_equals("parse count", count, 1);
- std::string actual = sd.asString();
+ struct sd_data
+ {
+ };
+ typedef test_group<sd_data> sd_test;
+ typedef sd_test::object sd_object;
+ tut::sd_test sd("LLSD");
+
+ template<> template<>
+ void sd_object::test<1>()
+ {
+ std::ostringstream resp;
+ resp << "{'connect':true, 'position':[r128,r128,r128], 'look_at':[r0,r1,r0], 'agent_access':'M', 'region_x':i8192, 'region_y':i8192}";
+ std::string str = resp.str();
+ LLMemoryStream mstr((U8*)str.c_str(), str.size());
+ LLSD response;
+ S32 count = LLSDSerialize::fromNotation(response, mstr, str.size());
+ ensure("stream parsed", response.isDefined());
+ ensure_equals("stream parse count", count, 13);
+ ensure_equals("sd type", response.type(), LLSD::TypeMap);
+ ensure_equals("map element count", response.size(), 6);
+ ensure_equals("value connect", response["connect"].asBoolean(), true);
+ ensure_equals("value region_x", response["region_x"].asInteger(),8192);
+ ensure_equals("value region_y", response["region_y"].asInteger(),8192);
+ }
+
+ template<> template<>
+ void sd_object::test<2>()
+ {
+ const std::string decoded("random");
+ //const std::string encoded("cmFuZG9t\n");
+ const std::string streamed("b(6)\"random\"");
+ typedef std::vector<U8> buf_t;
+ buf_t buf;
+ std::copy(
+ decoded.begin(),
+ decoded.end(),
+ std::back_insert_iterator<buf_t>(buf));
+ LLSD sd;
+ sd = buf;
+ std::stringstream str;
+ S32 count = LLSDSerialize::toNotation(sd, str);
+ ensure_equals("output count", count, 1);
+ std::string actual(str.str());
+ ensure_equals("formatted binary encoding", actual, streamed);
+ sd.clear();
+ LLSDSerialize::fromNotation(sd, str, str.str().size());
+ std::vector<U8> after;
+ after = sd.asBinary();
+ ensure_equals("binary decoded size", after.size(), decoded.size());
+ ensure("binary decoding", (0 == memcmp(
+ &after[0],
+ decoded.c_str(),
+ decoded.size())));
+ }
+
+ template<> template<>
+ void sd_object::test<3>()
+ {
+ for(S32 i = 0; i < 100; ++i)
+ {
+ // gen up a starting point
+ typedef std::vector<U8> buf_t;
+ buf_t source;
+ srand(i); /* Flawfinder: ignore */
+ S32 size = rand() % 1000 + 10;
+ std::generate_n(
+ std::back_insert_iterator<buf_t>(source),
+ size,
+ rand);
+ LLSD sd(source);
+ std::stringstream str;
+ S32 count = LLSDSerialize::toNotation(sd, str);
+ sd.clear();
+ ensure_equals("format count", count, 1);
+ LLSD sd2;
+ count = LLSDSerialize::fromNotation(sd2, str, str.str().size());
+ ensure_equals("parse count", count, 1);
+ buf_t dest = sd2.asBinary();
+ str.str("");
+ str << "binary encoding size " << i;
+ ensure_equals(str.str().c_str(), dest.size(), source.size());
+ str.str("");
+ str << "binary encoding " << i;
+ ensure(str.str().c_str(), (source == dest));
+ }
+ }
+
+ template<> template<>
+ void sd_object::test<4>()
+ {
+ std::ostringstream ostr;
+ ostr << "{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}\n"
+ << "{\n\tname\tObject|\n}\n";
+ std::string expected = ostr.str();
+ std::stringstream serialized;
+ serialized << "'" << LLSDNotationFormatter::escapeString(expected)
+ << "'";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(
+ sd,
+ serialized,
+ serialized.str().size());
+ ensure_equals("parse count", count, 1);
+ ensure_equals("String streaming", sd.asString(), expected);
+ }
+
+ template<> template<>
+ void sd_object::test<5>()
+ {
+ for(S32 i = 0; i < 100; ++i)
+ {
+ // gen up a starting point
+ typedef std::vector<U8> buf_t;
+ buf_t source;
+ srand(666 + i); /* Flawfinder: ignore */
+ S32 size = rand() % 1000 + 10;
+ std::generate_n(
+ std::back_insert_iterator<buf_t>(source),
+ size,
+ rand);
+ std::stringstream str;
+ str << "b(" << size << ")\"";
+ str.write((const char*)&source[0], size);
+ str << "\"";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+ ensure_equals("binary parse", count, 1);
+ buf_t actual = sd.asBinary();
+ ensure_equals("binary size", actual.size(), (size_t)size);
+ ensure("binary data", (0 == memcmp(&source[0], &actual[0], size)));
+ }
+ }
+
+ template<> template<>
+ void sd_object::test<6>()
+ {
+ std::string expected("'{\"task_id\":u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}'\t\n\t\t");
+ std::stringstream str;
+ str << "s(" << expected.size() << ")'";
+ str.write(expected.c_str(), expected.size());
+ str << "'";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+ ensure_equals("parse count", count, 1);
+ std::string actual = sd.asString();
+ ensure_equals("string sizes", actual.size(), expected.size());
+ ensure_equals("string content", actual, expected);
+ }
+
+ template<> template<>
+ void sd_object::test<7>()
+ {
+ std::string msg("come on in");
+ std::stringstream stream;
+ stream << "{'connect':1, 'message':'" << msg << "',"
+ << " 'position':[r45.65,r100.1,r25.5],"
+ << " 'look_at':[r0,r1,r0],"
+ << " 'agent_access':'PG'}";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(
+ sd,
+ stream,
+ stream.str().size());
+ ensure_equals("parse count", count, 12);
+ ensure_equals("bool value", sd["connect"].asBoolean(), true);
+ ensure_equals("message value", sd["message"].asString(), msg);
+ ensure_equals("pos x", sd["position"][0].asReal(), 45.65);
+ ensure_equals("pos y", sd["position"][1].asReal(), 100.1);
+ ensure_equals("pos z", sd["position"][2].asReal(), 25.5);
+ ensure_equals("look x", sd["look_at"][0].asReal(), 0.0);
+ ensure_equals("look y", sd["look_at"][1].asReal(), 1.0);
+ ensure_equals("look z", sd["look_at"][2].asReal(), 0.0);
+ }
+
+ template<> template<>
+ void sd_object::test<8>()
+ {
+ std::stringstream resp;
+ resp << "{'label':'short string test', 'singlechar':'a', 'empty':'', 'endoftest':'end' }";
+ LLSD response;
+ S32 count = LLSDSerialize::fromNotation(
+ response,
+ resp,
+ resp.str().size());
+ ensure_equals("parse count", count, 5);
+ ensure_equals("sd type", response.type(), LLSD::TypeMap);
+ ensure_equals("map element count", response.size(), 4);
+ ensure_equals("singlechar", response["singlechar"].asString(), "a");
+ ensure_equals("empty", response["empty"].asString(), "");
+ }
+
+ template<> template<>
+ void sd_object::test<9>()
+ {
+ std::ostringstream resp;
+ resp << "{'label':'short binary test', 'singlebinary':b(1)\"A\", 'singlerawstring':s(1)\"A\", 'endoftest':'end' }";
+ std::string str = resp.str();
+ LLSD sd;
+ LLMemoryStream mstr((U8*)str.c_str(), str.size());
+ S32 count = LLSDSerialize::fromNotation(sd, mstr, str.size());
+ ensure_equals("parse count", count, 5);
+ ensure("sd created", sd.isDefined());
+ ensure_equals("sd type", sd.type(), LLSD::TypeMap);
+ ensure_equals("map element count", sd.size(), 4);
+ ensure_equals(
+ "label",
+ sd["label"].asString(),
+ "short binary test");
+ std::vector<U8> bin = sd["singlebinary"].asBinary();
+ std::vector<U8> expected;
+ expected.resize(1);
+ expected[0] = 'A';
+ ensure("single binary", (0 == memcmp(&bin[0], &expected[0], 1)));
+ ensure_equals(
+ "single string",
+ sd["singlerawstring"].asString(),
+ std::string("A"));
+ ensure_equals("end", sd["endoftest"].asString(), "end");
+ }
+
+ template<> template<>
+ void sd_object::test<10>()
+ {
+
+ std::string message("parcel '' is naughty.");
+ std::stringstream str;
+ str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
+ << "'}";
+ std::string expected_str("{'message':'parcel \\'\\' is naughty.'}");
+ std::string actual_str = str.str();
+ ensure_equals("stream contents", actual_str, expected_str);
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, actual_str.size());
+ ensure_equals("parse count", count, 2);
+ ensure("valid parse", sd.isDefined());
+ std::string actual = sd["message"].asString();
+ ensure_equals("message contents", actual, message);
+ }
+
+ template<> template<>
+ void sd_object::test<11>()
+ {
+ std::string expected("\"\"\"\"''''''\"");
+ std::stringstream str;
+ str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+ ensure_equals("parse count", count, 1);
+ ensure_equals("string value", sd.asString(), expected);
+ }
+
+ template<> template<>
+ void sd_object::test<12>()
+ {
+ std::string expected("mytest\\");
+ std::stringstream str;
+ str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+ ensure_equals("parse count", count, 1);
+ ensure_equals("string value", sd.asString(), expected);
+ }
+
+ template<> template<>
+ void sd_object::test<13>()
+ {
+ for(S32 i = 0; i < 1000; ++i)
+ {
+ // gen up a starting point
+ std::string expected;
+ srand(1337 + i); /* Flawfinder: ignore */
+ S32 size = rand() % 30 + 5;
+ std::generate_n(
+ std::back_insert_iterator<std::string>(expected),
+ size,
+ rand);
+ std::stringstream str;
+ str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+ LLSD sd;
+ S32 count = LLSDSerialize::fromNotation(sd, str, expected.size());
+ ensure_equals("parse count", count, 1);
+ std::string actual = sd.asString();
/*
- if(actual != expected)
- {
- LL_WARNS() << "iteration " << i << LL_ENDL;
- std::ostringstream e_str;
- std::string::iterator iter = expected.begin();
- std::string::iterator end = expected.end();
- for(; iter != end; ++iter)
- {
- e_str << (S32)((U8)(*iter)) << " ";
- }
- e_str << std::endl;
- llsd_serialize_string(e_str, expected);
- LL_WARNS() << "expected size: " << expected.size() << LL_ENDL;
- LL_WARNS() << "expected: " << e_str.str() << LL_ENDL;
-
- std::ostringstream a_str;
- iter = actual.begin();
- end = actual.end();
- for(; iter != end; ++iter)
- {
- a_str << (S32)((U8)(*iter)) << " ";
- }
- a_str << std::endl;
- llsd_serialize_string(a_str, actual);
- LL_WARNS() << "actual size: " << actual.size() << LL_ENDL;
- LL_WARNS() << "actual: " << a_str.str() << LL_ENDL;
- }
+ if(actual != expected)
+ {
+ LL_WARNS() << "iteration " << i << LL_ENDL;
+ std::ostringstream e_str;
+ std::string::iterator iter = expected.begin();
+ std::string::iterator end = expected.end();
+ for(; iter != end; ++iter)
+ {
+ e_str << (S32)((U8)(*iter)) << " ";
+ }
+ e_str << std::endl;
+ llsd_serialize_string(e_str, expected);
+ LL_WARNS() << "expected size: " << expected.size() << LL_ENDL;
+ LL_WARNS() << "expected: " << e_str.str() << LL_ENDL;
+
+ std::ostringstream a_str;
+ iter = actual.begin();
+ end = actual.end();
+ for(; iter != end; ++iter)
+ {
+ a_str << (S32)((U8)(*iter)) << " ";
+ }
+ a_str << std::endl;
+ llsd_serialize_string(a_str, actual);
+ LL_WARNS() << "actual size: " << actual.size() << LL_ENDL;
+ LL_WARNS() << "actual: " << a_str.str() << LL_ENDL;
+ }
*/
- ensure_equals("string value", actual, expected);
- }
- }
+ ensure_equals("string value", actual, expected);
+ }
+ }
- template<> template<>
- void sd_object::test<14>()
- {
+ template<> template<>
+ void sd_object::test<14>()
+ {
//#if LL_WINDOWS && _MSC_VER >= 1400
// skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
//#endif
- std::string param = "[{'version':i1},{'data':{'binary_bucket':b(0)\"\"},'from_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'from_name':'Phoenix Linden','id':u004e45e5-5576-277a-fba7-859d6a4cb5c8,'message':'hey','offline':i0,'timestamp':i0,'to_id':u3c5f1bb4-5182-7546-6401-1d329b4ff2f8,'type':i0},{'agent_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'god_level':i0,'limited_to_estate':i1}]";
- std::istringstream istr;
- istr.str(param);
- LLSD param_sd;
- LLSDSerialize::fromNotation(param_sd, istr, param.size());
- ensure_equals("parsed type", param_sd.type(), LLSD::TypeArray);
- LLSD version_sd = param_sd[0];
- ensure_equals("version type", version_sd.type(), LLSD::TypeMap);
- ensure("has version", version_sd.has("version"));
- ensure_equals("version number", version_sd["version"].asInteger(), 1);
- LLSD src_sd = param_sd[1];
- ensure_equals("src type", src_sd.type(), LLSD::TypeMap);
- LLSD dst_sd = param_sd[2];
- ensure_equals("dst type", dst_sd.type(), LLSD::TypeMap);
- }
-
- template<> template<>
- void sd_object::test<15>()
- {
- std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
- std::istringstream istr;
- istr.str(val);
- LLSD sd;
- LLSDSerialize::fromNotation(sd, istr, val.size());
- ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
- ensure_equals("parsed size", sd.size(), 1);
- LLSD failures = sd[0]["failures"];
- ensure("no failures.", failures.isUndefined());
- LLSD success = sd[0]["successfuls"];
- ensure_equals("success type", success.type(), LLSD::TypeArray);
- ensure_equals("success size", success.size(), 1);
- ensure_equals("success instance type", success[0].type(), LLSD::TypeUUID);
- }
-
- template<> template<>
- void sd_object::test<16>()
- {
- std::string val = "[f,t,0,1,{'foo':t,'bar':f}]";
- std::istringstream istr;
- istr.str(val);
- LLSD sd;
- LLSDSerialize::fromNotation(sd, istr, val.size());
- ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
- ensure_equals("parsed size", sd.size(), 5);
- ensure_equals("element 0 false", sd[0].asBoolean(), false);
- ensure_equals("element 1 true", sd[1].asBoolean(), true);
- ensure_equals("element 2 false", sd[2].asBoolean(), false);
- ensure_equals("element 3 true", sd[3].asBoolean(), true);
- LLSD map = sd[4];
- ensure_equals("element 4 type", map.type(), LLSD::TypeMap);
- ensure_equals("map foo type", map["foo"].type(), LLSD::TypeBoolean);
- ensure_equals("map foo value", map["foo"].asBoolean(), true);
- ensure_equals("map bar type", map["bar"].type(), LLSD::TypeBoolean);
- ensure_equals("map bar value", map["bar"].asBoolean(), false);
- }
+ std::string param = "[{'version':i1},{'data':{'binary_bucket':b(0)\"\"},'from_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'from_name':'Phoenix Linden','id':u004e45e5-5576-277a-fba7-859d6a4cb5c8,'message':'hey','offline':i0,'timestamp':i0,'to_id':u3c5f1bb4-5182-7546-6401-1d329b4ff2f8,'type':i0},{'agent_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'god_level':i0,'limited_to_estate':i1}]";
+ std::istringstream istr;
+ istr.str(param);
+ LLSD param_sd;
+ LLSDSerialize::fromNotation(param_sd, istr, param.size());
+ ensure_equals("parsed type", param_sd.type(), LLSD::TypeArray);
+ LLSD version_sd = param_sd[0];
+ ensure_equals("version type", version_sd.type(), LLSD::TypeMap);
+ ensure("has version", version_sd.has("version"));
+ ensure_equals("version number", version_sd["version"].asInteger(), 1);
+ LLSD src_sd = param_sd[1];
+ ensure_equals("src type", src_sd.type(), LLSD::TypeMap);
+ LLSD dst_sd = param_sd[2];
+ ensure_equals("dst type", dst_sd.type(), LLSD::TypeMap);
+ }
+
+ template<> template<>
+ void sd_object::test<15>()
+ {
+ std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
+ std::istringstream istr;
+ istr.str(val);
+ LLSD sd;
+ LLSDSerialize::fromNotation(sd, istr, val.size());
+ ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
+ ensure_equals("parsed size", sd.size(), 1);
+ LLSD failures = sd[0]["failures"];
+ ensure("no failures.", failures.isUndefined());
+ LLSD success = sd[0]["successfuls"];
+ ensure_equals("success type", success.type(), LLSD::TypeArray);
+ ensure_equals("success size", success.size(), 1);
+ ensure_equals("success instance type", success[0].type(), LLSD::TypeUUID);
+ }
+
+ template<> template<>
+ void sd_object::test<16>()
+ {
+ std::string val = "[f,t,0,1,{'foo':t,'bar':f}]";
+ std::istringstream istr;
+ istr.str(val);
+ LLSD sd;
+ LLSDSerialize::fromNotation(sd, istr, val.size());
+ ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
+ ensure_equals("parsed size", sd.size(), 5);
+ ensure_equals("element 0 false", sd[0].asBoolean(), false);
+ ensure_equals("element 1 true", sd[1].asBoolean(), true);
+ ensure_equals("element 2 false", sd[2].asBoolean(), false);
+ ensure_equals("element 3 true", sd[3].asBoolean(), true);
+ LLSD map = sd[4];
+ ensure_equals("element 4 type", map.type(), LLSD::TypeMap);
+ ensure_equals("map foo type", map["foo"].type(), LLSD::TypeBoolean);
+ ensure_equals("map foo value", map["foo"].asBoolean(), true);
+ ensure_equals("map bar type", map["bar"].type(), LLSD::TypeBoolean);
+ ensure_equals("map bar value", map["bar"].asBoolean(), false);
+ }
/*
- template<> template<>
- void sd_object::test<16>()
- {
- }
+ template<> template<>
+ void sd_object::test<16>()
+ {
+ }
*/
}
@@ -445,227 +445,227 @@ namespace tut
namespace tut
{
- struct mem_data
- {
- };
- typedef test_group<mem_data> mem_test;
- typedef mem_test::object mem_object;
- tut::mem_test mem_stream("LLMemoryStream");
-
- template<> template<>
- void mem_object::test<1>()
- {
- const char HELLO_WORLD[] = "hello world";
- LLMemoryStream mem((U8*)&HELLO_WORLD[0], strlen(HELLO_WORLD)); /* Flawfinder: ignore */
- std::string hello;
- std::string world;
- mem >> hello >> world;
- ensure_equals("first word", hello, std::string("hello"));
- ensure_equals("second word", world, std::string("world"));
- }
+ struct mem_data
+ {
+ };
+ typedef test_group<mem_data> mem_test;
+ typedef mem_test::object mem_object;
+ tut::mem_test mem_stream("LLMemoryStream");
+
+ template<> template<>
+ void mem_object::test<1>()
+ {
+ const char HELLO_WORLD[] = "hello world";
+ LLMemoryStream mem((U8*)&HELLO_WORLD[0], strlen(HELLO_WORLD)); /* Flawfinder: ignore */
+ std::string hello;
+ std::string world;
+ mem >> hello >> world;
+ ensure_equals("first word", hello, std::string("hello"));
+ ensure_equals("second word", world, std::string("world"));
+ }
}
namespace tut
{
- struct U64_data
- {
- };
- typedef test_group<U64_data> U64_test;
- typedef U64_test::object U64_object;
- tut::U64_test U64_testcase("U64_conversion");
-
- // U64_to_str
- template<> template<>
- void U64_object::test<1>()
- {
- U64 val;
- std::string val_str;
- char result[256];
- std::string result_str;
-
- val = U64L(18446744073709551610); // slightly less than MAX_U64
- val_str = "18446744073709551610";
-
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.1", val_str, result_str);
-
- val = 0;
- val_str = "0";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.2", val_str, result_str);
-
- val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
- val_str = "18446744073709551615";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.3", val_str, result_str);
-
- // overflow - will result in warning at compile time
- val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
- val_str = "0";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.4", val_str, result_str);
-
- val = U64L(-1); // 0xFFFFFFFFFFFFFFFF == 18446744073709551615
- val_str = "18446744073709551615";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.5", val_str, result_str);
-
- val = U64L(10000000000000000000); // testing preserving of 0s
- val_str = "10000000000000000000";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.6", val_str, result_str);
-
- val = 1; // testing no leading 0s
- val_str = "1";
- U64_to_str(val, result, sizeof(result));
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.7", val_str, result_str);
-
- val = U64L(18446744073709551615); // testing exact sized buffer for result
- val_str = "18446744073709551615";
- memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
- U64_to_str(val, result, sizeof("18446744073709551615")); //pass in the exact size
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.8", val_str, result_str);
-
- val = U64L(18446744073709551615); // testing smaller sized buffer for result
- val_str = "1844";
- memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
- U64_to_str(val, result, 5); //pass in a size of 5. should only copy first 4 integers and add a null terminator
- result_str = (const char*) result;
- ensure_equals("U64_to_str converted 1.9", val_str, result_str);
- }
-
- // str_to_U64
- template<> template<>
- void U64_object::test<2>()
- {
- U64 val;
- U64 result;
-
- val = U64L(18446744073709551610); // slightly less than MAX_U64
- result = str_to_U64("18446744073709551610");
- ensure_equals("str_to_U64 converted 2.1", val, result);
-
- val = U64L(0); // empty string
- result = str_to_U64(LLStringUtil::null);
- ensure_equals("str_to_U64 converted 2.2", val, result);
-
- val = U64L(0); // 0
- result = str_to_U64("0");
- ensure_equals("str_to_U64 converted 2.3", val, result);
-
- val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
- result = str_to_U64("18446744073709551615");
- ensure_equals("str_to_U64 converted 2.4", val, result);
-
- // overflow - will result in warning at compile time
- val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
- result = str_to_U64("18446744073709551616");
- ensure_equals("str_to_U64 converted 2.5", val, result);
-
- val = U64L(1234); // process till first non-integral character
- result = str_to_U64("1234A5678");
- ensure_equals("str_to_U64 converted 2.6", val, result);
-
- val = U64L(5678); // skip all non-integral characters
- result = str_to_U64("ABCD5678");
- ensure_equals("str_to_U64 converted 2.7", val, result);
-
- // should it skip negative sign and process
- // rest of string or return 0
- val = U64L(1234); // skip initial negative sign
- result = str_to_U64("-1234");
- ensure_equals("str_to_U64 converted 2.8", val, result);
-
- val = U64L(5678); // stop at negative sign in the middle
- result = str_to_U64("5678-1234");
- ensure_equals("str_to_U64 converted 2.9", val, result);
-
- val = U64L(0); // no integers
- result = str_to_U64("AaCD");
- ensure_equals("str_to_U64 converted 2.10", val, result);
- }
-
- // U64_to_F64
- template<> template<>
- void U64_object::test<3>()
- {
- F64 val;
- F64 result;
-
- result = 18446744073709551610.0;
- val = U64_to_F64(U64L(18446744073709551610));
- ensure_equals("U64_to_F64 converted 3.1", val, result);
-
- result = 18446744073709551615.0; // 0xFFFFFFFFFFFFFFFF
- val = U64_to_F64(U64L(18446744073709551615));
- ensure_equals("U64_to_F64 converted 3.2", val, result);
-
- result = 0.0; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
- // overflow - will result in warning at compile time
- val = U64_to_F64(U64L(18446744073709551615)+1);
- ensure_equals("U64_to_F64 converted 3.3", val, result);
-
- result = 0.0; // 0
- val = U64_to_F64(U64L(0));
- ensure_equals("U64_to_F64 converted 3.4", val, result);
-
- result = 1.0; // odd
- val = U64_to_F64(U64L(1));
- ensure_equals("U64_to_F64 converted 3.5", val, result);
-
- result = 2.0; // even
- val = U64_to_F64(U64L(2));
- ensure_equals("U64_to_F64 converted 3.6", val, result);
-
- result = U64L(0x7FFFFFFFFFFFFFFF) * 1.0L; // 0x7FFFFFFFFFFFFFFF
- val = U64_to_F64(U64L(0x7FFFFFFFFFFFFFFF));
- ensure_equals("U64_to_F64 converted 3.7", val, result);
- }
-
- // llstrtou64
- // seems to be deprecated - could not find it being used
- // anywhere in the tarball - skipping unit tests for now
+ struct U64_data
+ {
+ };
+ typedef test_group<U64_data> U64_test;
+ typedef U64_test::object U64_object;
+ tut::U64_test U64_testcase("U64_conversion");
+
+ // U64_to_str
+ template<> template<>
+ void U64_object::test<1>()
+ {
+ U64 val;
+ std::string val_str;
+ char result[256];
+ std::string result_str;
+
+ val = U64L(18446744073709551610); // slightly less than MAX_U64
+ val_str = "18446744073709551610";
+
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.1", val_str, result_str);
+
+ val = 0;
+ val_str = "0";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.2", val_str, result_str);
+
+ val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
+ val_str = "18446744073709551615";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.3", val_str, result_str);
+
+ // overflow - will result in warning at compile time
+ val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+ val_str = "0";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.4", val_str, result_str);
+
+ val = U64L(-1); // 0xFFFFFFFFFFFFFFFF == 18446744073709551615
+ val_str = "18446744073709551615";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.5", val_str, result_str);
+
+ val = U64L(10000000000000000000); // testing preserving of 0s
+ val_str = "10000000000000000000";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.6", val_str, result_str);
+
+ val = 1; // testing no leading 0s
+ val_str = "1";
+ U64_to_str(val, result, sizeof(result));
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.7", val_str, result_str);
+
+ val = U64L(18446744073709551615); // testing exact sized buffer for result
+ val_str = "18446744073709551615";
+ memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
+ U64_to_str(val, result, sizeof("18446744073709551615")); //pass in the exact size
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.8", val_str, result_str);
+
+ val = U64L(18446744073709551615); // testing smaller sized buffer for result
+ val_str = "1844";
+ memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
+ U64_to_str(val, result, 5); //pass in a size of 5. should only copy first 4 integers and add a null terminator
+ result_str = (const char*) result;
+ ensure_equals("U64_to_str converted 1.9", val_str, result_str);
+ }
+
+ // str_to_U64
+ template<> template<>
+ void U64_object::test<2>()
+ {
+ U64 val;
+ U64 result;
+
+ val = U64L(18446744073709551610); // slightly less than MAX_U64
+ result = str_to_U64("18446744073709551610");
+ ensure_equals("str_to_U64 converted 2.1", val, result);
+
+ val = U64L(0); // empty string
+ result = str_to_U64(LLStringUtil::null);
+ ensure_equals("str_to_U64 converted 2.2", val, result);
+
+ val = U64L(0); // 0
+ result = str_to_U64("0");
+ ensure_equals("str_to_U64 converted 2.3", val, result);
+
+ val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
+ result = str_to_U64("18446744073709551615");
+ ensure_equals("str_to_U64 converted 2.4", val, result);
+
+ // overflow - will result in warning at compile time
+ val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+ result = str_to_U64("18446744073709551616");
+ ensure_equals("str_to_U64 converted 2.5", val, result);
+
+ val = U64L(1234); // process till first non-integral character
+ result = str_to_U64("1234A5678");
+ ensure_equals("str_to_U64 converted 2.6", val, result);
+
+ val = U64L(5678); // skip all non-integral characters
+ result = str_to_U64("ABCD5678");
+ ensure_equals("str_to_U64 converted 2.7", val, result);
+
+ // should it skip negative sign and process
+ // rest of string or return 0
+ val = U64L(1234); // skip initial negative sign
+ result = str_to_U64("-1234");
+ ensure_equals("str_to_U64 converted 2.8", val, result);
+
+ val = U64L(5678); // stop at negative sign in the middle
+ result = str_to_U64("5678-1234");
+ ensure_equals("str_to_U64 converted 2.9", val, result);
+
+ val = U64L(0); // no integers
+ result = str_to_U64("AaCD");
+ ensure_equals("str_to_U64 converted 2.10", val, result);
+ }
+
+ // U64_to_F64
+ template<> template<>
+ void U64_object::test<3>()
+ {
+ F64 val;
+ F64 result;
+
+ result = 18446744073709551610.0;
+ val = U64_to_F64(U64L(18446744073709551610));
+ ensure_equals("U64_to_F64 converted 3.1", val, result);
+
+ result = 18446744073709551615.0; // 0xFFFFFFFFFFFFFFFF
+ val = U64_to_F64(U64L(18446744073709551615));
+ ensure_equals("U64_to_F64 converted 3.2", val, result);
+
+ result = 0.0; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+ // overflow - will result in warning at compile time
+ val = U64_to_F64(U64L(18446744073709551615)+1);
+ ensure_equals("U64_to_F64 converted 3.3", val, result);
+
+ result = 0.0; // 0
+ val = U64_to_F64(U64L(0));
+ ensure_equals("U64_to_F64 converted 3.4", val, result);
+
+ result = 1.0; // odd
+ val = U64_to_F64(U64L(1));
+ ensure_equals("U64_to_F64 converted 3.5", val, result);
+
+ result = 2.0; // even
+ val = U64_to_F64(U64L(2));
+ ensure_equals("U64_to_F64 converted 3.6", val, result);
+
+ result = U64L(0x7FFFFFFFFFFFFFFF) * 1.0L; // 0x7FFFFFFFFFFFFFFF
+ val = U64_to_F64(U64L(0x7FFFFFFFFFFFFFFF));
+ ensure_equals("U64_to_F64 converted 3.7", val, result);
+ }
+
+ // llstrtou64
+ // seems to be deprecated - could not find it being used
+ // anywhere in the tarball - skipping unit tests for now
}
namespace tut
{
- struct hash_data
- {
- };
- typedef test_group<hash_data> hash_test;
- typedef hash_test::object hash_object;
- tut::hash_test hash_tester("LLHash");
+ struct hash_data
+ {
+ };
+ typedef test_group<hash_data> hash_test;
+ typedef hash_test::object hash_object;
+ tut::hash_test hash_tester("LLHash");
+
+ template<> template<>
+ void hash_object::test<1>()
+ {
+ const char * str1 = "test string one";
+ const char * same_as_str1 = "test string one";
+
+ size_t hash1 = llhash(str1);
+ size_t same_as_hash1 = llhash(same_as_str1);
- template<> template<>
- void hash_object::test<1>()
- {
- const char * str1 = "test string one";
- const char * same_as_str1 = "test string one";
- size_t hash1 = llhash(str1);
- size_t same_as_hash1 = llhash(same_as_str1);
+ ensure("Hashes from identical strings should be equal", hash1 == same_as_hash1);
+ char str[100];
+ strcpy( str, "Another test" );
- ensure("Hashes from identical strings should be equal", hash1 == same_as_hash1);
-
- char str[100];
- strcpy( str, "Another test" );
+ size_t hash2 = llhash(str);
- size_t hash2 = llhash(str);
-
- strcpy( str, "Different string, same pointer" );
+ strcpy( str, "Different string, same pointer" );
- size_t hash3 = llhash(str);
+ size_t hash3 = llhash(str);
- ensure("Hashes from same pointer but different string should not be equal", hash2 != hash3);
- }
+ ensure("Hashes from same pointer but different string should not be equal", hash2 != hash3);
+ }
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-28 17:12:21 +0000