summaryrefslogtreecommitdiff
path: root/indra/test
diff options
context:
space:
mode:
authorAndrey Lihatskiy <alihatskiy@productengine.com>2023-10-25 21:28:26 +0300
committerAndrey Lihatskiy <alihatskiy@productengine.com>2023-10-25 21:28:26 +0300
commit4c6ae49c88f58d04ae89ffb444954e12f60e0d52 (patch)
treeacb8ab3be3052138ea2186d497b0991604ce068e /indra/test
parenta97d50548090f181f8156ab41a5e03b3e383c1c8 (diff)
parent2e8e96cfbcb383a667d1b938f364f0bbafcad5b4 (diff)
Merge branch 'main' into DRTVWR-587-maint-V
# Conflicts: # autobuild.xml # indra/llcommon/tests/llleap_test.cpp # indra/newview/viewer_manifest.py
Diffstat (limited to 'indra/test')
-rw-r--r--indra/test/hexdump.h97
-rw-r--r--indra/test/namedtempfile.h183
-rw-r--r--indra/test/test.cpp10
3 files changed, 182 insertions, 108 deletions
diff --git a/indra/test/hexdump.h b/indra/test/hexdump.h
new file mode 100644
index 0000000000..dd7cbaaa3c
--- /dev/null
+++ b/indra/test/hexdump.h
@@ -0,0 +1,97 @@
+/**
+ * @file hexdump.h
+ * @author Nat Goodspeed
+ * @date 2023-09-08
+ * @brief Provide hexdump() and hexmix() ostream formatters
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Copyright (c) 2023, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_HEXDUMP_H)
+#define LL_HEXDUMP_H
+
+#include <cctype>
+#include <iomanip>
+#include <iostream>
+#include <string_view>
+
+// Format a given byte string as 2-digit hex values, no separators
+// Usage: std::cout << hexdump(somestring) << ...
+class hexdump
+{
+public:
+ hexdump(const std::string_view& data):
+ hexdump(data.data(), data.length())
+ {}
+
+ hexdump(const char* data, size_t len):
+ hexdump(reinterpret_cast<const unsigned char*>(data), len)
+ {}
+
+ hexdump(const unsigned char* data, size_t len):
+ mData(data, data + len)
+ {}
+
+ friend std::ostream& operator<<(std::ostream& out, const hexdump& self)
+ {
+ auto oldfmt{ out.flags() };
+ auto oldfill{ out.fill() };
+ out.setf(std::ios_base::hex, std::ios_base::basefield);
+ out.fill('0');
+ for (auto c : self.mData)
+ {
+ out << std::setw(2) << unsigned(c);
+ }
+ out.setf(oldfmt, std::ios_base::basefield);
+ out.fill(oldfill);
+ return out;
+ }
+
+private:
+ std::vector<unsigned char> mData;
+};
+
+// Format a given byte string as a mix of printable characters and, for each
+// non-printable character, "\xnn"
+// Usage: std::cout << hexmix(somestring) << ...
+class hexmix
+{
+public:
+ hexmix(const std::string_view& data):
+ mData(data)
+ {}
+
+ hexmix(const char* data, size_t len):
+ mData(data, len)
+ {}
+
+ friend std::ostream& operator<<(std::ostream& out, const hexmix& self)
+ {
+ auto oldfmt{ out.flags() };
+ auto oldfill{ out.fill() };
+ out.setf(std::ios_base::hex, std::ios_base::basefield);
+ out.fill('0');
+ for (auto c : self.mData)
+ {
+ // std::isprint() must be passed an unsigned char!
+ if (std::isprint(static_cast<unsigned char>(c)))
+ {
+ out << c;
+ }
+ else
+ {
+ out << "\\x" << std::setw(2) << unsigned(c);
+ }
+ }
+ out.setf(oldfmt, std::ios_base::basefield);
+ out.fill(oldfill);
+ return out;
+ }
+
+private:
+ std::string mData;
+};
+
+#endif /* ! defined(LL_HEXDUMP_H) */
diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
index 7d59cad32c..ad14cebbd1 100644
--- a/indra/test/namedtempfile.h
+++ b/indra/test/namedtempfile.h
@@ -13,15 +13,16 @@
#define LL_NAMEDTEMPFILE_H
#include "llerror.h"
-#include "llapr.h"
-#include "apr_file_io.h"
+#include "llstring.h"
+#include "stringize.h"
#include <string>
-#include <boost/function.hpp>
-#include <boost/phoenix/core/argument.hpp>
-#include <boost/phoenix/operator/bitwise.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
#include <boost/noncopyable.hpp>
+#include <functional>
#include <iostream>
#include <sstream>
+#include <string_view>
/**
* Create a text file with specified content "somewhere in the
@@ -31,134 +32,123 @@ class NamedTempFile: public boost::noncopyable
{
LOG_CLASS(NamedTempFile);
public:
- NamedTempFile(const std::string& pfx, const std::string& content, apr_pool_t* pool=gAPRPoolp):
- mPool(pool)
+ NamedTempFile(const std::string_view& pfx,
+ const std::string_view& content,
+ const std::string_view& sfx=std::string_view(""))
{
- createFile(pfx, boost::phoenix::placeholders::arg1 << content);
+ createFile(pfx, [&content](std::ostream& out){ out << content; }, sfx);
}
- // Disambiguate when passing string literal
- NamedTempFile(const std::string& pfx, const char* content, apr_pool_t* pool=gAPRPoolp):
- mPool(pool)
+ // Disambiguate when passing string literal -- unclear why a string
+ // literal should be ambiguous wrt std::string_view and Streamer
+ NamedTempFile(const std::string_view& pfx,
+ const char* content,
+ const std::string_view& sfx=std::string_view(""))
{
- createFile(pfx, boost::phoenix::placeholders::arg1 << content);
+ createFile(pfx, [&content](std::ostream& out){ out << content; }, sfx);
}
// Function that accepts an ostream ref and (presumably) writes stuff to
// it, e.g.:
// (boost::phoenix::placeholders::arg1 << "the value is " << 17 << '\n')
- typedef boost::function<void(std::ostream&)> Streamer;
+ typedef std::function<void(std::ostream&)> Streamer;
- NamedTempFile(const std::string& pfx, const Streamer& func, apr_pool_t* pool=gAPRPoolp):
- mPool(pool)
+ NamedTempFile(const std::string_view& pfx,
+ const Streamer& func,
+ const std::string_view& sfx=std::string_view(""))
{
- createFile(pfx, func);
+ createFile(pfx, func, sfx);
}
virtual ~NamedTempFile()
{
- ll_apr_assert_status(apr_file_remove(mPath.c_str(), mPool));
+ boost::filesystem::remove(mPath);
}
- virtual std::string getName() const { return mPath; }
+ std::string getName() const { return mPath.string(); }
- void peep()
+ template <typename CALLABLE>
+ void peep_via(CALLABLE&& callable) const
{
- std::cout << "File '" << mPath << "' contains:\n";
- std::ifstream reader(mPath.c_str());
+ std::forward<CALLABLE>(callable)(stringize("File '", mPath, "' contains:"));
+ boost::filesystem::ifstream reader(mPath, std::ios::binary);
std::string line;
while (std::getline(reader, line))
- std::cout << line << '\n';
- std::cout << "---\n";
+ std::forward<CALLABLE>(callable)(line);
+ std::forward<CALLABLE>(callable)("---");
+ }
+
+ void peep_log() const
+ {
+ peep_via([](const std::string& line){ LL_DEBUGS() << line << LL_ENDL; });
+ }
+
+ void peep(std::ostream& out=std::cout) const
+ {
+ peep_via([&out](const std::string& line){ out << line << '\n'; });
+ }
+
+ friend std::ostream& operator<<(std::ostream& out, const NamedTempFile& self)
+ {
+ self.peep(out);
+ return out;
+ }
+
+ static boost::filesystem::path temp_path(const std::string_view& pfx="",
+ const std::string_view& sfx="")
+ {
+ // This variable is set by GitHub actions and is the recommended place
+ // to put temp files belonging to an actions job.
+ const char* RUNNER_TEMP = getenv("RUNNER_TEMP");
+ boost::filesystem::path tempdir{
+ // if RUNNER_TEMP is set and not empty
+ (RUNNER_TEMP && *RUNNER_TEMP)?
+ boost::filesystem::path(RUNNER_TEMP) : // use RUNNER_TEMP if available
+ boost::filesystem::temp_directory_path()}; // else canonical temp dir
+ boost::filesystem::path tempname{
+ // use filename template recommended by unique_path() doc, but
+ // with underscores instead of hyphens: some use cases involve
+ // temporary Python scripts
+ tempdir / stringize(pfx, "%%%%_%%%%_%%%%_%%%%", sfx) };
+ return boost::filesystem::unique_path(tempname);
}
protected:
- void createFile(const std::string& pfx, const Streamer& func)
+ void createFile(const std::string_view& pfx,
+ const Streamer& func,
+ const std::string_view& sfx)
{
// Create file in a temporary place.
- const char* tempdir = NULL;
- ll_apr_assert_status(apr_temp_dir_get(&tempdir, mPool));
-
- // Construct a temp filename template in that directory.
- char *tempname = NULL;
- ll_apr_assert_status(apr_filepath_merge(&tempname,
- tempdir,
- (pfx + "XXXXXX").c_str(),
- 0,
- mPool));
-
- // Create a temp file from that template.
- apr_file_t* fp = NULL;
- ll_apr_assert_status(apr_file_mktemp(&fp,
- tempname,
- APR_CREATE | APR_WRITE | APR_EXCL,
- mPool));
- // apr_file_mktemp() alters tempname with the actual name. Not until
- // now is it valid to capture as our mPath.
- mPath = tempname;
-
+ mPath = temp_path(pfx, sfx);
+ boost::filesystem::ofstream out{ mPath, std::ios::binary };
// Write desired content.
- std::ostringstream out;
- // Stream stuff to it.
func(out);
-
- std::string data(out.str());
- apr_size_t writelen(data.length());
- ll_apr_assert_status(apr_file_write(fp, data.c_str(), &writelen));
- ll_apr_assert_status(apr_file_close(fp));
- llassert_always(writelen == data.length());
}
- std::string mPath;
- apr_pool_t* mPool;
+ boost::filesystem::path mPath;
};
/**
* Create a NamedTempFile with a specified filename extension. This is useful
* when, for instance, you must be able to use the file in a Python import
* statement.
- *
- * A NamedExtTempFile actually has two different names. We retain the original
- * no-extension name as a placeholder in the temp directory to ensure
- * uniqueness; to that we link the name plus the desired extension. Naturally,
- * both must be removed on destruction.
*/
class NamedExtTempFile: public NamedTempFile
{
LOG_CLASS(NamedExtTempFile);
public:
- NamedExtTempFile(const std::string& ext, const std::string& content, apr_pool_t* pool=gAPRPoolp):
- NamedTempFile(remove_dot(ext), content, pool),
- mLink(mPath + ensure_dot(ext))
- {
- linkto(mLink);
- }
+ NamedExtTempFile(const std::string& ext, const std::string_view& content):
+ NamedTempFile(remove_dot(ext), content, ensure_dot(ext))
+ {}
// Disambiguate when passing string literal
- NamedExtTempFile(const std::string& ext, const char* content, apr_pool_t* pool=gAPRPoolp):
- NamedTempFile(remove_dot(ext), content, pool),
- mLink(mPath + ensure_dot(ext))
- {
- linkto(mLink);
- }
-
- NamedExtTempFile(const std::string& ext, const Streamer& func, apr_pool_t* pool=gAPRPoolp):
- NamedTempFile(remove_dot(ext), func, pool),
- mLink(mPath + ensure_dot(ext))
- {
- linkto(mLink);
- }
+ NamedExtTempFile(const std::string& ext, const char* content):
+ NamedTempFile(remove_dot(ext), content, ensure_dot(ext))
+ {}
- virtual ~NamedExtTempFile()
- {
- ll_apr_assert_status(apr_file_remove(mLink.c_str(), mPool));
- }
-
- // Since the caller has gone to the trouble to create the name with the
- // extension, that should be the name we return. In this class, mPath is
- // just a placeholder to ensure that future createFile() calls won't
- // collide.
- virtual std::string getName() const { return mLink; }
+ NamedExtTempFile(const std::string& ext, const Streamer& func):
+ NamedTempFile(remove_dot(ext), func, ensure_dot(ext))
+ {}
static std::string ensure_dot(const std::string& ext)
{
@@ -175,7 +165,7 @@ public:
{
return ext;
}
- return std::string(".") + ext;
+ return "." + ext;
}
static std::string remove_dot(const std::string& ext)
@@ -187,19 +177,6 @@ public:
}
return ext.substr(found);
}
-
-private:
- void linkto(const std::string& path)
- {
- // This method assumes that since mPath (without extension) is
- // guaranteed by apr_file_mktemp() to be unique, then (mPath + any
- // extension) is also unique. This is likely, though not guaranteed:
- // files could be created in the same temp directory other than by
- // this class.
- ll_apr_assert_status(apr_file_link(mPath.c_str(), path.c_str()));
- }
-
- std::string mLink;
};
#endif /* ! defined(LL_NAMEDTEMPFILE_H) */
diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 1161a6d8e4..611eeb43b6 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -97,10 +97,10 @@ public:
class RecordToTempFile : public LLError::Recorder, public boost::noncopyable
{
public:
- RecordToTempFile(apr_pool_t* pPool)
+ RecordToTempFile()
: LLError::Recorder(),
boost::noncopyable(),
- mTempFile("log", "", pPool),
+ mTempFile("log", ""),
mFile(mTempFile.getName().c_str())
{
}
@@ -141,11 +141,11 @@ private:
class LLReplayLogReal: public LLReplayLog, public boost::noncopyable
{
public:
- LLReplayLogReal(LLError::ELevel level, apr_pool_t* pool)
+ LLReplayLogReal(LLError::ELevel level)
: LLReplayLog(),
boost::noncopyable(),
mOldSettings(LLError::saveAndResetSettings()),
- mRecorder(new RecordToTempFile(pool))
+ mRecorder(new RecordToTempFile())
{
LLError::setFatalFunction(wouldHaveCrashed);
LLError::setDefaultLevel(level);
@@ -624,7 +624,7 @@ int main(int argc, char **argv)
if (LOGFAIL && *LOGFAIL)
{
LLError::ELevel level = LLError::decodeLevel(LOGFAIL);
- replayer.reset(new LLReplayLogReal(level, gAPRPoolp));
+ replayer.reset(new LLReplayLogReal(level));
}
}
LLError::setFatalFunction(wouldHaveCrashed);