[SystemZ][z/OS] Avoid assumption for character value in futures tests

[muiez]

Summary

The aim of this patch is to remove the assumption that the character 'a' is always 97. In turn, this patch explicitly uses the character values to account for the EBCDIC 'a' that is not 97.

[• Quuxplusone]

libcxx/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp

90

I suggest that a much nicer way to fix all these tests would be to eliminate the (int, char) signature and the cast-from-char-to-double entirely. Just have it take double(int, float) or something, and pass 4.0 instead of 'a'.

Slightly less invasive: Leave the (int, char) signature, but pass 97 instead of 'a'.

More invasive, and "clever," but clean-looking: Leave the signature, pass '0' instead of 'a', and check that the result is (double)'8'... no, wait, that would be really dumb. Don't do that. :)

Either way, please upload with full context: use git show -U999 or git diff -U999 or whatever the arc incantation is.

[muiez]

libcxx/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp

90

Thanks for the suggestion. Please see updated diff :)

[• Quuxplusone]

libcxx/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp

90

LGTM now. Of course it's now utterly bizarre that we're choosing magic numbers like 97, 99, 122 instead of, say, 1, 2, 3... but that's a pre-existing weirdness of these tests. I think this is a good solution at this point.

[muiez]

As a side note, any idea why the Group Reviewer status is still red although the revision was accepted? It says "Requested Changes to Prior Diff (by @Quuxplusone)"

[• Quuxplusone]

It's because I accepted as "Quuxplusone" but not as "libc++"; normally we like to get an OK from two libc++ reviewers (and/or @ldionne) before granting the "libc++" project approval.
Anyway, I think this is obviously fine, so while I encourage you to wait for someone else's rubber-stamp, I'm also going to just mark it accepted anyway, so even if nobody new looks at it you won't be blocked.

[muiez]

Using clang-format.

[muiez]

In D108321#2956427, @Quuxplusone wrote:

It's because I accepted as "Quuxplusone" but not as "libc++"; normally we like to get an OK from two libc++ reviewers (and/or @ldionne) before granting the "libc++" project approval.
Anyway, I think this is obviously fine, so while I encourage you to wait for someone else's rubber-stamp, I'm also going to just mark it accepted anyway, so even if nobody new looks at it you won't be blocked.

Ohh I see. Thanks for the clarification, noted!

libcxx/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp

 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
         std::packaged_task<double(int, char)> p;
         p = std::move(p0);
         assert(!p0.valid());
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
     }
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p;
         p = std::move(p0);
         assert(!p0.valid());
         assert(!p.valid());
     }
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp

 int func(int i) { return i; }
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
         assert(A::n_copies == 0);
         assert(A::n_moves > 0);
     }
     A::n_copies = 0;
     A::n_copies = 0;
     {
         A a(5);
         std::packaged_task<double(int, char)> p(a);
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
         assert(A::n_copies > 0);
         assert(A::n_moves > 0);
     }
     {
         std::packaged_task<int(int)> p(&func);
         assert(p.valid());
         std::future<int> f = p.get_future();

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp

 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
         std::packaged_task<double(int, char)> p = std::move(p0);
         assert(!p0.valid());
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
     }
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p = std::move(p0);
         assert(!p0.valid());
         assert(!p.valid());
     }
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp

 };
 
 void func(std::packaged_task<double(int, char)>)
 {
 }
 
 void func2(std::packaged_task<double(int, char)> p)
 {
-    p(3, 'a');
+    p(3, 97);
 }
 
 int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();

libcxx/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp

