maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[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.
This commit is contained in:
Arthur O'Dwyer 2022-02-13 21:53:20 -05:00
parent 98bb747c87
commit f033bf88b4
6 changed files with 56 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libcxx/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
View File

@ -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);
}

24
libcxx/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
View File

@ -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);
}

8
libcxx/test/std/atomics/atomics.flag/atomic_flag_test.pass.cpp
View File

@ -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;

4
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
View File

@ -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);
}

24
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
View File

@ -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);
}

48
libcxx/test/std/atomics/atomics.flag/atomic_flag_test_explicit.pass.cpp
View File

@ -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;