From f682f070079037f8fb646e91ea336af0bc778813 Mon Sep 17 00:00:00 2001 From: Kim Barrett Date: Wed, 17 Sep 2025 20:20:17 +0000 Subject: [PATCH] 8367796: Rename AtomicAccess gtests Reviewed-by: ayang, tschatzl --- .../gtest/runtime/test_atomicAccess.cpp | 103 +++++++++--------- 1 file changed, 52 insertions(+), 51 deletions(-) diff --git a/test/hotspot/gtest/runtime/test_atomicAccess.cpp b/test/hotspot/gtest/runtime/test_atomicAccess.cpp index 523f27ca870..6e05f429970 100644 --- a/test/hotspot/gtest/runtime/test_atomicAccess.cpp +++ b/test/hotspot/gtest/runtime/test_atomicAccess.cpp @@ -25,13 +25,14 @@ #include "runtime/atomicAccess.hpp" #include "unittest.hpp" -// These tests of Atomic only verify functionality. They don't verify atomicity. +// These tests of AtomicAccess only verify functionality. They don't verify +// atomicity. template -struct AtomicAddTestSupport { +struct AtomicAccessAddTestSupport { volatile T _test_value; - AtomicAddTestSupport() : _test_value{} {} + AtomicAccessAddTestSupport() : _test_value{} {} void test_add() { T zero = 0; @@ -52,19 +53,19 @@ struct AtomicAddTestSupport { } }; -TEST_VM(AtomicAddTest, int32) { - using Support = AtomicAddTestSupport; +TEST_VM(AtomicAccessAddTest, int32) { + using Support = AtomicAccessAddTestSupport; Support().test_add(); Support().test_fetch_add(); } -TEST_VM(AtomicAddTest, int64) { - using Support = AtomicAddTestSupport; +TEST_VM(AtomicAccessAddTest, int64) { + using Support = AtomicAccessAddTestSupport; Support().test_add(); Support().test_fetch_add(); } -TEST_VM(AtomicAddTest, ptr) { +TEST_VM(AtomicAccessAddTest, ptr) { uint _test_values[10] = {}; uint* volatile _test_value{}; @@ -84,10 +85,10 @@ TEST_VM(AtomicAddTest, ptr) { }; template -struct AtomicXchgTestSupport { +struct AtomicAccessXchgTestSupport { volatile T _test_value; - AtomicXchgTestSupport() : _test_value{} {} + AtomicAccessXchgTestSupport() : _test_value{} {} void test() { T zero = 0; @@ -99,21 +100,21 @@ struct AtomicXchgTestSupport { } }; -TEST_VM(AtomicXchgTest, int32) { - using Support = AtomicXchgTestSupport; +TEST_VM(AtomicAccessXchgTest, int32) { + using Support = AtomicAccessXchgTestSupport; Support().test(); } -TEST_VM(AtomicXchgTest, int64) { - using Support = AtomicXchgTestSupport; +TEST_VM(AtomicAccessXchgTest, int64) { + using Support = AtomicAccessXchgTestSupport; Support().test(); } template -struct AtomicCmpxchgTestSupport { +struct AtomicAccessCmpxchgTestSupport { volatile T _test_value; - AtomicCmpxchgTestSupport() : _test_value{} {} + AtomicAccessCmpxchgTestSupport() : _test_value{} {} void test() { T zero = 0; @@ -129,25 +130,25 @@ struct AtomicCmpxchgTestSupport { } }; -TEST_VM(AtomicCmpxchgTest, int32) { - using Support = AtomicCmpxchgTestSupport; +TEST_VM(AtomicAccessCmpxchgTest, int32) { + using Support = AtomicAccessCmpxchgTestSupport; Support().test(); } -TEST_VM(AtomicCmpxchgTest, int64) { +TEST_VM(AtomicAccessCmpxchgTest, int64) { // Check if 64-bit atomics are available on the machine. if (!VM_Version::supports_cx8()) return; - using Support = AtomicCmpxchgTestSupport; + using Support = AtomicAccessCmpxchgTestSupport; Support().test(); } -struct AtomicCmpxchg1ByteStressSupport { +struct AtomicAccessCmpxchg1ByteStressSupport { char _default_val; int _base; char _array[7+32+7]; - AtomicCmpxchg1ByteStressSupport() : _default_val(0x7a), _base(7), _array{} {} + AtomicAccessCmpxchg1ByteStressSupport() : _default_val(0x7a), _base(7), _array{} {} void validate(char val, char val2, int index) { for (int i = 0; i < 7; i++) { @@ -182,16 +183,16 @@ struct AtomicCmpxchg1ByteStressSupport { } }; -TEST_VM(AtomicCmpxchg1Byte, stress) { - AtomicCmpxchg1ByteStressSupport support; +TEST_VM(AtomicAccessCmpxchg1Byte, stress) { + AtomicAccessCmpxchg1ByteStressSupport support; support.test(); } template -struct AtomicEnumTestSupport { +struct AtomicAccessEnumTestSupport { volatile T _test_value; - AtomicEnumTestSupport() : _test_value{} {} + AtomicAccessEnumTestSupport() : _test_value{} {} void test_store_load(T value) { EXPECT_NE(value, AtomicAccess::load(&_test_value)); @@ -216,25 +217,25 @@ struct AtomicEnumTestSupport { } }; -namespace AtomicEnumTestUnscoped { // Scope the enumerators. +namespace AtomicAccessEnumTestUnscoped { // Scope the enumerators. enum TestEnum { A, B, C }; } -TEST_VM(AtomicEnumTest, unscoped_enum) { - using namespace AtomicEnumTestUnscoped; - using Support = AtomicEnumTestSupport; +TEST_VM(AtomicAccessEnumTest, unscoped_enum) { + using namespace AtomicAccessEnumTestUnscoped; + using Support = AtomicAccessEnumTestSupport; Support().test_store_load(B); Support().test_cmpxchg(B, C); Support().test_xchg(B, C); } -enum class AtomicEnumTestScoped { A, B, C }; +enum class AtomicAccessEnumTestScoped { A, B, C }; -TEST_VM(AtomicEnumTest, scoped_enum) { - const AtomicEnumTestScoped B = AtomicEnumTestScoped::B; - const AtomicEnumTestScoped C = AtomicEnumTestScoped::C; - using Support = AtomicEnumTestSupport; +TEST_VM(AtomicAccessEnumTest, scoped_enum) { + const AtomicAccessEnumTestScoped B = AtomicAccessEnumTestScoped::B; + const AtomicAccessEnumTestScoped C = AtomicAccessEnumTestScoped::C; + using Support = AtomicAccessEnumTestSupport; Support().test_store_load(B); Support().test_cmpxchg(B, C); @@ -242,14 +243,14 @@ TEST_VM(AtomicEnumTest, scoped_enum) { } template -struct AtomicBitopsTestSupport { +struct AtomicAccessBitopsTestSupport { volatile T _test_value; // At least one byte differs between _old_value and _old_value op _change_value. static const T _old_value = static_cast(UCONST64(0x7f5300007f530044)); static const T _change_value = static_cast(UCONST64(0x3800530038005322)); - AtomicBitopsTestSupport() : _test_value(0) {} + AtomicAccessBitopsTestSupport() : _test_value(0) {} void fetch_then_and() { AtomicAccess::store(&_test_value, _old_value); @@ -320,31 +321,31 @@ struct AtomicBitopsTestSupport { }; template -const T AtomicBitopsTestSupport::_old_value; +const T AtomicAccessBitopsTestSupport::_old_value; template -const T AtomicBitopsTestSupport::_change_value; +const T AtomicAccessBitopsTestSupport::_change_value; -TEST_VM(AtomicBitopsTest, int8) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, int8) { + AtomicAccessBitopsTestSupport()(); } -TEST_VM(AtomicBitopsTest, uint8) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, uint8) { + AtomicAccessBitopsTestSupport()(); } -TEST_VM(AtomicBitopsTest, int32) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, int32) { + AtomicAccessBitopsTestSupport()(); } -TEST_VM(AtomicBitopsTest, uint32) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, uint32) { + AtomicAccessBitopsTestSupport()(); } -TEST_VM(AtomicBitopsTest, int64) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, int64) { + AtomicAccessBitopsTestSupport()(); } -TEST_VM(AtomicBitopsTest, uint64) { - AtomicBitopsTestSupport()(); +TEST_VM(AtomicAccessBitopsTest, uint64) { + AtomicAccessBitopsTestSupport()(); }