[libc++] [test] Remove `UNSUPPORTED: stdlib=msvc` from lock.pass.cpp

[• Quuxplusone]

Summary

@CaseyCarter says, "We run std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp on every CI and it works fine with MSVC STL. I'm guessing this annotation predates @BillyONeal's rewrite of std::lock in 2017-ish."

[BillyONeal]

There should probably be a note here that this test isn't testing
standard guarantee; it's testing that Howard's dining philosophers
rebooted algorithm is implemented.

[Mordante]

LGTM

[• Quuxplusone]

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

109–113

@BillyONeal: Oh, I think I see what you mean. This test isn't conforming, right? Because here type L1 has a try_lock method that literally never succeeds. So this test might reasonably spin forever, spinning trying to lock L1 l1 via try_lock and never succeeding. The only reason it "works" with libc++ (and presumably now MSVC) is that when l1.try_lock() fails, we unlock everything and start over with a blocking l1.lock() (which happens to succeed).
I'll adjust the comment, but also, gross. :P

[• Quuxplusone]

Update the comment.

It feels like this test maybe shouldn't even be in libcxx/test/std/, but it's also our only test coverage for std::lock at all, and splitting it up into "conforming" and "non-conforming" pieces seems like more than I signed up for. So I'm going to resist scope creep and land this once CI is green. If someone else wants to tackle the "write good std::lock tests" task, that'd be cool.

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// This test hangs forever when built against libstdc++ and MSVC. In order to allow
-// validation of the test suite against other STLs we have to mark it
-// unsupported.
-// UNSUPPORTED: stdlib=libstdc++, stdlib=msvc
+// This test hangs forever when built against libstdc++ (Oct 2016).
+// UNSUPPORTED: stdlib=libstdc++
+
+// This test isn't quite standards-conforming: it's testing our specific
+// algorithm, where when lx.try_lock() fails we start the next attempt
+// with an unconditional lx.lock(). Thus our algorithm can handle a list
+// of mutexes where at-most-one of them is of the evil type `class L1`,
+// but will loop forever if two or more of them are `class L1`.
 
 // <mutex>
 
 // template <class L1, class L2, class... L3>
 //   void lock(L1&, L2&, L3&...);
 
 #include <mutex>
 #include <cassert>
int main(int, char**)
     {
         L0 l0;
         L0 l1;
         std::lock(l0, l1);
         assert(l0.locked());
         assert(l1.locked());
     }
     {
         L0 l0;
         L1 l1;
         std::lock(l0, l1);
         assert(l0.locked());
         assert(l1.locked());
     }
     {
         L1 l0;
         L0 l1;
         std::lock(l0, l1);
         assert(l0.locked());
         assert(l1.locked());
     }