diff options
Diffstat (limited to 'indra/test')
| -rwxr-xr-x | indra/test/llevents_tut.cpp | 2 | ||||
| -rwxr-xr-x | indra/test/lltut.cpp | 25 | ||||
| -rwxr-xr-x | indra/test/lltut.h | 95 |
3 files changed, 75 insertions, 47 deletions
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp index a9114075fc..16edab6282 100755 --- a/indra/test/llevents_tut.cpp +++ b/indra/test/llevents_tut.cpp @@ -48,10 +48,10 @@ #include <boost/shared_ptr.hpp> #include <boost/assign/list_of.hpp> // other Linden headers +#include "tests/listener.h" // must PRECEDE lltut.h #include "lltut.h" #include "catch_and_store_what_in.h" #include "stringize.h" -#include "tests/listener.h" using boost::assign::list_of; diff --git a/indra/test/lltut.cpp b/indra/test/lltut.cpp index a183cef9a9..2730fb34d7 100755 --- a/indra/test/lltut.cpp +++ b/indra/test/lltut.cpp @@ -52,12 +52,25 @@ namespace tut 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 char* msg, - const std::vector<U8>& actual, const std::vector<U8>& expected) + const LLSD::Binary& actual, const LLSD::Binary& expected) { - std::string s(msg); - - ensure_equals(s + " size", actual.size(), expected.size()); + ensure_equals(std::string(msg? msg : ""), actual, expected); + } + + void ensure_equals(const std::string& msg, + const LLSD::Binary& actual, const LLSD::Binary& expected) + { + ensure_equals(msg + " size", actual.size(), expected.size()); std::vector<U8>::const_iterator i, j; int k; @@ -65,14 +78,14 @@ namespace tut i != actual.end(); ++i, ++j, ++k) { - ensure_equals(s + " field", *i, *j); + ensure_equals(msg + " field", *i, *j); } } void ensure_equals(const char* m, const LLSD& actual, const LLSD& expected) { - ensure_equals(std::string(m), actual, expected); + ensure_equals(std::string(m? m : ""), actual, expected); } void ensure_equals(const std::string& msg, const LLSD& actual, diff --git a/indra/test/lltut.h b/indra/test/lltut.h index 5428be3719..6cb670b2a3 100755 --- a/indra/test/lltut.h +++ b/indra/test/lltut.h @@ -30,6 +30,60 @@ #define LL_LLTUT_H #include "is_approx_equal_fraction.h" // instead of llmath.h +#include <cstring> + +class LLDate; +class LLSD; +class LLURI; + +namespace tut +{ + template <class T,class Q> + void ensure_equals(const std::string& msg, + const Q& actual,const T& expected) + { ensure_equals(msg.c_str(), actual, expected); } + + void ensure_equals(const char* msg, + const LLDate& actual, const LLDate& expected); + + void ensure_equals(const char* msg, + const LLURI& actual, const LLURI& expected); + + // std::vector<U8> is the current definition of LLSD::Binary. Because + // we're only forward-declaring LLSD in this header file, we can't + // directly reference that nested type. If the build complains that + // there's no definition for either of these declarations, it could be + // that LLSD::Binary has changed, and that these declarations must be + // adjusted to match. + void ensure_equals(const char* msg, + const std::vector<U8>& actual, const std::vector<U8>& expected); + + void ensure_equals(const std::string& msg, + const std::vector<U8>& actual, const std::vector<U8>& expected); + + void ensure_equals(const char* msg, + const LLSD& actual, const LLSD& expected); + + void ensure_equals(const std::string& msg, + const LLSD& actual, const LLSD& expected); + + void ensure_starts_with(const std::string& msg, + const std::string& actual, const std::string& expectedStart); + + void ensure_ends_with(const std::string& msg, + const std::string& actual, const std::string& expectedEnd); + + void ensure_contains(const std::string& msg, + const std::string& actual, const std::string& expectedSubString); + + void ensure_does_not_contain(const std::string& msg, + const std::string& actual, const std::string& expectedSubString); +} + +// This is an odd place to #include an important contributor -- but the usual +// rules are reversed here. Instead of the overloads above referencing tut.hpp +// features, we need calls in tut.hpp template functions to dispatch to our +// overloads declared above. // turn off warnings about unused functions from clang for tut package #pragma clang diagnostic push @@ -37,12 +91,7 @@ #include <tut/tut.hpp> #pragma clang diagnostic pop -#include <cstring> - -class LLDate; -class LLSD; -class LLURI; - +// The functions BELOW this point actually consume tut.hpp functionality. namespace tut { inline void ensure_approximately_equals(const char* msg, F64 actual, F64 expected, U32 frac_bits) @@ -112,40 +161,6 @@ namespace tut { ensure_not_equals(NULL, actual, expected); } - - - template <class T,class Q> - void ensure_equals(const std::string& msg, - const Q& actual,const T& expected) - { ensure_equals(msg.c_str(), actual, expected); } - - void ensure_equals(const char* msg, - const LLDate& actual, const LLDate& expected); - - void ensure_equals(const char* msg, - const LLURI& actual, const LLURI& expected); - - void ensure_equals(const char* msg, - const std::vector<U8>& actual, const std::vector<U8>& expected); - - void ensure_equals(const char* msg, - const LLSD& actual, const LLSD& expected); - - void ensure_equals(const std::string& msg, - const LLSD& actual, const LLSD& expected); - - void ensure_starts_with(const std::string& msg, - const std::string& actual, const std::string& expectedStart); - - void ensure_ends_with(const std::string& msg, - const std::string& actual, const std::string& expectedEnd); - - void ensure_contains(const std::string& msg, - const std::string& actual, const std::string& expectedSubString); - - void ensure_does_not_contain(const std::string& msg, - const std::string& actual, const std::string& expectedSubString); } - #endif // LL_LLTUT_H |