[libcxx-commits] [libcxx] f033bf8 - [libc++] [test] Qualify calls to std::atomic_flag_{clear, test} functions. NFCI.
Arthur O'Dwyer via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Feb 16 08:04:18 PST 2022
Author: Arthur O'Dwyer
Date: 2022-02-16T11:03:34-05:00
New Revision: f033bf88b4e22795dba19235b299ceebd34449b7
URL: https://github.com/llvm/llvm-project/commit/f033bf88b4e22795dba19235b299ceebd34449b7
DIFF: https://github.com/llvm/llvm-project/commit/f033bf88b4e22795dba19235b299ceebd34449b7.diff
LOG: [libc++] [test] Qualify calls to std::atomic_flag_{clear,test} functions. NFCI.
We shouldn't be calling these functions via ADL -- and neither should anybody
in the wild be calling it via ADL, so it's not like we need to test
the ADL ability of these functions in particular.
Reviewed as part of D119860.
Added:
Modified:
libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp
Removed:
################################################################################
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
index 4ac77af50a118..3e673303b859e 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
@@ -24,14 +24,14 @@ int main(int, char**)
std::atomic_flag f;
f.clear();
f.test_and_set();
- atomic_flag_clear(&f);
+ std::atomic_flag_clear(&f);
assert(f.test_and_set() == 0);
}
{
volatile std::atomic_flag f;
f.clear();
f.test_and_set();
- atomic_flag_clear(&f);
+ std::atomic_flag_clear(&f);
assert(f.test_and_set() == 0);
}
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
index a83ae26b38e79..4146b4dc3cde7 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
@@ -22,44 +22,44 @@ int main(int, char**)
{
{
std::atomic_flag f; // uninitialized first
- atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
assert(f.test_and_set() == 0);
}
{
std::atomic_flag f;
- atomic_flag_clear_explicit(&f, std::memory_order_release);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_release);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_release);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_release);
assert(f.test_and_set() == 0);
}
{
std::atomic_flag f;
- atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
assert(f.test_and_set() == 0);
}
{
volatile std::atomic_flag f;
- atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
assert(f.test_and_set() == 0);
}
{
volatile std::atomic_flag f;
- atomic_flag_clear_explicit(&f, std::memory_order_release);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_release);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_release);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_release);
assert(f.test_and_set() == 0);
}
{
volatile std::atomic_flag f;
- atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
assert(f.test_and_set() == 0);
- atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+ std::atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
assert(f.test_and_set() == 0);
}
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp
index 4ee4de1e7893b..c8ded8fffd311 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp
@@ -23,16 +23,16 @@ int main(int, char**)
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test(&f) == 0);
+ assert(std::atomic_flag_test(&f) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test(&f) == 1);
+ assert(std::atomic_flag_test(&f) == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test(&f) == 0);
+ assert(std::atomic_flag_test(&f) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test(&f) == 1);
+ assert(std::atomic_flag_test(&f) == 1);
}
return 0;
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
index 1e643fa245eef..b80dbe54feee8 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
@@ -23,13 +23,13 @@ int main(int, char**)
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set(&f) == 0);
+ assert(std::atomic_flag_test_and_set(&f) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set(&f) == 0);
+ assert(std::atomic_flag_test_and_set(&f) == 0);
assert(f.test_and_set() == 1);
}
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
index 8a5b55ad68ab5..00036c2664c1f 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
@@ -23,73 +23,73 @@ int main(int, char**)
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0);
assert(f.test_and_set() == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0);
assert(f.test_and_set() == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0);
assert(f.test_and_set() == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0);
assert(f.test_and_set() == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0);
assert(f.test_and_set() == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0);
assert(f.test_and_set() == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
+ assert(std::atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
assert(f.test_and_set() == 1);
}
diff --git a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp
index 1132dbd6106af..f2a5632b77ddd 100644
--- a/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp
@@ -23,90 +23,90 @@ int main(int, char**)
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
}
#ifdef _LIBCPP_VERSION // Don't violate precondition [atomics.flag]/6
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
}
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
}
#endif // _LIBCPP_VERSION
{
std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
}
#ifdef _LIBCPP_VERSION // Don't violate precondition [atomics.flag]/6
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
}
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
}
#endif // _LIBCPP_VERSION
{
volatile std::atomic_flag f;
f.clear();
- assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
assert(f.test_and_set() == 0);
- assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
+ assert(std::atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
}
return 0;
More information about the libcxx-commits
mailing list