From 8a289a161df3e9856f65e09d8828ad8f6d84654f Mon Sep 17 00:00:00 2001 From: Logan Dethrow Date: Fri, 9 Sep 2011 15:52:36 -0400 Subject: Re-enabled and fixed llsd_new_tut.cpp by copying the fixed version from the server test directory. --- indra/test/llsd_new_tut.cpp | 69 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 56 insertions(+), 13 deletions(-) (limited to 'indra/test/llsd_new_tut.cpp') diff --git a/indra/test/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp index dd93b36f04..18bc03d5d6 100644 --- a/indra/test/llsd_new_tut.cpp +++ b/indra/test/llsd_new_tut.cpp @@ -5,7 +5,7 @@ * * $LicenseInfo:firstyear=2006&license=viewerlgpl$ * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. + * Copyright (C) 2006-2011, 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 @@ -32,6 +32,17 @@ #include "llsdtraits.h" #include "llstring.h" +#if LL_WINDOWS +#include +namespace std +{ + int fpclassify(double x) + { + return _fpclass(x); + } +} +#endif + namespace tut { class SDCleanupCheck @@ -218,19 +229,16 @@ namespace tut } else { -// TODO: Fix on windows.... -#ifndef LL_WINDOWS -# if !defined(fpclassify) && __GNUC__ >= 3 -# define FPCLASSIFY_NAMESPACE std:: -# else -# define FPCLASSIFY_NAMESPACE -# endif - int left = FPCLASSIFY_NAMESPACE fpclassify(v.asReal()); - int right = FPCLASSIFY_NAMESPACE fpclassify(eReal); + int left = std::fpclassify(v.asReal()); + int right = std::fpclassify(eReal); ensure_equals(s+" to real", left, right); - ensure_equals(s+" to string", v.asString(), eString); -#endif + // ensure_equals(s+" to string", v.asString(), eString); + // I've commented this check out, since there doesn't + // seem to be uniform string representation for NaN on + // all platforms. For example, on my Ubuntu 8.10 laptop + // with libc 2.11.1, sqrt(-1.0) will return '-nan', not + // 'nan'. } } @@ -742,6 +750,42 @@ namespace tut LLSD w = v; w = "nice day"; } + + { + SDAllocationCheck check("shared values test for threaded work", 9); + + //U32 start_llsd_count = LLSD::outstandingCount(); + + LLSD m = LLSD::emptyMap(); + + m["one"] = 1; + m["two"] = 2; + m["one_copy"] = m["one"]; // 3 (m, "one" and "two") + + m["undef_one"] = LLSD(); + m["undef_two"] = LLSD(); + m["undef_one_copy"] = m["undef_one"]; + + { // Ensure first_array gets freed to avoid counting it + LLSD first_array = LLSD::emptyArray(); + first_array.append(1.0f); + first_array.append(2.0f); + first_array.append(3.0f); // 7 + + m["array"] = first_array; + m["array_clone"] = first_array; + m["array_copy"] = m["array"]; // 7 + } + + m["string_one"] = "string one value"; + m["string_two"] = "string two value"; + m["string_one_copy"] = m["string_one"]; // 9 + + //U32 llsd_object_count = LLSD::outstandingCount(); + //std::cout << "Using " << (llsd_object_count - start_llsd_count) << " LLSD objects" << std::endl; + + //m.dumpStats(); + } } template<> template<> @@ -769,4 +813,3 @@ namespace tut test serializations */ } - -- cgit v1.3 From d1ccfc5495524758161d5004a78f834f47f9c017 Mon Sep 17 00:00:00 2001 From: Logan Dethrow Date: Wed, 5 Oct 2011 15:33:53 -0400 Subject: Changed the handling of the different naming of fpclassify on windows and Linux in llsd_new_tut.cpp to be more clean at Nat's recommendation. --- indra/test/llsd_new_tut.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'indra/test/llsd_new_tut.cpp') diff --git a/indra/test/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp index 18bc03d5d6..b2fa54a688 100644 --- a/indra/test/llsd_new_tut.cpp +++ b/indra/test/llsd_new_tut.cpp @@ -34,13 +34,15 @@ #if LL_WINDOWS #include -namespace std +namespace { int fpclassify(double x) { return _fpclass(x); } } +#else +using std::fpclassify; #endif namespace tut @@ -229,8 +231,8 @@ namespace tut } else { - int left = std::fpclassify(v.asReal()); - int right = std::fpclassify(eReal); + int left = fpclassify(v.asReal()); + int right = fpclassify(eReal); ensure_equals(s+" to real", left, right); // ensure_equals(s+" to string", v.asString(), eString); -- cgit v1.3 From b0d869554b902c30f8a874b1e772a0241acf9f1f Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 17 Nov 2011 11:10:39 -0500 Subject: LLSD-14: Add tests from Simon's server-trunk changeset 3852648182db. That changeset provides most of the changes previously checked in on this Jira (viewer changeset 22b293aae639). Bring over the code he added to llsd_new_tut.cpp as well. --- indra/test/llsd_new_tut.cpp | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) (limited to 'indra/test/llsd_new_tut.cpp') diff --git a/indra/test/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp index dd93b36f04..f332ad0ee2 100644 --- a/indra/test/llsd_new_tut.cpp +++ b/indra/test/llsd_new_tut.cpp @@ -742,6 +742,42 @@ namespace tut LLSD w = v; w = "nice day"; } + + { + SDAllocationCheck check("shared values test for threaded work", 9); + + //U32 start_llsd_count = LLSD::outstandingCount(); + + LLSD m = LLSD::emptyMap(); + + m["one"] = 1; + m["two"] = 2; + m["one_copy"] = m["one"]; // 3 (m, "one" and "two") + + m["undef_one"] = LLSD(); + m["undef_two"] = LLSD(); + m["undef_one_copy"] = m["undef_one"]; + + { // Ensure first_array gets freed to avoid counting it + LLSD first_array = LLSD::emptyArray(); + first_array.append(1.0f); + first_array.append(2.0f); + first_array.append(3.0f); // 7 + + m["array"] = first_array; + m["array_clone"] = first_array; + m["array_copy"] = m["array"]; // 7 + } + + m["string_one"] = "string one value"; + m["string_two"] = "string two value"; + m["string_one_copy"] = m["string_one"]; // 9 + + //U32 llsd_object_count = LLSD::outstandingCount(); + //std::cout << "Using " << (llsd_object_count - start_llsd_count) << " LLSD objects" << std::endl; + + //m.dumpStats(); + } } template<> template<> -- cgit v1.3 From 95fb0249e9f43d907608cc5840d1f8c0e49981d0 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 1 Dec 2011 16:50:27 -0500 Subject: LLSD-14: Move LLSD::(outstanding|allocation)Count() to free functions. Free functions can be unconditionally compiled into the .o file, but conditionally hidden in the header file. Static class methods don't have that flexibility: without a declaration in the header file, you can't compile a function definition in the .cpp file. That makes it awkward to use the same llcommon build for production and for unit tests. Why make the function declarations conditional at all? These are debugging functions. They break the abstraction, they peek under the covers. Production code should not use them. Making them conditional on an #ifdef symbol in the unit-test source file means the compiler would reject any use by production code. Put differently, it allows us to assert with confidence that only unit tests do use them. Put new free functions in (lowercase) llsd namespace so as not to clutter global namespace. Tweak the one known consumer (llsd_new_tut.cpp) accordingly. --- indra/llcommon/llsd.cpp | 14 ++++++++------ indra/llcommon/llsd.h | 30 +++++++++++++++++------------- indra/test/llsd_new_tut.cpp | 13 +++++++------ 3 files changed, 32 insertions(+), 25 deletions(-) (limited to 'indra/test/llsd_new_tut.cpp') diff --git a/indra/llcommon/llsd.cpp b/indra/llcommon/llsd.cpp index 1bd5d06d29..08cb7bd2a8 100644 --- a/indra/llcommon/llsd.cpp +++ b/indra/llcommon/llsd.cpp @@ -91,7 +91,7 @@ protected: bool shared() const { return (mUseCount > 1) && (mUseCount != STATIC_USAGE_COUNT); } U32 mUseCount; - + public: static void reset(Impl*& var, Impl* impl); ///< safely set var to refer to the new impl (possibly shared) @@ -901,11 +901,6 @@ LLSD& LLSD::operator[](Integer i) const LLSD& LLSD::operator[](Integer i) const { return safe(impl).ref(i); } -#ifdef LLSD_DEBUG_INFO -U32 LLSD::allocationCount() { return Impl::sAllocationCount; } -U32 LLSD::outstandingCount() { return Impl::sOutstandingCount; } -#endif - static const char *llsd_dump(const LLSD &llsd, bool useXMLFormat) { // sStorage is used to hold the string representation of the llsd last @@ -954,6 +949,13 @@ LLSD::array_iterator LLSD::endArray() { return makeArray(impl).endArray(); } LLSD::array_const_iterator LLSD::beginArray() const{ return safe(impl).beginArray(); } LLSD::array_const_iterator LLSD::endArray() const { return safe(impl).endArray(); } +namespace llsd +{ + +U32 allocationCount() { return LLSD::Impl::sAllocationCount; } +U32 outstandingCount() { return LLSD::Impl::sOutstandingCount; } + +} // namespace llsd // Diagnostic dump of contents in an LLSD object #ifdef LLSD_DEBUG_INFO diff --git a/indra/llcommon/llsd.h b/indra/llcommon/llsd.h index 3519b134c2..ae083dd629 100644 --- a/indra/llcommon/llsd.h +++ b/indra/llcommon/llsd.h @@ -389,19 +389,6 @@ private: Impl* impl; friend class LLSD::Impl; //@} - - /** @name Unit Testing Interface */ - //@{ -public: -#ifdef LLSD_DEBUG_INFO - /// @warn THESE COUNTS WILL NOT BE ACCURATE IN A MULTI-THREADED - /// ENVIRONMENT. - /// - /// These counts track LLSD::Impl (hidden) objects. - static U32 allocationCount(); ///< how many Impls have been made - static U32 outstandingCount(); ///< how many Impls are still alive -#endif - //@} private: /** @name Debugging Interface */ @@ -475,6 +462,23 @@ struct llsd_select_string : public std::unary_function LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLSD& llsd); +namespace llsd +{ + +/** @name Unit Testing Interface */ +//@{ +#ifdef LLSD_DEBUG_INFO + /// @warn THESE COUNTS WILL NOT BE ACCURATE IN A MULTI-THREADED + /// ENVIRONMENT. + /// + /// These counts track LLSD::Impl (hidden) objects. + LL_COMMON_API U32 allocationCount(); ///< how many Impls have been made + LL_COMMON_API U32 outstandingCount(); ///< how many Impls are still alive +#endif +//@} + +} // namespace llsd + /** QUESTIONS & TO DOS - Would Binary be more convenient as unsigned char* buffer semantics? - Should Binary be convertible to/from String, and if so how? diff --git a/indra/test/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp index f332ad0ee2..b55a562e98 100644 --- a/indra/test/llsd_new_tut.cpp +++ b/indra/test/llsd_new_tut.cpp @@ -25,6 +25,7 @@ * $/LicenseInfo$ */ +#define LLSD_DEBUG_INFO #include #include "linden_common.h" #include "lltut.h" @@ -39,11 +40,11 @@ namespace tut private: U32 mOutstandingAtStart; public: - SDCleanupCheck() : mOutstandingAtStart(LLSD::outstandingCount()) { } + SDCleanupCheck() : mOutstandingAtStart(llsd::outstandingCount()) { } ~SDCleanupCheck() { ensure_equals("SDCleanupCheck", - LLSD::outstandingCount(), mOutstandingAtStart); + llsd::outstandingCount(), mOutstandingAtStart); } }; @@ -57,12 +58,12 @@ namespace tut SDAllocationCheck(const std::string& message, int expectedAllocations) : mMessage(message), mExpectedAllocations(expectedAllocations), - mAllocationAtStart(LLSD::allocationCount()) + mAllocationAtStart(llsd::allocationCount()) { } ~SDAllocationCheck() { ensure_equals(mMessage + " SDAllocationCheck", - LLSD::allocationCount() - mAllocationAtStart, + llsd::allocationCount() - mAllocationAtStart, mExpectedAllocations); } }; @@ -746,7 +747,7 @@ namespace tut { SDAllocationCheck check("shared values test for threaded work", 9); - //U32 start_llsd_count = LLSD::outstandingCount(); + //U32 start_llsd_count = llsd::outstandingCount(); LLSD m = LLSD::emptyMap(); @@ -773,7 +774,7 @@ namespace tut m["string_two"] = "string two value"; m["string_one_copy"] = m["string_one"]; // 9 - //U32 llsd_object_count = LLSD::outstandingCount(); + //U32 llsd_object_count = llsd::outstandingCount(); //std::cout << "Using " << (llsd_object_count - start_llsd_count) << " LLSD objects" << std::endl; //m.dumpStats(); -- cgit v1.3