[libcxx] [test] Fix unreferenced formal parameter warnings.

[STL_MSFT]

Summary

Fix unreferenced formal parameter warnings. Found by MSVC as usual.

[EricWF]

Get commit access!

[EricWF]

r284942.

test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp

public:
 
     friend constexpr bool operator==(const Y& x, const Y& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Z
 {
 public:
-    Z(int i) {TEST_THROW(6);}
+    Z(int) {TEST_THROW(6);}
 };
 
 
 int main()
 {
     {
         constexpr optional<int> opt(in_place, 5);
         static_assert(static_cast<bool>(opt) == true, "");

test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp

 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {}
     Z(Z&&) {TEST_THROW(7);}
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
-    friend void swap(Z& x, Z& y) {TEST_THROW(6);}
+    friend void swap(Z&, Z&) {TEST_THROW(6);}
 };
 
 
 int main()
 {
     {
         optional<int> opt1;
         optional<int> opt2;

test/std/utilities/optional/optional.specalg/swap.pass.cpp

 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {}
     Z(Z&&) { TEST_THROW(7);}
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
-    friend void swap(Z& x, Z& y) { TEST_THROW(6);}
+    friend void swap(Z&, Z&) { TEST_THROW(6);}
 };
 
 
 struct NonSwappable {
     NonSwappable(NonSwappable const&) = delete;
 };
 void swap(NonSwappable&, NonSwappable&) = delete;
 

test/support/archetypes.hpp

struct TestBase {
     explicit TestBase(int x) noexcept : value(x) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     TestBase(int x) noexcept : value(x) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit TestBase(int x, int y) noexcept : value(y) {
+    explicit TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    TestBase(int x, int y) noexcept : value(y) {
+    TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit TestBase(std::initializer_list<int>& il, int y = 0) noexcept
       : value(il.size()) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>

 
 template <bool Explicit = false>
 struct ValueBase {
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr ValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr ValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit constexpr ValueBase(int x, int y) : value(y) {}
+    explicit constexpr ValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    constexpr ValueBase(int x, int y) : value(y) {}
+    constexpr ValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr ValueBase(std::initializer_list<int>& il, int y = 0) : value(il.size()) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr ValueBase(std::initializer_list<int>& il, int y = 0) : value(il.size()) {}
     TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
         value = xvalue;
         return *this;
     }

 
 template <bool Explicit = false>
 struct TrivialValueBase {
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr TrivialValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit constexpr TrivialValueBase(int x, int y) : value(y) {}
+    explicit constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    constexpr TrivialValueBase(int x, int y) : value(y) {}
+    constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int y = 0) : value(il.size()) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(std::initializer_list<int>& il, int y = 0) : value(il.size()) {};
     int value;
 protected:
     constexpr TrivialValueBase() noexcept : value(0) {}
 };