summaryrefslogtreecommitdiff
path: root/indra/test/lltut.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/test/lltut.cpp')
-rw-r--r--indra/test/lltut.cpp338
1 files changed, 169 insertions, 169 deletions
diff --git a/indra/test/lltut.cpp b/indra/test/lltut.cpp
index 5a8ee87afd..36c8fe4078 100644
--- a/indra/test/lltut.cpp
+++ b/indra/test/lltut.cpp
@@ -1,4 +1,4 @@
-/**
+/**
* @file lltut.cpp
* @author Mark Lentczner
* @date 5/16/06
@@ -7,21 +7,21 @@
* $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$
*/
@@ -38,169 +38,169 @@
namespace tut
{
- void ensure_equals(const std::string& msg, const LLDate& actual,
- const LLDate& expected)
- {
- ensure_equals(msg,
- actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
- }
-
- void ensure_equals(const std::string& msg, const LLURI& actual,
- const LLURI& expected)
- {
- ensure_equals(msg,
- actual.asString(), expected.asString());
- }
-
- // The lexical param types here intentionally diverge from the declaration
- // in our header file. In lltut.h, LLSD is only a forward-declared type;
- // we have no access to its LLSD::Binary nested type, and so must restate
- // it explicitly to declare this overload. However, an overload that does
- // NOT match LLSD::Binary does us no good whatsoever: it would never be
- // engaged. Stating LLSD::Binary for this definition at least means that
- // if the LLSD::Binary type ever diverges from what we expect in lltut.h,
- // that divergence will produce an error: no definition will match that
- // declaration.
- void ensure_equals(const std::string& msg,
- const LLSD::Binary& actual, const LLSD::Binary& expected)
- {
- ensure_equals(msg + " size", actual.size(), expected.size());
-
- LLSD::Binary::const_iterator i, j;
- int k;
- for (i = actual.begin(), j = expected.begin(), k = 0;
- i != actual.end();
- ++i, ++j, ++k)
- {
- ensure_equals(msg + " field", *i, *j);
- }
- }
-
- void ensure_equals(const std::string& msg, const LLSD& actual,
- const LLSD& expected)
- {
- ensure_equals(msg + " type", actual.type(), expected.type());
- switch (actual.type())
- {
- case LLSD::TypeUndefined:
- return;
-
- case LLSD::TypeBoolean:
- ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
- return;
-
- case LLSD::TypeInteger:
- ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
- return;
-
- case LLSD::TypeReal:
- ensure_equals(msg + " real", actual.asReal(), expected.asReal());
- return;
-
- case LLSD::TypeString:
- ensure_equals(msg + " string", actual.asString(), expected.asString());
- return;
-
- case LLSD::TypeUUID:
- ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
- return;
-
- case LLSD::TypeDate:
- ensure_equals(msg + " date", actual.asDate(), expected.asDate());
- return;
-
- case LLSD::TypeURI:
- ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
- return;
-
- case LLSD::TypeBinary:
- ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
- return;
-
- case LLSD::TypeMap:
- {
- ensure_equals(msg + " map size", actual.size(), expected.size());
-
- LLSD::map_const_iterator actual_iter = actual.beginMap();
- LLSD::map_const_iterator expected_iter = expected.beginMap();
-
- while(actual_iter != actual.endMap())
- {
- ensure_equals(msg + " map keys",
- actual_iter->first, expected_iter->first);
- ensure_equals(msg + "[" + actual_iter->first + "]",
- actual_iter->second, expected_iter->second);
- ++actual_iter;
- ++expected_iter;
- }
- return;
- }
- case LLSD::TypeArray:
- {
- ensure_equals(msg + " array size", actual.size(), expected.size());
-
- for(int i = 0; i < actual.size(); ++i)
- {
- ensure_equals(msg + llformat("[%d]", i),
- actual[i], expected[i]);
- }
- return;
- }
- default:
- // should never get here, but compiler produces warning if we
- // don't cover this case, and at Linden warnings are fatal.
- throw failure(STRINGIZE("invalid type field " << actual.type()));
- }
- }
-
- void ensure_starts_with(const std::string& msg,
- const std::string& actual, const std::string& expectedStart)
- {
- if( actual.find(expectedStart, 0) != 0 )
- {
- std::stringstream ss;
- ss << msg << ": " << "expected to find '" << expectedStart
- << "' at start of actual '" << actual << "'";
- throw failure(ss.str().c_str());
- }
- }
-
- void ensure_ends_with(const std::string& msg,
- const std::string& actual, const std::string& expectedEnd)
- {
- if( actual.size() < expectedEnd.size()
- || actual.rfind(expectedEnd)
- != (actual.size() - expectedEnd.size()) )
- {
- std::stringstream ss;
- ss << msg << ": " << "expected to find '" << expectedEnd
- << "' at end of actual '" << actual << "'";
- throw failure(ss.str().c_str());
- }
- }
-
- void ensure_contains(const std::string& msg,
- const std::string& actual, const std::string& expectedSubString)
- {
- if( actual.find(expectedSubString, 0) == std::string::npos )
- {
- std::stringstream ss;
- ss << msg << ": " << "expected to find '" << expectedSubString
- << "' in actual '" << actual << "'";
- throw failure(ss.str().c_str());
- }
- }
-
- void ensure_does_not_contain(const std::string& msg,
- const std::string& actual, const std::string& expectedSubString)
- {
- if( actual.find(expectedSubString, 0) != std::string::npos )
- {
- std::stringstream ss;
- ss << msg << ": " << "expected not to find " << expectedSubString
- << " in actual " << actual;
- throw failure(ss.str().c_str());
- }
- }
+ void ensure_equals(const std::string& msg, const LLDate& actual,
+ const LLDate& expected)
+ {
+ ensure_equals(msg,
+ actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
+ }
+
+ void ensure_equals(const std::string& msg, const LLURI& actual,
+ const LLURI& expected)
+ {
+ ensure_equals(msg,
+ actual.asString(), expected.asString());
+ }
+
+ // The lexical param types here intentionally diverge from the declaration
+ // in our header file. In lltut.h, LLSD is only a forward-declared type;
+ // we have no access to its LLSD::Binary nested type, and so must restate
+ // it explicitly to declare this overload. However, an overload that does
+ // NOT match LLSD::Binary does us no good whatsoever: it would never be
+ // engaged. Stating LLSD::Binary for this definition at least means that
+ // if the LLSD::Binary type ever diverges from what we expect in lltut.h,
+ // that divergence will produce an error: no definition will match that
+ // declaration.
+ void ensure_equals(const std::string& msg,
+ const LLSD::Binary& actual, const LLSD::Binary& expected)
+ {
+ ensure_equals(msg + " size", actual.size(), expected.size());
+
+ LLSD::Binary::const_iterator i, j;
+ int k;
+ for (i = actual.begin(), j = expected.begin(), k = 0;
+ i != actual.end();
+ ++i, ++j, ++k)
+ {
+ ensure_equals(msg + " field", *i, *j);
+ }
+ }
+
+ void ensure_equals(const std::string& msg, const LLSD& actual,
+ const LLSD& expected)
+ {
+ ensure_equals(msg + " type", actual.type(), expected.type());
+ switch (actual.type())
+ {
+ case LLSD::TypeUndefined:
+ return;
+
+ case LLSD::TypeBoolean:
+ ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
+ return;
+
+ case LLSD::TypeInteger:
+ ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
+ return;
+
+ case LLSD::TypeReal:
+ ensure_equals(msg + " real", actual.asReal(), expected.asReal());
+ return;
+
+ case LLSD::TypeString:
+ ensure_equals(msg + " string", actual.asString(), expected.asString());
+ return;
+
+ case LLSD::TypeUUID:
+ ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
+ return;
+
+ case LLSD::TypeDate:
+ ensure_equals(msg + " date", actual.asDate(), expected.asDate());
+ return;
+
+ case LLSD::TypeURI:
+ ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
+ return;
+
+ case LLSD::TypeBinary:
+ ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
+ return;
+
+ case LLSD::TypeMap:
+ {
+ ensure_equals(msg + " map size", actual.size(), expected.size());
+
+ LLSD::map_const_iterator actual_iter = actual.beginMap();
+ LLSD::map_const_iterator expected_iter = expected.beginMap();
+
+ while(actual_iter != actual.endMap())
+ {
+ ensure_equals(msg + " map keys",
+ actual_iter->first, expected_iter->first);
+ ensure_equals(msg + "[" + actual_iter->first + "]",
+ actual_iter->second, expected_iter->second);
+ ++actual_iter;
+ ++expected_iter;
+ }
+ return;
+ }
+ case LLSD::TypeArray:
+ {
+ ensure_equals(msg + " array size", actual.size(), expected.size());
+
+ for(int i = 0; i < actual.size(); ++i)
+ {
+ ensure_equals(msg + llformat("[%d]", i),
+ actual[i], expected[i]);
+ }
+ return;
+ }
+ default:
+ // should never get here, but compiler produces warning if we
+ // don't cover this case, and at Linden warnings are fatal.
+ throw failure(STRINGIZE("invalid type field " << actual.type()));
+ }
+ }
+
+ void ensure_starts_with(const std::string& msg,
+ const std::string& actual, const std::string& expectedStart)
+ {
+ if( actual.find(expectedStart, 0) != 0 )
+ {
+ std::stringstream ss;
+ ss << msg << ": " << "expected to find '" << expectedStart
+ << "' at start of actual '" << actual << "'";
+ throw failure(ss.str().c_str());
+ }
+ }
+
+ void ensure_ends_with(const std::string& msg,
+ const std::string& actual, const std::string& expectedEnd)
+ {
+ if( actual.size() < expectedEnd.size()
+ || actual.rfind(expectedEnd)
+ != (actual.size() - expectedEnd.size()) )
+ {
+ std::stringstream ss;
+ ss << msg << ": " << "expected to find '" << expectedEnd
+ << "' at end of actual '" << actual << "'";
+ throw failure(ss.str().c_str());
+ }
+ }
+
+ void ensure_contains(const std::string& msg,
+ const std::string& actual, const std::string& expectedSubString)
+ {
+ if( actual.find(expectedSubString, 0) == std::string::npos )
+ {
+ std::stringstream ss;
+ ss << msg << ": " << "expected to find '" << expectedSubString
+ << "' in actual '" << actual << "'";
+ throw failure(ss.str().c_str());
+ }
+ }
+
+ void ensure_does_not_contain(const std::string& msg,
+ const std::string& actual, const std::string& expectedSubString)
+ {
+ if( actual.find(expectedSubString, 0) != std::string::npos )
+ {
+ std::stringstream ss;
+ ss << msg << ": " << "expected not to find " << expectedSubString
+ << " in actual " << actual;
+ throw failure(ss.str().c_str());
+ }
+ }
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 10:28:33 +0000