[libcxx][tests]Skip checking midpoint of adjacent values for PPC double-double

[xingxue]

Summary

For 128 bit long double implemented as 2 doubles on PowerPC, nextafterl() of libm gives imprecise results which fails the test that checks the midpoint of adjacent values. This patch skips the test for this particular case on PowerPC.

[hubert.reinterpretcast]

Seems reasonable. @mclow.lists, any comments?

[mclow.lists]

I'd like to understand what's going on with nextafter when you say "is unreliable". Is there a link describing this behavior?

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

91

This is all compile-time stuff; we shouldn't be doing a runtime check.
Also, in other places we check #if defined(__PPC__) not just #if __PPC__

114

We don't usually write outputs in tests; no one looks at them.

[mclow.lists]

In svn 360673 we changed this call from "nextoward` to nextafter because NetBSD 8 doesn't implement the former.

[hubert.reinterpretcast]

In D62384#1531670, @mclow.lists wrote:

I'd like to understand what's going on with nextafter when you say "is unreliable". Is there a link describing this behavior?

https://bugs.launchpad.net/ubuntu/+source/glibc/+bug/1831808

[xingxue]

Addressed comments:

• Skip the test of midpoint of adjacent values for PPC double-double based on compile-time checking;
• Use #if defined(__PPC__) instead of #if __PPC__ ;
• Removed output to std::cerr.

[xingxue]

Thanks Marshall and Hubert for your comments!

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

91

Changed to skip the test without a runtime check. Use #if defined(__PPC__) as suggested.

114

Removed the output.

[xingxue]

Hi @mclow.lists, Do you have any further comments?

[mclow.lists]

I was updating this test this morning to add constexpr tests, so I just committed this as revision 363740.

[hubert.reinterpretcast]

I believe that all comments have been addressed. LGTM.

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

84

Just a note: It appears AIX does not provide nextafterl for such long doubles anyway.

[xingxue]

Thanks to Marshall for committing the patch. Closing this revision.

llvm-svn: 363740

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

     assert(d0 < d1);  // sanity checking
     assert(d1 < d2);  // sanity checking
 
-//  Since there's nothing in between, the midpoint has to be one or the other
-    T res;
-    res = std::midpoint(d0, d1);
-    assert(res == d0 || res == d1);
-    assert(d0 <= res);
-    assert(res <= d1);
-    res = std::midpoint(d1, d0);
-    assert(res == d0 || res == d1);
-    assert(d0 <= res);
-    assert(res <= d1);
-
-    res = std::midpoint(d1, d2);
-    assert(res == d1 || res == d2);
-    assert(d1 <= res);
-    assert(res <= d2);
-    res = std::midpoint(d2, d1);
-    assert(res == d1 || res == d2);
-    assert(d1 <= res);
-    assert(res <= d2);
+#if defined(__PPC__) && __LONG_DOUBLE_128__ && !__LONG_DOUBLE_IEEE128__
+    // For 128 bit long double implemented as 2 doubles on PowerPC,
+    // nextafterl() of libm gives imprecise results which fails the
+    // midpoint() tests below. So skip the test for this case.
+    if constexpr (sizeof(T) != 16)
+#endif
+    {
+        // Since there's nothing in between, the midpoint has to be one or
+        // the other.
+        T res;
+        res = std::midpoint(d0, d1);
+        assert(res == d0 || res == d1);
+        assert(d0 <= res);
+        assert(res <= d1);
+        res = std::midpoint(d1, d0);
+        assert(res == d0 || res == d1);
+        assert(d0 <= res);
+        assert(res <= d1);
+
+        res = std::midpoint(d1, d2);
+        assert(res == d1 || res == d2);
+        assert(d1 <= res);
+        assert(res <= d2);
+        res = std::midpoint(d2, d1);
+        assert(res == d1 || res == d2);
+        assert(d1 <= res);
+        assert(res <= d2);
+    }
 }