From 0f665666201146069647d1686e2ff565d469097b Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 13 Jul 2011 17:36:59 -0400 Subject: Introduce support for C++ integration tests running Python scripts. This is in its infancy; tested on Mac; needs to be ironed out on Windows and Linux. Goal is to test at least some cross-language LLSD serialization. --- indra/llcommon/CMakeLists.txt | 3 +- indra/llcommon/tests/llsdserialize_test.cpp | 97 ++++++++++++++++++++++++----- indra/llcommon/tests/setpython.py | 19 ++++++ 3 files changed, 103 insertions(+), 16 deletions(-) create mode 100644 indra/llcommon/tests/setpython.py (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index 9910281b64..c755020a64 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -317,7 +317,8 @@ if (LL_TESTS) LL_ADD_INTEGRATION_TEST(lllazy "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llprocessor "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llrand "" "${test_libs}") - LL_ADD_INTEGRATION_TEST(llsdserialize "" "${test_libs}") + LL_ADD_INTEGRATION_TEST(llsdserialize "" "${test_libs}" + "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/setpython.py") LL_ADD_INTEGRATION_TEST(llstring "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lltreeiterators "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lluri "" "${test_libs}") diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 7b4c7d6a48..75b79467b7 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -25,33 +25,26 @@ * $/LicenseInfo$ */ -#if !LL_WINDOWS -#include -#endif - #include "linden_common.h" #include "../llsd.h" #include "../llsdserialize.h" #include "../llformat.h" #include "../test/lltut.h" - +#include "llprocesslauncher.h" +#include "stringize.h" #if LL_WINDOWS #include typedef U32 uint32_t; +#else +#include +#include #endif -std::vector string_to_vector(std::string str) +std::vector string_to_vector(const std::string& str) { - // bc LLSD can't... - size_t len = (size_t)str.length(); - std::vector v(len); - for (size_t i = 0; i < len ; i++) - { - v[i] = str[i]; - } - return v; + return std::vector(str.begin(), str.end()); } namespace tut @@ -1494,5 +1487,79 @@ namespace tut ensureBinaryAndNotation("map", test); ensureBinaryAndXML("map", test); } -} + struct TestPythonCompatible + { + TestPythonCompatible() {} + ~TestPythonCompatible() {} + + void python(const std::string& desc, const std::string& script, F32 timeout=5) + { + const char* PYTHON(getenv("PYTHON")); + ensure("Set $PYTHON to the Python interpreter", PYTHON); + LLProcessLauncher py; + py.setExecutable(PYTHON); + py.addArgument("-c"); + py.addArgument(script); + ensure_equals(STRINGIZE("Couldn't launch " << desc << " script"), py.launch(), 0); + +#if LL_WINDOWS + ensure_equals(STRINGIZE(desc << " script ran beyond " + << std::fixed << std::setprecision(1) + << timeout << " seconds"), + WaitForSingleObject(py.getProcessHandle(), DWORD(timeout * 1000)), + WAIT_OBJECT_0); + DWORD rc(0); + GetExitCodeProcess(py.getProcessHandle(), &rc); + ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); +#else + // Implementing timeout would mean messing with alarm() and + // catching SIGALRM... later maybe... + int status(0); + if (waitpid(py.getProcessID(), &status, 0) == -1) + { + int waitpid_errno(errno); + ensure_equals(STRINGIZE("Couldn't retrieve rc from " << desc << " script: " + "waitpid() errno " << waitpid_errno), + waitpid_errno, ECHILD); + } + else + { + if (WIFEXITED(status)) + { + int rc(WEXITSTATUS(status)); + ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); + } + else if (WIFSIGNALED(status)) + { + ensure(STRINGIZE(desc << " script terminated by signal " << WTERMSIG(status)), + false); + } + else + { + ensure(STRINGIZE(desc << " script produced impossible status " << status), + false); + } + } +#endif + } + }; + + typedef tut::test_group TestPythonCompatibleGroup; + typedef TestPythonCompatibleGroup::object TestPythonCompatibleObject; + TestPythonCompatibleGroup pycompat("LLSD serialize Python compatibility"); + + template<> template<> + void TestPythonCompatibleObject::test<1>() + { + python("hello", "print 'Hello, world!'"); + } + + template<> template<> + void TestPythonCompatibleObject::test<2>() + { + python("platform", +"import sys\n" +"print 'Running on', sys.platform"); + } +} diff --git a/indra/llcommon/tests/setpython.py b/indra/llcommon/tests/setpython.py new file mode 100644 index 0000000000..df7b90428e --- /dev/null +++ b/indra/llcommon/tests/setpython.py @@ -0,0 +1,19 @@ +#!/usr/bin/python +"""\ +@file setpython.py +@author Nat Goodspeed +@date 2011-07-13 +@brief Set PYTHON environment variable for tests that care. + +$LicenseInfo:firstyear=2011&license=viewerlgpl$ +Copyright (c) 2011, Linden Research, Inc. +$/LicenseInfo$ +""" + +import os +import sys +import subprocess + +if __name__ == "__main__": + os.environ["PYTHON"] = sys.executable + sys.exit(subprocess.call(sys.argv[1:])) -- cgit v1.2.3 From beea7cdc2d003d815ef2ac32978f841b81288494 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 13 Jul 2011 19:03:28 -0400 Subject: Attempt to fix confusing header-file-order problems on Windows. --- indra/llcommon/tests/llsdserialize_test.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 75b79467b7..6b96c0e234 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -25,6 +25,12 @@ * $/LicenseInfo$ */ +#if !LL_WINDOWS +#include +#include +#include +#endif + #include "linden_common.h" #include "../llsd.h" #include "../llsdserialize.h" @@ -37,9 +43,6 @@ #if LL_WINDOWS #include typedef U32 uint32_t; -#else -#include -#include #endif std::vector string_to_vector(const std::string& str) -- cgit v1.2.3 From ec780a733f46e2fc436ca5d492f42ab4e3e8b516 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 13 Jul 2011 19:41:23 -0400 Subject: Still trying to fix Windows header-file-order problem. --- indra/llcommon/tests/llsdserialize_test.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 6b96c0e234..ff0d8d5f46 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -25,13 +25,18 @@ * $/LicenseInfo$ */ -#if !LL_WINDOWS + +#include "linden_common.h" + +#if LL_WINDOWS +#include +typedef U32 uint32_t; +#else #include #include #include #endif -#include "linden_common.h" #include "../llsd.h" #include "../llsdserialize.h" #include "../llformat.h" @@ -40,11 +45,6 @@ #include "llprocesslauncher.h" #include "stringize.h" -#if LL_WINDOWS -#include -typedef U32 uint32_t; -#endif - std::vector string_to_vector(const std::string& str) { return std::vector(str.begin(), str.end()); -- cgit v1.2.3 From 0ab0efc3270f44da3d8b3a9db2845eeddde44dc6 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 14:00:12 -0400 Subject: Work around broken Windows command-line processing. It's wonderful that the Python interpreter will accept a whole multi-line script as a composite -c argument... but because Windows command-line processing is fundamentally flawed, we simply can't count on it for Windows. Instead, accept script text, write a temporary script file in a system- dependent temp directory, ask Python to run that script and delete the file. Also, on Windows, use _spawnl(), much simpler than adding bizarre Windows wait logic to LLProcessLauncher. Use LLProcessLauncher only on Mac & Linux, with waitpid() to capture rc. --- indra/llcommon/tests/llsdserialize_test.cpp | 93 ++++++++++++++++++++++++----- 1 file changed, 78 insertions(+), 15 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index ff0d8d5f46..4e09a4fe3c 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -31,18 +31,28 @@ #if LL_WINDOWS #include typedef U32 uint32_t; +#include #else #include #include #include +#include "llprocesslauncher.h" #endif +// As we're not trying to preserve compatibility with old Boost.Filesystem +// code, but rather writing brand-new code, use the newest available +// Filesystem API. +#define BOOST_FILESYSTEM_VERSION 3 +#include "boost/filesystem.hpp" +#include "boost/filesystem/v3/fstream.hpp" +#include "boost/range.hpp" +#include "boost/foreach.hpp" + #include "../llsd.h" #include "../llsdserialize.h" #include "../llformat.h" #include "../test/lltut.h" -#include "llprocesslauncher.h" #include "stringize.h" std::vector string_to_vector(const std::string& str) @@ -50,6 +60,51 @@ std::vector string_to_vector(const std::string& str) return std::vector(str.begin(), str.end()); } +// boost::filesystem::temp_directory_path() isn't yet in Boost 1.45! :-( +// Switch to that one as soon as we update to a Boost that contains it. +boost::filesystem::path temp_directory_path() +{ +#if LL_WINDOWS + char buffer[PATH_MAX]; + GetTempPath(sizeof(buffer), buffer); + return boost::filesystem::path(buffer); + +#else // LL_DARWIN, LL_LINUX + static const char* vars[] = { "TMPDIR", "TMP", "TEMP", "TEMPDIR" }; + BOOST_FOREACH(const char* var, vars) + { + const char* found = getenv(var); + if (found) + return boost::filesystem::path(found); + } + return boost::filesystem::path("/tmp"); +#endif // LL_DARWIN, LL_LINUX +} + +// Create a Python script file with specified content "somewhere in the +// filesystem," cleaning up when it goes out of scope. +class NamedTempScript +{ +public: + NamedTempScript(const std::string& content): + mPath(/*boost::filesystem*/::temp_directory_path() / + boost::filesystem::unique_path("%%%%-%%%%-%%%%-%%%%.py")) + { + boost::filesystem::ofstream file(mPath); + file << content << '\n'; + } + + ~NamedTempScript() + { + boost::filesystem::remove(mPath); + } + + std::string getName() const { return mPath.native(); } + +private: + boost::filesystem::path mPath; +}; + namespace tut { struct sd_xml_data @@ -1496,26 +1551,34 @@ namespace tut TestPythonCompatible() {} ~TestPythonCompatible() {} - void python(const std::string& desc, const std::string& script, F32 timeout=5) + void python(const std::string& desc, const std::string& script /*, F32 timeout=5 */) { const char* PYTHON(getenv("PYTHON")); ensure("Set $PYTHON to the Python interpreter", PYTHON); + + NamedTempScript scriptfile(script); + +#if LL_WINDOWS + std::string q("\""); + std::string qPYTHON(q + PYTHON + q); + std::string qscript(q + scriptfile.getName() + q); + int rc(_spawnl(_P_WAIT, PYTHON, qPYTHON.c_str(), qscript.c_str(), NULL)); + if (rc == -1) + { + char buffer[256]; + strerror_s(buffer, errno); // C++ can infer the buffer size! :-O + ensure(STRINGIZE("Couldn't run Python " << desc << "script: " << buffer), false); + } + else + { + ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); + } + +#else // LL_DARWIN, LL_LINUX LLProcessLauncher py; py.setExecutable(PYTHON); - py.addArgument("-c"); - py.addArgument(script); + py.addArgument(scriptfile.getName()); ensure_equals(STRINGIZE("Couldn't launch " << desc << " script"), py.launch(), 0); - -#if LL_WINDOWS - ensure_equals(STRINGIZE(desc << " script ran beyond " - << std::fixed << std::setprecision(1) - << timeout << " seconds"), - WaitForSingleObject(py.getProcessHandle(), DWORD(timeout * 1000)), - WAIT_OBJECT_0); - DWORD rc(0); - GetExitCodeProcess(py.getProcessHandle(), &rc); - ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); -#else // Implementing timeout would mean messing with alarm() and // catching SIGALRM... later maybe... int status(0); -- cgit v1.2.3 From 3ddaf95c5c0dc35f0efa91860f9642d4cdf26559 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 14:01:45 -0400 Subject: New llsdserialize_test logic needs Boost.Filesystem library. That, in turn, needs Boost.System library. --- indra/llcommon/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index c755020a64..09a05689f4 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -317,7 +317,8 @@ if (LL_TESTS) LL_ADD_INTEGRATION_TEST(lllazy "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llprocessor "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llrand "" "${test_libs}") - LL_ADD_INTEGRATION_TEST(llsdserialize "" "${test_libs}" + LL_ADD_INTEGRATION_TEST(llsdserialize "" + "${test_libs};${BOOST_FILESYSTEM_LIBRARY};${BOOST_SYSTEM_LIBRARY}" "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/setpython.py") LL_ADD_INTEGRATION_TEST(llstring "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lltreeiterators "" "${test_libs}") -- cgit v1.2.3 From 4c465f496f602860f5044bded01fde8883083e70 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 15:08:25 -0400 Subject: Eliminate use of PATH_MAX, which is bogus anyway. --- indra/llcommon/tests/llsdserialize_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 4e09a4fe3c..687c64dfeb 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -65,7 +65,7 @@ std::vector string_to_vector(const std::string& str) boost::filesystem::path temp_directory_path() { #if LL_WINDOWS - char buffer[PATH_MAX]; + char buffer[4096]; GetTempPath(sizeof(buffer), buffer); return boost::filesystem::path(buffer); -- cgit v1.2.3 From 24508cc924938d2a8752496b9752b7c4d934dd77 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 15:27:36 -0400 Subject: Attempt to fix minor build errors on Windows. --- indra/llcommon/tests/llsdserialize_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 687c64dfeb..e0a7835550 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -66,7 +66,7 @@ boost::filesystem::path temp_directory_path() { #if LL_WINDOWS char buffer[4096]; - GetTempPath(sizeof(buffer), buffer); + GetTempPathA(sizeof(buffer), buffer); return boost::filesystem::path(buffer); #else // LL_DARWIN, LL_LINUX @@ -99,7 +99,7 @@ public: boost::filesystem::remove(mPath); } - std::string getName() const { return mPath.native(); } + std::string getName() const { return mPath.string(); } private: boost::filesystem::path mPath; -- cgit v1.2.3 From 624c3f1a8e503a3a577b81e06b0ae3344e8ede17 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 16:24:31 -0400 Subject: Use Linden wstring-to-string conversion, not boost::filesystem's. On Windows, calling boost::filesystem::path::string() implicitly requests code conversion between std::wstring (the boost::filesystem::path::string_type selected on Windows) and std::string. At least for integration-test program, that produces link errors. Use Linden's wstring_to_utf8str() instead. --- indra/llcommon/tests/llsdserialize_test.cpp | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index e0a7835550..93261fa306 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -54,6 +54,7 @@ typedef U32 uint32_t; #include "../test/lltut.h" #include "stringize.h" +#include "llstring.h" std::vector string_to_vector(const std::string& str) { @@ -81,6 +82,28 @@ boost::filesystem::path temp_directory_path() #endif // LL_DARWIN, LL_LINUX } +// We want a std::string from a boost::filesystem::path::native() call. While +// there is a boost::filesystem::path::string() call as well, invoking that +// (at least in this test-program context) produces unresolved externals for +// boost::filesystem::path conversion machinery even though we can resolve +// other boost::filesystem symbols. Possibly those conversion routines aren't +// being built for Linden's Boost package. But that's okay, llstring.h +// provides conversion machinery we can use instead. +// On Posix platforms, boost::filesystem::path::native() returns std::string. +inline +std::string native_to_string(const std::string& in) +{ + return in; +} + +// On Windows, though, boost::filesystem::path::native() returns std::wstring. +// Make sure the right conversion happens. +inline +std::string native_to_string(const std::wstring& in) +{ + return wstring_to_utf8str(in); +} + // Create a Python script file with specified content "somewhere in the // filesystem," cleaning up when it goes out of scope. class NamedTempScript @@ -99,7 +122,7 @@ public: boost::filesystem::remove(mPath); } - std::string getName() const { return mPath.string(); } + std::string getName() const { return native_to_string(mPath.native()); } private: boost::filesystem::path mPath; -- cgit v1.2.3 From 8ca0f872f2f3cd026788c3ea28c3a00f5d407033 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 17:12:02 -0400 Subject: wstring_to_utf8str() accepts LLWString rather than std::wstring. --- indra/llcommon/tests/llsdserialize_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 93261fa306..e61e6b9460 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -101,7 +101,8 @@ std::string native_to_string(const std::string& in) inline std::string native_to_string(const std::wstring& in) { - return wstring_to_utf8str(in); + // So actually, wstring_to_utf8str() accepts LLWString rather than std::wstring... + return wstring_to_utf8str(LLWString(in.begin(), in.end())); } // Create a Python script file with specified content "somewhere in the -- cgit v1.2.3 From 5f37ec3c712221765bbb42e3428975e9b1402c9c Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 19:07:13 -0400 Subject: Avoid Boost.Filesystem: Boost package improperly built on Windows? Seems Linden's Boost package and the viewer build might use different settings of the /Zc:wchar_t switch. Anyway, this implementation using open(O_CREAT | O_EXCL) should be more robust. I'm surprised Boost.Filesystem doesn't seem to offer "create a unique file"; all I found was "generate a random filename fairly likely to be unique." --- indra/llcommon/tests/llsdserialize_test.cpp | 112 +++++++++++++++++++--------- 1 file changed, 77 insertions(+), 35 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index e61e6b9460..ec0cacfe90 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -33,18 +33,34 @@ typedef U32 uint32_t; #include #else +#include #include #include +#include #include +#include #include "llprocesslauncher.h" #endif +/*==========================================================================*| +// Whoops, seems Linden's Boost package and the viewer are built with +// different settings of VC's /Zc:wchar_t switch! Using Boost.Filesystem +// pathname operations produces Windows link errors: +// unresolved external symbol "private: static class std::codecvt const * & __cdecl boost::filesystem3::path::wchar_t_codecvt_facet()" +// unresolved external symbol "void __cdecl boost::filesystem3::path_traits::convert()" +// See: +// http://boost.2283326.n4.nabble.com/filesystem-v3-unicode-and-std-codecvt-linker-error-td3455549.html +// which points to: +// http://msdn.microsoft.com/en-us/library/dh8che7s%28v=VS.100%29.aspx + // As we're not trying to preserve compatibility with old Boost.Filesystem // code, but rather writing brand-new code, use the newest available // Filesystem API. #define BOOST_FILESYSTEM_VERSION 3 #include "boost/filesystem.hpp" #include "boost/filesystem/v3/fstream.hpp" +|*==========================================================================*/ #include "boost/range.hpp" #include "boost/foreach.hpp" @@ -54,7 +70,6 @@ typedef U32 uint32_t; #include "../test/lltut.h" #include "stringize.h" -#include "llstring.h" std::vector string_to_vector(const std::string& str) { @@ -62,13 +77,12 @@ std::vector string_to_vector(const std::string& str) } // boost::filesystem::temp_directory_path() isn't yet in Boost 1.45! :-( -// Switch to that one as soon as we update to a Boost that contains it. -boost::filesystem::path temp_directory_path() +std::string temp_directory_path() { #if LL_WINDOWS char buffer[4096]; GetTempPathA(sizeof(buffer), buffer); - return boost::filesystem::path(buffer); + return buffer; #else // LL_DARWIN, LL_LINUX static const char* vars[] = { "TMPDIR", "TMP", "TEMP", "TEMPDIR" }; @@ -76,34 +90,28 @@ boost::filesystem::path temp_directory_path() { const char* found = getenv(var); if (found) - return boost::filesystem::path(found); + return found; } - return boost::filesystem::path("/tmp"); + return "/tmp"; #endif // LL_DARWIN, LL_LINUX } -// We want a std::string from a boost::filesystem::path::native() call. While -// there is a boost::filesystem::path::string() call as well, invoking that -// (at least in this test-program context) produces unresolved externals for -// boost::filesystem::path conversion machinery even though we can resolve -// other boost::filesystem symbols. Possibly those conversion routines aren't -// being built for Linden's Boost package. But that's okay, llstring.h -// provides conversion machinery we can use instead. -// On Posix platforms, boost::filesystem::path::native() returns std::string. -inline -std::string native_to_string(const std::string& in) -{ - return in; -} - -// On Windows, though, boost::filesystem::path::native() returns std::wstring. -// Make sure the right conversion happens. -inline -std::string native_to_string(const std::wstring& in) -{ - // So actually, wstring_to_utf8str() accepts LLWString rather than std::wstring... - return wstring_to_utf8str(LLWString(in.begin(), in.end())); -} +// Windows presents a kinda sorta compatibility layer. Code to the yucky +// Windows names because they're less likely than the Posix names to collide +// with any other names in this source. +#if LL_WINDOWS +#define _remove DeleteFile +#else // ! LL_WINDOWS +#define _open open +#define _write write +#define _close close +#define _remove remove +#define _O_WRONLY O_WRONLY +#define _O_CREAT O_CREAT +#define _O_EXCL O_EXCL +#define _S_IWRITE S_IWUSR +#define _S_IREAD S_IRUSR +#endif // ! LL_WINDOWS // Create a Python script file with specified content "somewhere in the // filesystem," cleaning up when it goes out of scope. @@ -111,22 +119,56 @@ class NamedTempScript { public: NamedTempScript(const std::string& content): - mPath(/*boost::filesystem*/::temp_directory_path() / - boost::filesystem::unique_path("%%%%-%%%%-%%%%-%%%%.py")) + mPath(temp_directory_path()) { - boost::filesystem::ofstream file(mPath); - file << content << '\n'; + // Make sure mPath ends with a directory separator, if it doesn't already. + if (mPath.empty() || + ! (mPath[mPath.length() - 1] == '\\' || mPath[mPath.length() - 1] == '/')) + { + mPath.append("/"); + } + + // Open a file with a unique name in the mPath directory. + int fd(-1); + for (int i(0);; ++i) + { + // Append an integer name to mPath. It need not be zero-filled, + // but I think it's neater that way. + std::string testname(STRINGIZE(mPath + << std::setw(8) << std::setfill('0') << i + << ".py")); + // The key to this whole loop is the _O_CREAT | _O_EXCL bitmask, + // which requests an error if the file already exists. A proper + // implementation will check atomically, ensuring that racing + // processes will end up with two different filenames. + fd = _open(testname.c_str(), + _O_WRONLY | _O_CREAT | _O_EXCL, + _S_IREAD | _S_IWRITE); + if (fd != -1) // managed to open the file + { + mPath = testname; // remember its actual name + break; + } + // it's a problem if the open() failed for any other reason but + // the existence of a file by the same name + assert(errno == EEXIST); + // loop back to try another filename + } + // File is open, its name is in mPath: write it and close it. + _write(fd, content.c_str(), content.length()); + _write(fd, "\n", 1); + _close(fd); } ~NamedTempScript() { - boost::filesystem::remove(mPath); + _remove(mPath.c_str()); } - std::string getName() const { return native_to_string(mPath.native()); } + std::string getName() const { return mPath; } private: - boost::filesystem::path mPath; + std::string mPath; }; namespace tut -- cgit v1.2.3 From 9f66409b88481ca4ded5b9bb9d81e5977a43a5af Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 19:39:32 -0400 Subject: #include correct headers for Windows _open() et al. Also mollify Linux build, which gets alarmed when you implicitly ignore write()'s return value. Ignore it explicitly. --- indra/llcommon/tests/llsdserialize_test.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index ec0cacfe90..025870c915 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -32,16 +32,18 @@ #include typedef U32 uint32_t; #include +#include #else #include #include #include -#include #include -#include #include "llprocesslauncher.h" #endif +#include +#include + /*==========================================================================*| // Whoops, seems Linden's Boost package and the viewer are built with // different settings of VC's /Zc:wchar_t switch! Using Boost.Filesystem @@ -100,7 +102,7 @@ std::string temp_directory_path() // Windows names because they're less likely than the Posix names to collide // with any other names in this source. #if LL_WINDOWS -#define _remove DeleteFile +#define _remove DeleteFileA #else // ! LL_WINDOWS #define _open open #define _write write @@ -155,8 +157,8 @@ public: // loop back to try another filename } // File is open, its name is in mPath: write it and close it. - _write(fd, content.c_str(), content.length()); - _write(fd, "\n", 1); + (void)_write(fd, content.c_str(), content.length()); + (void)_write(fd, "\n", 1); _close(fd); } -- cgit v1.2.3 From 1f58cd688f44fed6da91af5cac0d48166c2647d0 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 14 Jul 2011 20:20:35 -0400 Subject: Pacify Linux gcc more thoroughly. --- indra/llcommon/tests/llsdserialize_test.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 025870c915..41d2fcc696 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -157,8 +157,12 @@ public: // loop back to try another filename } // File is open, its name is in mPath: write it and close it. - (void)_write(fd, content.c_str(), content.length()); - (void)_write(fd, "\n", 1); + // Truthfully, we'd just as soon ignore the return value from + // _write(), but Linux gcc generates fatal warnings if we do. + bool ok(true); + ok = ok && (content.length() == _write(fd, content.c_str(), content.length())); + ok = ok && (1 == _write(fd, "\n", 1)); + assert(ok); _close(fd); } -- cgit v1.2.3 From e3b5d9fc5c638beff4eed25a366dc5cc1c0478b1 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 10:48:46 -0400 Subject: Change NamedTempScript to NamedTempFile; allow streaming to it. The only thing about NamedTempScript that was specific to script files was the hardcoded ".py" extension. Renaming it to NamedTempFile with an explicit extension argument addresses that. Allow constructing NamedTempFile with either a std::string, as before, or an expression of the form (lambda::_1 << some << stuff). If Linden's Boost package included the Boost.Iostreams lib, we could even stream such an expression directly to an ostream constructed around the fd. But oh well. --- indra/llcommon/tests/llsdserialize_test.cpp | 102 ++++++++++++++++++++-------- 1 file changed, 75 insertions(+), 27 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 41d2fcc696..8b59e99b24 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -43,6 +43,7 @@ typedef U32 uint32_t; #include #include +#include /*==========================================================================*| // Whoops, seems Linden's Boost package and the viewer are built with @@ -65,6 +66,14 @@ typedef U32 uint32_t; |*==========================================================================*/ #include "boost/range.hpp" #include "boost/foreach.hpp" +#include "boost/function.hpp" +#include "boost/lambda/lambda.hpp" +namespace lambda = boost::lambda; +/*==========================================================================*| +// Aaaarrgh, Linden's Boost package doesn't even include Boost.Iostreams! +#include "boost/iostreams/stream.hpp" +#include "boost/iostreams/device/file_descriptor.hpp" +|*==========================================================================*/ #include "../llsd.h" #include "../llsdserialize.h" @@ -115,13 +124,37 @@ std::string temp_directory_path() #define _S_IREAD S_IRUSR #endif // ! LL_WINDOWS -// Create a Python script file with specified content "somewhere in the +// Create a text file with specified content "somewhere in the // filesystem," cleaning up when it goes out of scope. -class NamedTempScript +class NamedTempFile { public: - NamedTempScript(const std::string& content): + // Function that accepts an ostream ref and (presumably) writes stuff to + // it, e.g.: + // (lambda::_1 << "the value is " << 17 << '\n') + typedef boost::function Streamer; + + NamedTempFile(const std::string& ext, const std::string& content): + mPath(temp_directory_path()) + { + createFile(ext, lambda::_1 << content); + } + + NamedTempFile(const std::string& ext, const Streamer& func): mPath(temp_directory_path()) + { + createFile(ext, func); + } + + ~NamedTempFile() + { + _remove(mPath.c_str()); + } + + std::string getName() const { return mPath; } + +private: + void createFile(const std::string& ext, const Streamer& func) { // Make sure mPath ends with a directory separator, if it doesn't already. if (mPath.empty() || @@ -138,11 +171,11 @@ public: // but I think it's neater that way. std::string testname(STRINGIZE(mPath << std::setw(8) << std::setfill('0') << i - << ".py")); + << ext)); // The key to this whole loop is the _O_CREAT | _O_EXCL bitmask, - // which requests an error if the file already exists. A proper - // implementation will check atomically, ensuring that racing - // processes will end up with two different filenames. + // which requests error EEXIST if the file already exists. A + // proper implementation will check atomically, ensuring that + // racing processes will end up with two different filenames. fd = _open(testname.c_str(), _O_WRONLY | _O_CREAT | _O_EXCL, _S_IREAD | _S_IWRITE); @@ -151,29 +184,40 @@ public: mPath = testname; // remember its actual name break; } - // it's a problem if the open() failed for any other reason but - // the existence of a file by the same name - assert(errno == EEXIST); + // This loop is specifically coded to handle EEXIST. Any other + // error is a problem. + llassert_always(errno == EEXIST); // loop back to try another filename } - // File is open, its name is in mPath: write it and close it. - // Truthfully, we'd just as soon ignore the return value from - // _write(), but Linux gcc generates fatal warnings if we do. - bool ok(true); - ok = ok && (content.length() == _write(fd, content.c_str(), content.length())); - ok = ok && (1 == _write(fd, "\n", 1)); - assert(ok); - _close(fd); + // fd is open, its name is in mPath: write it and close it. + +/*==========================================================================*| + // Define an ostream on the open fd. Tell it to close fd on destruction. + boost::iostreams::stream + out(fd, boost::iostreams::close_handle); +|*==========================================================================*/ + std::ostringstream out; + // Stream stuff to it. + func(out); + // toss in a final newline for good measure + out << '\n'; + + std::string data(out.str()); + int written(_write(fd, data.c_str(), data.length())); + int closed(_close(fd)); + llassert_always(written == data.length() && closed == 0); } - ~NamedTempScript() + void peep() { - _remove(mPath.c_str()); + std::cout << "File '" << mPath << "' contains:\n"; + std::ifstream reader(mPath.c_str()); + std::string line; + while (std::getline(reader, line)) + std::cout << line << '\n'; + std::cout << "---\n"; } - std::string getName() const { return mPath; } - -private: std::string mPath; }; @@ -1628,7 +1672,7 @@ namespace tut const char* PYTHON(getenv("PYTHON")); ensure("Set $PYTHON to the Python interpreter", PYTHON); - NamedTempScript scriptfile(script); + NamedTempFile scriptfile(".py", script); #if LL_WINDOWS std::string q("\""); @@ -1690,14 +1734,18 @@ namespace tut template<> template<> void TestPythonCompatibleObject::test<1>() { - python("hello", "print 'Hello, world!'"); + set_test_name("verify python()"); + python("hello", + "import sys\n" + "sys.exit(0)"); } template<> template<> void TestPythonCompatibleObject::test<2>() { + set_test_name("verify NamedTempFile"); python("platform", -"import sys\n" -"print 'Running on', sys.platform"); + "import sys\n" + "print 'Running on', sys.platform"); } } -- cgit v1.2.3 From c33cf379f25e9a1a3780a73805749616fa07de66 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 11:53:05 -0400 Subject: Add test to verify C++-to-Python LLSD notation sequence. Write a sequence of LLSDSerialize::toNotation() calls separated by newlines to a data file, then read lines and parse using llbase.llsd.parse(). Verify that this produces expected data even when one item is a string containing newlines. Generalize python() helper function to allow using any of the NamedTempFile constructor forms. Allow specifying expected Python rc (default 0) and use this to verify an intentional sys.exit(17). This is better than previous sys.exit(0) test because when, at one point, NamedTempFile failed to write file data, running Python on an empty script file still terminates with rc 0. A nonzero rc verifies that we've written the file, that Python is running it and that we're retrieving its rc. --- indra/llcommon/tests/llsdserialize_test.cpp | 65 +++++++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 4 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 8b59e99b24..aaf3740b07 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -68,6 +68,7 @@ typedef U32 uint32_t; #include "boost/foreach.hpp" #include "boost/function.hpp" #include "boost/lambda/lambda.hpp" +#include "boost/lambda/bind.hpp" namespace lambda = boost::lambda; /*==========================================================================*| // Aaaarrgh, Linden's Boost package doesn't even include Boost.Iostreams! @@ -77,6 +78,7 @@ namespace lambda = boost::lambda; #include "../llsd.h" #include "../llsdserialize.h" +#include "llsdutil.h" #include "../llformat.h" #include "../test/lltut.h" @@ -140,6 +142,13 @@ public: createFile(ext, lambda::_1 << content); } + // Disambiguate when passing string literal + NamedTempFile(const std::string& ext, const char* content): + mPath(temp_directory_path()) + { + createFile(ext, lambda::_1 << content); + } + NamedTempFile(const std::string& ext, const Streamer& func): mPath(temp_directory_path()) { @@ -1667,7 +1676,8 @@ namespace tut TestPythonCompatible() {} ~TestPythonCompatible() {} - void python(const std::string& desc, const std::string& script /*, F32 timeout=5 */) + template + void python(const std::string& desc, const CONTENT& script, int expect=0) { const char* PYTHON(getenv("PYTHON")); ensure("Set $PYTHON to the Python interpreter", PYTHON); @@ -1687,7 +1697,7 @@ namespace tut } else { - ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); + ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, expect); } #else // LL_DARWIN, LL_LINUX @@ -1710,7 +1720,8 @@ namespace tut if (WIFEXITED(status)) { int rc(WEXITSTATUS(status)); - ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), rc, 0); + ensure_equals(STRINGIZE(desc << " script terminated with rc " << rc), + rc, expect); } else if (WIFSIGNALED(status)) { @@ -1737,7 +1748,8 @@ namespace tut set_test_name("verify python()"); python("hello", "import sys\n" - "sys.exit(0)"); + "sys.exit(17)", + 17); // expect nonzero rc } template<> template<> @@ -1748,4 +1760,49 @@ namespace tut "import sys\n" "print 'Running on', sys.platform"); } + + template<> template<> + void TestPythonCompatibleObject::test<3>() + { + set_test_name("verify sequence to Python"); + + LLSD cdata(LLSDArray(17)(3.14) + ("This string\n" + "has several\n" + "lines.")); + + const char pydata[] = + "def verify(iterable):\n" + " it = iter(iterable)\n" + " assert it.next() == 17\n" + " assert abs(it.next() - 3.14) < 0.01\n" + " assert it.next() == '''\\\n" + "This string\n" + "has several\n" + "lines.'''\n" + " try:\n" + " it.next()\n" + " except StopIteration:\n" + " pass\n" + " else:\n" + " assert False, 'Too many data items'\n"; + + // Create a something.llsd file containing 'data' serialized to notation. + // Avoid final newline because NamedTempFile implicitly adds one. + NamedTempFile file(".llsd", + (lambda::bind(LLSDSerialize::toNotation, cdata[0], lambda::_1), + lambda::_1 << '\n', + lambda::bind(LLSDSerialize::toNotation, cdata[1], lambda::_1), + lambda::_1 << '\n', + lambda::bind(LLSDSerialize::toNotation, cdata[2], lambda::_1))); + + python("read C++ notation", + lambda::_1 << + "from llbase import llsd\n" + "def parse_each(iterable):\n" + " for item in iterable:\n" + " yield llsd.parse(item)\n" << + pydata << + "verify(parse_each(open('" << file.getName() << "')))\n"); + } } -- cgit v1.2.3 From 7341e01ce2c833a190e6361bd97cf64bc1947efc Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 12:42:49 -0400 Subject: Add test to verify Python-to-C++ LLSD notation sequence. Verify that an LLSD::String containing newlines works; verify that newlines between items are accepted. --- indra/llcommon/tests/llsdserialize_test.cpp | 60 ++++++++++++++++++++++++++++- 1 file changed, 58 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index aaf3740b07..0b9f1b53d2 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1787,8 +1787,12 @@ namespace tut " else:\n" " assert False, 'Too many data items'\n"; - // Create a something.llsd file containing 'data' serialized to notation. - // Avoid final newline because NamedTempFile implicitly adds one. + // Create a something.llsd file containing 'data' serialized to + // notation. It's important to separate with newlines because Python's + // llsd module doesn't support parsing from a file stream, only from a + // string, so we have to know how much of the file to read into a + // string. Avoid final newline because NamedTempFile implicitly adds + // one. NamedTempFile file(".llsd", (lambda::bind(LLSDSerialize::toNotation, cdata[0], lambda::_1), lambda::_1 << '\n', @@ -1805,4 +1809,56 @@ namespace tut pydata << "verify(parse_each(open('" << file.getName() << "')))\n"); } + + template<> template<> + void TestPythonCompatibleObject::test<4>() + { + set_test_name("verify sequence from Python"); + + // Create an empty data file. This is just a placeholder for our + // script to write into. Create it to establish a unique name that + // we know. + NamedTempFile file(".llsd", ""); + + python("write Python notation", + lambda::_1 << + "from __future__ import with_statement\n" + "from llbase import llsd\n" + "DATA = [\n" + " 17,\n" + " 3.14,\n" + " '''\\\n" + "This string\n" + "has several\n" + "lines.''',\n" + "]\n" + // N.B. Using 'print' implicitly adds newlines. + "with open('" << file.getName() << "', 'w') as f:\n" + " for item in DATA:\n" + " print >>f, llsd.format_notation(item)\n"); + + std::ifstream inf(file.getName().c_str()); + LLSD item; + // Notice that we're not doing anything special to parse out the + // newlines: LLSDSerialize::fromNotation ignores them. While it would + // seem they're not strictly necessary, going in this direction, we + // want to ensure that notation-separated-by-newlines works in both + // directions -- since in practice, a given file might be read by + // either language. + ensure_equals("Failed to read LLSD::Integer from Python", + LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), + 1); + ensure_equals(item.asInteger(), 17); + ensure_equals("Failed to read LLSD::Real from Python", + LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), + 1); + ensure_approximately_equals(item.asReal(), 3.14, 7); // 7 bits ~= 0.01 + ensure_equals("Failed to read LLSD::String from Python", + LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), + 1); + ensure_equals(item.asString(), + "This string\n" + "has several\n" + "lines."); + } } -- cgit v1.2.3 From 4b21954729163069e9d8f78c22624a2ecbc17b38 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 14:02:45 -0400 Subject: Muzzle VS warning --- indra/llcommon/tests/llsdserialize_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 0b9f1b53d2..e6a0deaa8b 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1852,7 +1852,7 @@ namespace tut ensure_equals("Failed to read LLSD::Real from Python", LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), 1); - ensure_approximately_equals(item.asReal(), 3.14, 7); // 7 bits ~= 0.01 + ensure_approximately_equals(F32(item.asReal()), 3.14, 7); // 7 bits ~= 0.01 ensure_equals("Failed to read LLSD::String from Python", LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), 1); -- cgit v1.2.3 From fee07bb597a64489b8e4bca8513ebd2afd9e7b6e Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 14:24:37 -0400 Subject: Try again to pacify VS fatal warning. --- indra/llcommon/tests/llsdserialize_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index e6a0deaa8b..b0c0df192c 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1852,7 +1852,8 @@ namespace tut ensure_equals("Failed to read LLSD::Real from Python", LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), 1); - ensure_approximately_equals(F32(item.asReal()), 3.14, 7); // 7 bits ~= 0.01 + ensure_approximately_equals("Bad LLSD::Real value from Python", + item.asReal(), 3.14, 7); // 7 bits ~= 0.01 ensure_equals("Failed to read LLSD::String from Python", LLSDSerialize::fromNotation(item, inf, LLSDSerialize::SIZE_UNLIMITED), 1); -- cgit v1.2.3 From e41c4c90f0d8c935fa8e4de6a8439d00283c3206 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 16:01:43 -0400 Subject: Not all TC agents have llbase.llsd, fall back to indra.base.llsd --- indra/llcommon/tests/llsdserialize_test.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index b0c0df192c..30cc2bbc8a 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1802,7 +1802,10 @@ namespace tut python("read C++ notation", lambda::_1 << - "from llbase import llsd\n" + "try:\n" + " from llbase import llsd\n" + "except ImportError:\n" + " from indra.base import llsd\n" "def parse_each(iterable):\n" " for item in iterable:\n" " yield llsd.parse(item)\n" << @@ -1823,7 +1826,10 @@ namespace tut python("write Python notation", lambda::_1 << "from __future__ import with_statement\n" - "from llbase import llsd\n" + "try:\n" + " from llbase import llsd\n" + "except ImportError:\n" + " from indra.base import llsd\n" "DATA = [\n" " 17,\n" " 3.14,\n" -- cgit v1.2.3 From 15c36ee9b39624a29303b6e0cf434c9758657ded Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 17:20:27 -0400 Subject: If we're going to need indra.base.llsd, have to munge sys.path. And at that point, the Python logic needed to bring in the llsd module is big enough to warrant capturing it in a separate string variable common to multiple tests. --- indra/llcommon/tests/llsdserialize_test.cpp | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 30cc2bbc8a..a54d861680 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1673,9 +1673,21 @@ namespace tut struct TestPythonCompatible { - TestPythonCompatible() {} + TestPythonCompatible(): + import_llsd("import os.path\n" + "import sys\n" + "sys.path.insert(0,\n" + " os.path.join(os.path.dirname(__file__),\n" + " os.pardir, os.pardir, 'lib', 'python'))\n" + "try:\n" + " from llbase import llsd\n" + "except ImportError:\n" + " from indra.base import llsd\n") + {} ~TestPythonCompatible() {} + std::string import_llsd; + template void python(const std::string& desc, const CONTENT& script, int expect=0) { @@ -1802,10 +1814,7 @@ namespace tut python("read C++ notation", lambda::_1 << - "try:\n" - " from llbase import llsd\n" - "except ImportError:\n" - " from indra.base import llsd\n" + import_llsd << "def parse_each(iterable):\n" " for item in iterable:\n" " yield llsd.parse(item)\n" << @@ -1825,11 +1834,8 @@ namespace tut python("write Python notation", lambda::_1 << - "from __future__ import with_statement\n" - "try:\n" - " from llbase import llsd\n" - "except ImportError:\n" - " from indra.base import llsd\n" + "from __future__ import with_statement\n" << + import_llsd << "DATA = [\n" " 17,\n" " 3.14,\n" -- cgit v1.2.3 From 2b509383ccb22a1a4258e1d56710cbb998d6c6af Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Fri, 15 Jul 2011 22:32:06 -0400 Subject: Use C++ __FILE__ rather than Python __file__ to find indra work area. In this case, the Python code in question is being written from a C++ string literal to a temp script file in a platform-dependent temp directory -- so the Python __file__ value tells you nothing about the location of the repository checkout. Embedding __FILE__ from the containing C++ source file works better. --- indra/llcommon/tests/llsdserialize_test.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index a54d861680..c65a1d3ca0 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1674,10 +1674,16 @@ namespace tut struct TestPythonCompatible { TestPythonCompatible(): + // Note the peculiar insertion of __FILE__ into this string. + // Normally I like to make a Python script navigate relative to + // its own placement in the repo directory tree (__file__) -- but + // in this case, the script is being written into a platform- + // dependent temp directory! So locate indra/lib/python relative + // to this C++ source file rather than the Python module. import_llsd("import os.path\n" "import sys\n" "sys.path.insert(0,\n" - " os.path.join(os.path.dirname(__file__),\n" + " os.path.join(os.path.dirname('" __FILE__ "'),\n" " os.pardir, os.pardir, 'lib', 'python'))\n" "try:\n" " from llbase import llsd\n" -- cgit v1.2.3 From 81dc4401288f0a3cb95ce53d4ede79daa0f0f3d0 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Sat, 16 Jul 2011 10:20:41 -0400 Subject: Use raw-string syntax for Python string containing Windows pathname. Consider this pathname for llsdserialize_test.cpp: C:\nats\indra\llcommon\tests\llsdserialize_test.cpp Embed that in a Python string literal: 'C:\nats\indra\llcommon\tests\llsdserialize_test.cpp' and you get a string containing: C: ats\indra\llcommon ests\llsdserialize_test.cpp where the \n became a newline and the \t became a tab character. Hopefully Python raw-string syntax r'C:\etc\etc' works better. --- indra/llcommon/tests/llsdserialize_test.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index c65a1d3ca0..81de64930f 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1680,10 +1680,12 @@ namespace tut // in this case, the script is being written into a platform- // dependent temp directory! So locate indra/lib/python relative // to this C++ source file rather than the Python module. + // Use Python raw-string syntax so Windows pathname backslashes + // won't mislead Python's string scanner. import_llsd("import os.path\n" "import sys\n" "sys.path.insert(0,\n" - " os.path.join(os.path.dirname('" __FILE__ "'),\n" + " os.path.join(os.path.dirname(r'" __FILE__ "'),\n" " os.pardir, os.pardir, 'lib', 'python'))\n" "try:\n" " from llbase import llsd\n" -- cgit v1.2.3 From 790032d2316989eb5b36af2569408ce1e1296015 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Sat, 16 Jul 2011 22:24:31 -0400 Subject: Use raw-string syntax for other Windows pathnames inserted to Python. --- indra/llcommon/tests/llsdserialize_test.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 81de64930f..7ce7ada29e 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -1827,7 +1827,8 @@ namespace tut " for item in iterable:\n" " yield llsd.parse(item)\n" << pydata << - "verify(parse_each(open('" << file.getName() << "')))\n"); + // Don't forget raw-string syntax for Windows pathnames. + "verify(parse_each(open(r'" << file.getName() << "')))\n"); } template<> template<> @@ -1852,8 +1853,9 @@ namespace tut "has several\n" "lines.''',\n" "]\n" + // Don't forget raw-string syntax for Windows pathnames. // N.B. Using 'print' implicitly adds newlines. - "with open('" << file.getName() << "', 'w') as f:\n" + "with open(r'" << file.getName() << "', 'w') as f:\n" " for item in DATA:\n" " print >>f, llsd.format_notation(item)\n"); -- cgit v1.2.3 From 9077f7722b3ab2b6dda7e5c13cee3fd59d7dbf53 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Sun, 17 Jul 2011 09:51:29 -0400 Subject: Decided against using Boost.Filesystem, remove from link --- indra/llcommon/CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index 09a05689f4..c755020a64 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -317,8 +317,7 @@ if (LL_TESTS) LL_ADD_INTEGRATION_TEST(lllazy "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llprocessor "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llrand "" "${test_libs}") - LL_ADD_INTEGRATION_TEST(llsdserialize "" - "${test_libs};${BOOST_FILESYSTEM_LIBRARY};${BOOST_SYSTEM_LIBRARY}" + LL_ADD_INTEGRATION_TEST(llsdserialize "" "${test_libs}" "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/setpython.py") LL_ADD_INTEGRATION_TEST(llstring "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lltreeiterators "" "${test_libs}") -- cgit v1.2.3 From 50d271a2ae28334b7dc1170d6222b3b4125fac6b Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Mon, 18 Jul 2011 08:31:32 -0400 Subject: increment viewer version to 2.8.2 --- indra/llcommon/llversionviewer.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h index 0018b8e844..6c1d233425 100644 --- a/indra/llcommon/llversionviewer.h +++ b/indra/llcommon/llversionviewer.h @@ -29,7 +29,7 @@ const S32 LL_VERSION_MAJOR = 2; const S32 LL_VERSION_MINOR = 8; -const S32 LL_VERSION_PATCH = 1; +const S32 LL_VERSION_PATCH = 2; const S32 LL_VERSION_BUILD = 0; const char * const LL_CHANNEL = "Second Life Developer"; -- cgit v1.2.3 From 677609b7224b2cd1e02e5866218f2e0d1fce57ba Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Tue, 19 Jul 2011 09:05:54 -0400 Subject: Per Josh's comments in http://codereview.lindenlab.com/6510035/ Instead of low-level open(O_CREAT | O_EXCL) loop on all platforms, use GetTempFileName() on Windows and mkstemp() elsewhere. Don't append a final newline to NamedTempFile: use caller's data literally. Tweak a couple comments. --- indra/llcommon/tests/llsdserialize_test.cpp | 179 +++++++++++++++++++++------- 1 file changed, 133 insertions(+), 46 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 7ce7ada29e..1fe3dc13c0 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -37,12 +37,12 @@ typedef U32 uint32_t; #include #include #include +#include +#include #include #include "llprocesslauncher.h" #endif -#include -#include #include /*==========================================================================*| @@ -89,6 +89,45 @@ std::vector string_to_vector(const std::string& str) return std::vector(str.begin(), str.end()); } +#if ! LL_WINDOWS +// We want to call strerror_r(), but alarmingly, there are two different +// variants. The one that returns int always populates the passed buffer +// (except in case of error), whereas the other one always returns a valid +// char* but might or might not populate the passed buffer. How do we know +// which one we're getting? Define adapters for each and let the compiler +// select the applicable adapter. + +// strerror_r() returns char* +std::string message_from(int /*orig_errno*/, const char* /*buffer*/, const char* strerror_ret) +{ + return strerror_ret; +} + +// strerror_r() returns int +std::string message_from(int orig_errno, const char* buffer, int strerror_ret) +{ + if (strerror_ret == 0) + { + return buffer; + } + // Here strerror_r() has set errno. Since strerror_r() has already failed, + // seems like a poor bet to call it again to diagnose its own error... + int stre_errno = errno; + if (stre_errno == ERANGE) + { + return STRINGIZE("strerror_r() can't explain errno " << orig_errno + << " (buffer too small)"); + } + if (stre_errno == EINVAL) + { + return STRINGIZE("unknown errno " << orig_errno); + } + // Here we don't even understand the errno from strerror_r()! + return STRINGIZE("strerror_r() can't explain errno " << orig_errno + << " (error " << stre_errno << ')'); +} +#endif // ! LL_WINDOWS + // boost::filesystem::temp_directory_path() isn't yet in Boost 1.45! :-( std::string temp_directory_path() { @@ -119,11 +158,6 @@ std::string temp_directory_path() #define _write write #define _close close #define _remove remove -#define _O_WRONLY O_WRONLY -#define _O_CREAT O_CREAT -#define _O_EXCL O_EXCL -#define _S_IWRITE S_IWUSR -#define _S_IREAD S_IRUSR #endif // ! LL_WINDOWS // Create a text file with specified content "somewhere in the @@ -165,6 +199,11 @@ public: private: void createFile(const std::string& ext, const Streamer& func) { + // Silly maybe, but use 'ext' as the name prefix. Strip off a leading + // '.' if present. + int pfx_offset = ((! ext.empty()) && ext[0] == '.')? 1 : 0; + +#if ! LL_WINDOWS // Make sure mPath ends with a directory separator, if it doesn't already. if (mPath.empty() || ! (mPath[mPath.length() - 1] == '\\' || mPath[mPath.length() - 1] == '/')) @@ -172,49 +211,92 @@ private: mPath.append("/"); } - // Open a file with a unique name in the mPath directory. - int fd(-1); - for (int i(0);; ++i) + // mkstemp() accepts and modifies a char* template string. Generate + // the template string, then copy to modifiable storage. + // mkstemp() requires its template string to end in six X's. + mPath += ext.substr(pfx_offset) + "XXXXXX"; + // Copy to vector + std::vector pathtemplate(mPath.begin(), mPath.end()); + // append a nul byte for classic-C semantics + pathtemplate.push_back('\0'); + // std::vector promises that a pointer to the 0th element is the same + // as a pointer to a contiguous classic-C array + int fd(mkstemp(&pathtemplate[0])); + if (fd == -1) { - // Append an integer name to mPath. It need not be zero-filled, - // but I think it's neater that way. - std::string testname(STRINGIZE(mPath - << std::setw(8) << std::setfill('0') << i - << ext)); - // The key to this whole loop is the _O_CREAT | _O_EXCL bitmask, - // which requests error EEXIST if the file already exists. A - // proper implementation will check atomically, ensuring that - // racing processes will end up with two different filenames. - fd = _open(testname.c_str(), - _O_WRONLY | _O_CREAT | _O_EXCL, - _S_IREAD | _S_IWRITE); - if (fd != -1) // managed to open the file + // The documented errno values (http://linux.die.net/man/3/mkstemp) + // are used in a somewhat unusual way, so provide context-specific + // errors. + if (errno == EEXIST) + { + LL_ERRS("NamedTempFile") << "mkstemp(\"" << mPath + << "\") could not create unique file " << LL_ENDL; + } + if (errno == EINVAL) { - mPath = testname; // remember its actual name - break; + LL_ERRS("NamedTempFile") << "bad mkstemp() file path template '" + << mPath << "'" << LL_ENDL; } - // This loop is specifically coded to handle EEXIST. Any other - // error is a problem. - llassert_always(errno == EEXIST); - // loop back to try another filename + // Shrug, something else + int mkst_errno = errno; + char buffer[256]; + LL_ERRS("NamedTempFile") << "mkstemp(\"" << mPath << "\") failed: " + << message_from(mkst_errno, buffer, + strerror_r(mkst_errno, buffer, sizeof(buffer))) + << LL_ENDL; } - // fd is open, its name is in mPath: write it and close it. + // mkstemp() seems to have worked! Capture the modified filename. + // Avoid the nul byte we appended. + mPath.assign(pathtemplate.begin(), (pathtemplate.end()-1)); /*==========================================================================*| // Define an ostream on the open fd. Tell it to close fd on destruction. boost::iostreams::stream out(fd, boost::iostreams::close_handle); |*==========================================================================*/ + + // Write desired content. std::ostringstream out; // Stream stuff to it. func(out); - // toss in a final newline for good measure - out << '\n'; std::string data(out.str()); int written(_write(fd, data.c_str(), data.length())); int closed(_close(fd)); llassert_always(written == data.length() && closed == 0); + +#else // LL_WINDOWS + // GetTempFileName() is documented to require a MAX_PATH buffer. + char tempname[MAX_PATH]; + // Use 'ext' as filename prefix, but skip leading '.' if any. + // The 0 param is very important: requests iterating until we get a + // unique name. + if (0 == GetTempFileNameA(mPath.c_str(), ext.c_str() + pfx_offset, 0, tempname)) + { + // I always have to look up this call... :-P + LPVOID msgptr; + FormatMessageA( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + LPTSTR(&lpMsgBuf), + 0, NULL ); + LL_ERRS("NamedTempFile") << "GetTempFileName(\"" << mPath << "\", \"" + << (ext.c_str() + pfx_offset) << "\") failed: " + << msgptr << LL_ENDL; + LocalFree(msgptr); + } + // GetTempFileName() appears to have worked! Capture the actual + // filename. + mPath = tempname; + // Open the file and stream content to it. Destructor will close. + std::ofstream out(tempname); + func(out); + +#endif // LL_WINDOWS } void peep() @@ -1674,14 +1756,13 @@ namespace tut struct TestPythonCompatible { TestPythonCompatible(): - // Note the peculiar insertion of __FILE__ into this string. - // Normally I like to make a Python script navigate relative to - // its own placement in the repo directory tree (__file__) -- but - // in this case, the script is being written into a platform- - // dependent temp directory! So locate indra/lib/python relative - // to this C++ source file rather than the Python module. - // Use Python raw-string syntax so Windows pathname backslashes - // won't mislead Python's string scanner. + // Note the peculiar insertion of __FILE__ into this string. Since + // this script is being written into a platform-dependent temp + // directory, we can't locate indra/lib/python relative to + // Python's __file__. Use __FILE__ instead, navigating relative + // to this C++ source file. Use Python raw-string syntax so + // Windows pathname backslashes won't mislead Python's string + // scanner. import_llsd("import os.path\n" "import sys\n" "sys.path.insert(0,\n" @@ -1708,7 +1789,7 @@ namespace tut std::string q("\""); std::string qPYTHON(q + PYTHON + q); std::string qscript(q + scriptfile.getName() + q); - int rc(_spawnl(_P_WAIT, PYTHON, qPYTHON.c_str(), qscript.c_str(), NULL)); + int rc = _spawnl(_P_WAIT, PYTHON, qPYTHON.c_str(), qscript.c_str(), NULL); if (rc == -1) { char buffer[256]; @@ -1768,7 +1849,7 @@ namespace tut set_test_name("verify python()"); python("hello", "import sys\n" - "sys.exit(17)", + "sys.exit(17)\n", 17); // expect nonzero rc } @@ -1778,7 +1859,7 @@ namespace tut set_test_name("verify NamedTempFile"); python("platform", "import sys\n" - "print 'Running on', sys.platform"); + "print 'Running on', sys.platform\n"); } template<> template<> @@ -1811,14 +1892,20 @@ namespace tut // notation. It's important to separate with newlines because Python's // llsd module doesn't support parsing from a file stream, only from a // string, so we have to know how much of the file to read into a - // string. Avoid final newline because NamedTempFile implicitly adds - // one. + // string. NamedTempFile file(".llsd", + // NamedTempFile's boost::function constructor + // takes a callable. To this callable it passes the + // std::ostream with which it's writing the + // NamedTempFile. This lambda-based expression + // first calls LLSD::Serialize() with that ostream, + // then streams a newline to it, etc. (lambda::bind(LLSDSerialize::toNotation, cdata[0], lambda::_1), lambda::_1 << '\n', lambda::bind(LLSDSerialize::toNotation, cdata[1], lambda::_1), lambda::_1 << '\n', - lambda::bind(LLSDSerialize::toNotation, cdata[2], lambda::_1))); + lambda::bind(LLSDSerialize::toNotation, cdata[2], lambda::_1), + lambda::_1 << '\n')); python("read C++ notation", lambda::_1 << -- cgit v1.2.3 From 5379467ccb2861d2dbcbc8a13f860d9448bd2fb0 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Tue, 19 Jul 2011 10:18:12 -0400 Subject: Fix copy/paste error in swiped FormatMessage() example code. --- indra/llcommon/tests/llsdserialize_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index 1fe3dc13c0..f2a7530f10 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -282,7 +282,7 @@ private: NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - LPTSTR(&lpMsgBuf), + LPTSTR(&msgptr), 0, NULL ); LL_ERRS("NamedTempFile") << "GetTempFileName(\"" << mPath << "\", \"" << (ext.c_str() + pfx_offset) << "\") failed: " -- cgit v1.2.3 From 25ababd7a6e7a1ab7222b760b7bcc8dde3e6b829 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Tue, 19 Jul 2011 10:40:02 -0400 Subject: More FormatMessage compile errors, try again to fix --- indra/llcommon/tests/llsdserialize_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp index f2a7530f10..72322c3b72 100644 --- a/indra/llcommon/tests/llsdserialize_test.cpp +++ b/indra/llcommon/tests/llsdserialize_test.cpp @@ -274,7 +274,7 @@ private: if (0 == GetTempFileNameA(mPath.c_str(), ext.c_str() + pfx_offset, 0, tempname)) { // I always have to look up this call... :-P - LPVOID msgptr; + LPSTR msgptr; FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | @@ -282,7 +282,7 @@ private: NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - LPTSTR(&msgptr), + LPSTR(&msgptr), // have to cast (char**) to (char*) 0, NULL ); LL_ERRS("NamedTempFile") << "GetTempFileName(\"" << mPath << "\", \"" << (ext.c_str() + pfx_offset) << "\") failed: " -- cgit v1.2.3 From 65d82fe192bdb4eb27766cf02eadaf78012f2817 Mon Sep 17 00:00:00 2001 From: Dave Parks Date: Thu, 21 Jul 2011 13:10:28 -0500 Subject: SH-2031 Fix for stall in "Cleanup" --- indra/llcommon/llfasttimer_class.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llfasttimer_class.cpp b/indra/llcommon/llfasttimer_class.cpp index bd594b06cf..675eda2fc5 100644 --- a/indra/llcommon/llfasttimer_class.cpp +++ b/indra/llcommon/llfasttimer_class.cpp @@ -228,6 +228,14 @@ void LLFastTimer::DeclareTimer::updateCachedPointers() // update cached pointer it->mFrameState = &it->mTimer.getFrameState(); } + + // also update frame states of timers on stack + LLFastTimer* cur_timerp = LLFastTimer::sCurTimerData.mCurTimer; + while(cur_timerp->mLastTimerData.mCurTimer != cur_timerp) + { + cur_timerp->mFrameState = &cur_timerp->mFrameState->mTimer->getFrameState(); + cur_timerp = cur_timerp->mLastTimerData.mCurTimer; + } } //static -- cgit v1.2.3 From e4a8ef4ce2572db98d08233c58e23d3ec75f30d7 Mon Sep 17 00:00:00 2001 From: Dave Parks Date: Fri, 22 Jul 2011 02:33:55 -0500 Subject: SH-2031 Cleanup from threaded curl implementation (remove errors/loops on shutdown). --- indra/llcommon/llthread.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llthread.cpp b/indra/llcommon/llthread.cpp index d9400fb5b3..4063cc730b 100644 --- a/indra/llcommon/llthread.cpp +++ b/indra/llcommon/llthread.cpp @@ -323,7 +323,8 @@ LLMutex::LLMutex(apr_pool_t *poolp) : LLMutex::~LLMutex() { #if MUTEX_DEBUG - llassert_always(!isLocked()); // better not be locked! + //bad assertion, the subclass LLSignal might be "locked", and that's OK + //llassert_always(!isLocked()); // better not be locked! #endif apr_thread_mutex_destroy(mAPRMutexp); mAPRMutexp = NULL; -- cgit v1.2.3 From 4c32fb04558fba6a5d467be63d6a070e9be6a29d Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Mon, 25 Jul 2011 10:58:48 -0400 Subject: increment viewer version to 2.8.3 --- indra/llcommon/llversionviewer.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h index 6c1d233425..f98a5398c3 100644 --- a/indra/llcommon/llversionviewer.h +++ b/indra/llcommon/llversionviewer.h @@ -29,7 +29,7 @@ const S32 LL_VERSION_MAJOR = 2; const S32 LL_VERSION_MINOR = 8; -const S32 LL_VERSION_PATCH = 2; +const S32 LL_VERSION_PATCH = 3; const S32 LL_VERSION_BUILD = 0; const char * const LL_CHANNEL = "Second Life Developer"; -- cgit v1.2.3 From 017a23aaf489dff7ab5832618d0d0b21996e5f0d Mon Sep 17 00:00:00 2001 From: Leslie Linden Date: Wed, 3 Aug 2011 17:07:49 -0700 Subject: SH-2218 WORK AROUND -- v2.8.x Viewers crash consistently when I actively use other applications * Just removed mac memory stats to make a low-risk work-around. --- indra/llcommon/llsys.cpp | 178 ----------------------------------------------- 1 file changed, 178 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llsys.cpp b/indra/llcommon/llsys.cpp index 99e61433c6..8807bf1bf8 100644 --- a/indra/llcommon/llsys.cpp +++ b/indra/llcommon/llsys.cpp @@ -1003,184 +1003,6 @@ LLSD LLMemoryInfo::loadStatsMap() LL_WARNS("LLMemoryInfo") << "Unable to collect hw.memsize memory information" << LL_ENDL; } - FILE* pout = popen("vm_stat 2>&1", "r"); - if (! pout) // popen() couldn't run vm_stat - { - // Save errno right away. - int popen_errno(errno); - LL_WARNS("LLMemoryInfo") << "Unable to collect vm_stat memory information: "; - char buffer[256]; - if (0 == strerror_r(popen_errno, buffer, sizeof(buffer))) - { - LL_CONT << buffer; - } - else - { - LL_CONT << "errno " << popen_errno; - } - LL_CONT << LL_ENDL; - } - else // popen() launched vm_stat - { - // Mach Virtual Memory Statistics: (page size of 4096 bytes) - // Pages free: 462078. - // Pages active: 142010. - // Pages inactive: 220007. - // Pages wired down: 159552. - // "Translation faults": 220825184. - // Pages copy-on-write: 2104153. - // Pages zero filled: 167034876. - // Pages reactivated: 65153. - // Pageins: 2097212. - // Pageouts: 41759. - // Object cache: 841598 hits of 7629869 lookups (11% hit rate) - - // Intentionally don't pass the boost::no_except flag. These - // boost::regex objects are constructed with string literals, so they - // should be valid every time. If they become invalid, we WANT an - // exception, hopefully even before the dev checks in. - boost::regex pagesize_rx("\\(page size of ([0-9]+) bytes\\)"); - boost::regex stat_rx("(.+): +([0-9]+)\\."); - boost::regex cache_rx("Object cache: ([0-9]+) hits of ([0-9]+) lookups " - "\\(([0-9]+)% hit rate\\)"); - boost::cmatch matched; - LLSD::Integer pagesizekb(4096/1024); - - // Here 'pout' is vm_stat's stdout. Search it for relevant data. - char line[100]; - line[sizeof(line)-1] = '\0'; - while (fgets(line, sizeof(line)-1, pout)) - { - size_t linelen(strlen(line)); - // Truncate any trailing newline - if (line[linelen - 1] == '\n') - { - line[--linelen] = '\0'; - } - LL_DEBUGS("LLMemoryInfo") << line << LL_ENDL; - if (regex_search_no_exc(line, matched, pagesize_rx)) - { - // "Mach Virtual Memory Statistics: (page size of 4096 bytes)" - std::string pagesize_str(matched[1].first, matched[1].second); - try - { - // Reasonable to assume that pagesize will always be a - // multiple of 1Kb? - pagesizekb = boost::lexical_cast(pagesize_str)/1024; - } - catch (const boost::bad_lexical_cast&) - { - LL_WARNS("LLMemoryInfo") << "couldn't parse '" << pagesize_str - << "' in vm_stat line: " << line << LL_ENDL; - continue; - } - stats.add("page size", pagesizekb); - } - else if (regex_match_no_exc(line, matched, stat_rx)) - { - // e.g. "Pages free: 462078." - // Strip double-quotes off certain statistic names - const char *key_begin(matched[1].first), *key_end(matched[1].second); - if (key_begin[0] == '"' && key_end[-1] == '"') - { - ++key_begin; - --key_end; - } - LLSD::String key(key_begin, key_end); - LLSD::String value_str(matched[2].first, matched[2].second); - LLSD::Integer value(0); - try - { - value = boost::lexical_cast(value_str); - } - catch (const boost::bad_lexical_cast&) - { - LL_WARNS("LLMemoryInfo") << "couldn't parse '" << value_str - << "' in vm_stat line: " << line << LL_ENDL; - continue; - } - // Store this statistic. - stats.add(key, value); - // Is this in units of pages? If so, convert to Kb. - static const LLSD::String pages("Pages "); - if (key.substr(0, pages.length()) == pages) - { - // Synthesize a new key with kb in place of Pages - LLSD::String kbkey("kb "); - kbkey.append(key.substr(pages.length())); - stats.add(kbkey, value * pagesizekb); - } - } - else if (regex_match_no_exc(line, matched, cache_rx)) - { - // e.g. "Object cache: 841598 hits of 7629869 lookups (11% hit rate)" - static const char* cache_keys[] = { "cache hits", "cache lookups", "cache hit%" }; - std::vector cache_values; - for (size_t i = 0; i < (sizeof(cache_keys)/sizeof(cache_keys[0])); ++i) - { - LLSD::String value_str(matched[i+1].first, matched[i+1].second); - LLSD::Integer value(0); - try - { - value = boost::lexical_cast(value_str); - } - catch (boost::bad_lexical_cast&) - { - LL_WARNS("LLMemoryInfo") << "couldn't parse '" << value_str - << "' in vm_stat line: " << line << LL_ENDL; - continue; - } - stats.add(cache_keys[i], value); - } - } - else - { - LL_WARNS("LLMemoryInfo") << "unrecognized vm_stat line: " << line << LL_ENDL; - } - } - int status(pclose(pout)); - if (status == -1) // pclose() couldn't retrieve rc - { - // Save errno right away. - int pclose_errno(errno); - // The ECHILD error happens so frequently that unless filtered, - // the warning below spams the log file. This is too bad, because - // sometimes the logic above fails to produce any output derived - // from vm_stat, but we've been unable to observe any specific - // error indicating the problem. - if (pclose_errno != ECHILD) - { - LL_WARNS("LLMemoryInfo") << "Unable to obtain vm_stat termination code: "; - char buffer[256]; - if (0 == strerror_r(pclose_errno, buffer, sizeof(buffer))) - { - LL_CONT << buffer; - } - else - { - LL_CONT << "errno " << pclose_errno; - } - LL_CONT << LL_ENDL; - } - } - else // pclose() retrieved rc; analyze - { - if (WIFEXITED(status)) - { - int rc(WEXITSTATUS(status)); - if (rc != 0) - { - LL_WARNS("LLMemoryInfo") << "vm_stat terminated with rc " << rc << LL_ENDL; - } - } - else if (WIFSIGNALED(status)) - { - LL_WARNS("LLMemoryInfo") << "vm_stat terminated by signal " << WTERMSIG(status) - << LL_ENDL; - } - } - } - #elif LL_SOLARIS U64 phys = 0; -- cgit v1.2.3