From 8429693866326bf23e7d40b15f2943798d262e72 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Thu, 16 Nov 2023 15:27:10 -0800 Subject: [PATCH] Added skip test flags to test_base Flags are to be used in new tests when creating tests that potentially take a long time to run. Certain test suites are intended to be quick and may skip certain long running tests. New slow tests should check these flags and skip using GTEST_SKIP(). Bug: 311273599 Test: ./build.py x86-64 --debug Change-Id: I4fc5a026f23f489bf2ad8b8a11dc467f550f0c5e --- libwvdrmengine/cdm/core/test/test_base.cpp | 92 +++++++++++++++++++++- libwvdrmengine/cdm/core/test/test_base.h | 24 +++++- 2 files changed, 112 insertions(+), 4 deletions(-) diff --git a/libwvdrmengine/cdm/core/test/test_base.cpp b/libwvdrmengine/cdm/core/test/test_base.cpp index 59ab761e..e6cfa8b8 100644 --- a/libwvdrmengine/cdm/core/test/test_base.cpp +++ b/libwvdrmengine/cdm/core/test/test_base.cpp @@ -145,14 +145,60 @@ void show_menu(const char* prog_name, const std::string& extra_help_text) { std::cout << " --dump_golden_data" << std::endl; std::cout << " Dump the license request and response from the server." + << std::endl + << std::endl; + + std::cout << " --skip-slow-tests" << std::endl; + std::cout << " Skips tests that are known to be slow." << std::endl; + std::cout << " --skip-sleepy-tests" << std::endl; + std::cout << " Skips tests that sleep a lot." << std::endl; + std::cout << " --run-sleepy-tests" << std::endl; + std::cout << " Allow tests that sleep a lot (used with --skip-slow-tests)" + << std::endl; + std::cout << " --skip-decryption-stress-tests" << std::endl; + std::cout << " Skips decryption stress tests." << std::endl; + std::cout << " --run-decryption-stress-tests" << std::endl; + std::cout << " Allow decryption stress tests (used with " + << "--skip-slow-tests)" << std::endl; + std::cout << " --skip-request-flood-tests" << std::endl; + std::cout << " Skips tests that generate a lot of requests." << std::endl; + std::cout << " --run-request-flood-tests" << std::endl; + std::cout << " Allow tests that generate a lot of requests (used with " + << "--skip-slow-tests)" << std::endl; + std::cout << " --skip-multi-thread-stress-tests" << std::endl; + std::cout << " Skips tests that stress thread protections." << std::endl; + std::cout << " --run-multi-thread-stress-tests" << std::endl; + std::cout << " Allow tests that stress thread protections (used with " + << "--skip-slow-tests)" << std::endl; + std::cout << " --skip-usage-table-stress-tests" << std::endl; + std::cout << " Skips tests that stess the usage table." << std::endl; + std::cout << " --run-usage-table-stress-tests" << std::endl; + std::cout << " Allow tests that stess the usage table (used with " + << "--skip-slow-tests)" << std::endl << std::endl; std::cout << extra_help_text << std::endl; } + +enum OptionalBool { + kBoolUnset, + kBoolFalse, + kBoolTrue, +}; + +bool UnwrapOptionalBool(OptionalBool value, bool default_value) { + return (value == kBoolUnset) ? default_value : (value == kBoolTrue); +} } // namespace +// Static WvCdmTestBase variables. std::unique_ptr WvCdmTestBase::default_config_; bool WvCdmTestBase::use_qa_test_keybox_ = false; +bool WvCdmTestBase::skip_sleepy_tests_ = false; +bool WvCdmTestBase::skip_decryption_stress_tests_ = false; +bool WvCdmTestBase::skip_request_flood_tests_ = false; +bool WvCdmTestBase::skip_multi_thread_stress_tests_ = false; +bool WvCdmTestBase::skip_usage_table_stress_tests_ = false; void WvCdmTestBase::StripeBuffer(std::vector* buffer, size_t size, uint8_t init) { @@ -311,8 +357,7 @@ void WvCdmTestBase::InstallTestRootOfTrust() { } } -WvCdmTestBase::WvCdmTestBase() - : config_(*default_config_), binary_provisioning_(false) { +WvCdmTestBase::WvCdmTestBase() : config_(*default_config_) { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); @@ -375,12 +420,21 @@ bool WvCdmTestBase::Initialize(int argc, const char* const argv[], bool show_usage = false; int verbosity = 0; + bool skip_slow_tests = false; + OptionalBool skip_sleepy_tests = kBoolUnset; + OptionalBool skip_decryption_stress_tests = kBoolUnset; + OptionalBool skip_request_flood_tests = kBoolUnset; + OptionalBool skip_multi_thread_stress_tests = kBoolUnset; + OptionalBool skip_usage_table_stress_tests = kBoolUnset; + default_config_.reset(new ConfigTestEnv(kContentProtectionUatServer)); // Skip the first element, which is the program name. const std::vector args(argv + 1, argv + argc); for (const std::string& arg : args) { - if (arg == "--verbose" || arg == "-v") { + if (arg == "--help" || arg == "-h") { + show_usage = true; + } else if (arg == "--verbose" || arg == "-v") { ++verbosity; } else if (arg == "--no_filter") { filter_tests = false; @@ -398,6 +452,28 @@ bool WvCdmTestBase::Initialize(int argc, const char* const argv[], } else if (arg == "--dump_golden_data") { default_config_->set_dump_golden_data(true); testing::AddGlobalTestEnvironment(new MessageDumper); + } else if (arg == "--skip-slow-tests") { + skip_slow_tests = true; + } else if (arg == "--skip-sleepy-tests") { + skip_sleepy_tests = kBoolTrue; + } else if (arg == "--run-sleepy-tests") { + skip_sleepy_tests = kBoolFalse; + } else if (arg == "--skip-decryption-stress-tests") { + skip_decryption_stress_tests = kBoolTrue; + } else if (arg == "--run-decryption-stress-tests") { + skip_decryption_stress_tests = kBoolFalse; + } else if (arg == "--skip-request-flood-tests") { + skip_request_flood_tests = kBoolTrue; + } else if (arg == "--run-request-flood-tests") { + skip_request_flood_tests = kBoolFalse; + } else if (arg == "--skip-multi-thread-stress-tests") { + skip_multi_thread_stress_tests = kBoolTrue; + } else if (arg == "--run-multi-thread-stress-tests") { + skip_multi_thread_stress_tests = kBoolFalse; + } else if (arg == "--skip-usage-table-stress-tests") { + skip_usage_table_stress_tests = kBoolTrue; + } else if (arg == "--run-usage-table-stress-tests") { + skip_usage_table_stress_tests = kBoolFalse; } else { const auto index = arg.find('='); if (index == std::string::npos) { @@ -498,6 +574,16 @@ bool WvCdmTestBase::Initialize(int argc, const char* const argv[], ::testing::GTEST_FLAG(filter) = wvoec::global_features.RestrictFilter(::testing::GTEST_FLAG(filter)); } + + skip_sleepy_tests_ = UnwrapOptionalBool(skip_sleepy_tests, skip_slow_tests); + skip_decryption_stress_tests_ = + UnwrapOptionalBool(skip_decryption_stress_tests, skip_slow_tests); + skip_request_flood_tests_ = + UnwrapOptionalBool(skip_request_flood_tests, skip_slow_tests); + skip_multi_thread_stress_tests_ = + UnwrapOptionalBool(skip_multi_thread_stress_tests, skip_slow_tests); + skip_usage_table_stress_tests_ = + UnwrapOptionalBool(skip_usage_table_stress_tests, skip_slow_tests); return true; } diff --git a/libwvdrmengine/cdm/core/test/test_base.h b/libwvdrmengine/cdm/core/test/test_base.h index 8c41dd64..3a9aa343 100644 --- a/libwvdrmengine/cdm/core/test/test_base.h +++ b/libwvdrmengine/cdm/core/test/test_base.h @@ -48,6 +48,20 @@ class WvCdmTestBase : public ::testing::Test { // Calls Provision() if not already provisioned. virtual void EnsureProvisioned(); + virtual bool skip_sleepy_tests() const { return skip_sleepy_tests_; } + virtual bool skip_decryption_stress_tests() const { + return skip_decryption_stress_tests_; + } + virtual bool skip_request_flood_tests() const { + return skip_request_flood_tests_; + } + virtual bool skip_multi_thread_stress_tests() const { + return skip_multi_thread_stress_tests_; + } + virtual bool skip_usage_table_stress_tests() const { + return skip_usage_table_stress_tests_; + } + // Fill a buffer with some nonconstant data of the given size. The first byte // will be set to to help you find the buffer when debugging. static void StripeBuffer(std::vector* buffer, size_t size, @@ -78,7 +92,15 @@ class WvCdmTestBase : public ::testing::Test { // This should be set by test subclasses BEFORE calling SetUp -- i.e. in the // tests's constructor. - bool binary_provisioning_; + bool binary_provisioning_ = false; + + private: + // Skip flags for long running tests. + static bool skip_sleepy_tests_; + static bool skip_decryption_stress_tests_; + static bool skip_request_flood_tests_; + static bool skip_multi_thread_stress_tests_; + static bool skip_usage_table_stress_tests_; }; // This just makes the constructor public so that we can create one with dummy