public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
         try
         {

libcxx/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp

 {
     long data_;
 
 public:
     explicit A(long i) : data_(i) {}
 
     long operator()(long i, long j) const
     {
-        if (j == 'z')
+        if (j == 122)
             TEST_THROW(A(6));
         return data_ + i + j;
     }
 };
 
 void func0(std::packaged_task<double(int, char)> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    p.make_ready_at_thread_exit(3, 'a');
+    p.make_ready_at_thread_exit(3, 97);
 }
 
 void func1(std::packaged_task<double(int, char)> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    p.make_ready_at_thread_exit(3, 'z');
+    p.make_ready_at_thread_exit(3, 122);
 }
 
 void func2(std::packaged_task<double(int, char)> p)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    p.make_ready_at_thread_exit(3, 'a');
+    p.make_ready_at_thread_exit(3, 97);
     try
     {
-        p.make_ready_at_thread_exit(3, 'c');
+        p.make_ready_at_thread_exit(3, 99);
     }
     catch (const std::future_error& e)
     {
         assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
     }
 #else
     ((void)p);
 #endif
 }
 
 void func3(std::packaged_task<double(int, char)> p)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        p.make_ready_at_thread_exit(3, 'a');
+        p.make_ready_at_thread_exit(3, 97);
     }
     catch (const std::future_error& e)
     {
         assert(e.code() == make_error_code(std::future_errc::no_state));
     }
 #else
     ((void)p);
 #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
         support::make_test_thread(func1, std::move(p)).detach();
         try
         {
             f.get();
             assert(false);
         }
         catch (const A& e)
         {
-            assert(e(3, 'a') == 106);
+            assert(e(3, 97) == 106.0);
         }
     }
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
         support::make_test_thread(func2, std::move(p)).detach();
         assert(f.get() == 105.0);
     }

libcxx/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp

 {
     long data_;
 
 public:
     explicit A(long i) : data_(i) {}
 
     long operator()(long i, long j) const
     {
-        if (j == 'z')
+        if (j == 122)
             TEST_THROW(A(6));
         return data_ + i + j;
     }
 };
 
 void func0(std::packaged_task<double(int, char)> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    p(3, 'a');
+    p(3, 97);
 }
 
 void func1(std::packaged_task<double(int, char)> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    p(3, 'z');
+    p(3, 122);
 }
 
 void func2(std::packaged_task<double(int, char)> p)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    p(3, 'a');
+    p(3, 97);
     try
     {
-        p(3, 'c');
+        p(3, 99);
     }
     catch (const std::future_error& e)
     {
         assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
     }
 #else
     ((void)p);
 #endif
 }
 
 void func3(std::packaged_task<double(int, char)> p)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        p(3, 'a');
+        p(3, 97);
     }
     catch (const std::future_error& e)
     {
         assert(e.code() == make_error_code(std::future_errc::no_state));
     }
 #else
     ((void)p);
 #endif
 }
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
         support::make_test_thread(func0, std::move(p)).detach();
         assert(f.get() == 105.0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
         support::make_test_thread(func1, std::move(p)).detach();
         try
         {
             f.get();
             assert(false);
         }
         catch (const A& e)
         {
-            assert(e(3, 'a') == 106);
+            assert(e(3, 97) == 106.0);
         }
     }
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
         std::thread t = support::make_test_thread(func2, std::move(p));
         assert(f.get() == 105.0);
         t.join();

libcxx/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp

public:
     }
 };
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
         p.reset();
-        p(4, 'a');
+        p(4, 97);
         f = p.get_future();
         assert(f.get() == 106.0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::packaged_task<double(int, char)> p;
         try
         {

libcxx/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp

 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
         std::packaged_task<double(int, char)> p;
         p.swap(p0);
         assert(!p0.valid());
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
     }
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p;
         p.swap(p0);
         assert(!p0.valid());
         assert(!p.valid());
     }
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp

 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
         std::packaged_task<double(int, char)> p;
         swap(p, p0);
         assert(!p0.valid());
         assert(p.valid());
         std::future<double> f = p.get_future();
-        p(3, 'a');
+        p(3, 97);
         assert(f.get() == 105.0);
     }
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p;
         swap(p, p0);
         assert(!p0.valid());
         assert(!p.valid());
     }
 
   return 0;
 }