Mark MSVC unsupported for concept emulation

There is something to say to enable those tests that work and only mark those that dont as unsupported, but this blanket statement seems better and makes the intent clear

.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept equivalence_relation;

.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp

@@ -9,6 +9,7 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: gcc-8, gcc-9
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept equivalence_relation;

.upstream-tests/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class U>
 // concept invocable;

.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept predicate;

.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.compile.pass.cpp

@@ -9,6 +9,7 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: gcc-8, gcc-9
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept predicate;

.upstream-tests/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class U>
 // concept regular_invocable;

.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept relation;

.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.compile.pass.cpp

@@ -9,6 +9,7 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: gcc-8, gcc-9
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept relation;

.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept strict_weak_order;

.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.compile.pass.cpp

@@ -9,6 +9,7 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: gcc-8, gcc-9
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class F, class... Args>
 // concept strict_weak_order;

.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept equality_comparable = // see below

.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class U>
 // concept equality_comparable_with = // see below

.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept totally_ordered;

.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered_with.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept totally_ordered_with;

.upstream-tests/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class LHS, class RHS>
 // concept assignable_from =

.upstream-tests/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class From, class To>
 // concept common_with;
@@ -567,7 +568,7 @@ __host__ __device__ constexpr bool HasCommonReference() noexcept {
   return requires { typename cuda::std::common_reference_t<T, U>; };
 #else
   return cuda::std::_Common_reference_exists<T, U>;
-#endif 
+#endif
 }
 
 static_assert(HasValidCommonType<T6, int>(), "");

.upstream-tests/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class From, class To>
 // concept common_reference_with;

.upstream-tests/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class... Args>
 // concept constructible_from;

.upstream-tests/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class From, class To>
 // concept convertible_to;

.upstream-tests/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept copy_constructible;

.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // We voluntarily use cuda::std::default_initializable on types that have redundant
 // or ignored cv-qualifiers -- don't warn about it.

.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 //     concept default_initializable = constructible_from<T> &&
@@ -28,10 +29,10 @@ _LIBCUDACXX_CONCEPT_FRAGMENT(
   brace_initializable_,
   requires() //
   ( T{}));
-  
+
 template<class T>
 _LIBCUDACXX_CONCEPT brace_initializable = _LIBCUDACXX_FRAGMENT(brace_initializable_, T);
-  
+
 __host__ __device__ void test() {
     // LWG3149
     // Changed the concept from constructible_from<T>

.upstream-tests/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class Derived, class Base>
 // concept derived_from;
@@ -397,7 +398,7 @@ int main(int, char**) {
 
 #if TEST_STD_VER > 17
     CheckNotDerivedFrom<void, void>();
-#endif 
+#endif
     CheckNotDerivedFrom<int, int>();
   }
   { // Nothing should be derived from a fundamental type

.upstream-tests/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept destructible = is_nothrow_destructible_v<T>;

.upstream-tests/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept move_constructible;

.upstream-tests/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class U>
 // concept same_as;

.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp

@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// UNSUPPORTED: gcc-5
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept swappable = // see below
@@ -249,7 +249,7 @@ int main(int, char**) {
   assert(check_throwable_adl_swappable_arrays());
   assert(check_swappable_references());
   assert(check_swappable_pointers());
-  
+
 #if (!defined(__GNUC__) || __GNUC__ >= 10)
   static_assert(check_lvalue_adl_swappable(), "");
   static_assert(check_rvalue_adl_swappable(), "");

.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp

@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// UNSUPPORTED: gcc-5
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T, class U>
 // concept swappable_with = // see below

.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept floating_point = // see below

.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept integral = // see below

.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept signed_integral = // see below

.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept unsigned_integral = // see below

.upstream-tests/test/std/concepts/concepts.object/copyable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept copyable = see below;

.upstream-tests/test/std/concepts/concepts.object/movable.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept movable = see below;

.upstream-tests/test/std/concepts/concepts.object/regular.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept regular = see below;

.upstream-tests/test/std/concepts/concepts.object/semiregular.compile.pass.cpp

@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: windows && (c++11 || c++14 || c++17)
 
 // template<class T>
 // concept semiregular = see below;