[libcxx] [test] Remove spurious semicolons.

[STL_MSFT]

Summary

[libcxx] [test] Remove spurious semicolons.

[STL_MSFT]

Thanks, r288750.

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

#if TEST_STD_VER >= 11
         assert(i->first == 4);
         assert(i->second == "four");
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
-        assert(c.get_allocator() == A{});;
+        assert(c.get_allocator() == A{});
     }
 #endif
 }

test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp

int main()
     {
         std::ostringstream ss0(" 123 456");
         std::ostringstream ss;
         ss.swap(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
-        ss0 << i << ' ' << 567;;
+        ss0 << i << ' ' << 567;
         assert(ss0.str() == "234 567");
     }
     {
         std::wostringstream ss0(L" 123 456");
         std::wostringstream ss;
         ss.swap(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
-        ss0 << i << ' ' << 567;;
+        ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
 }

test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::ostringstream ss0(" 123 456");
         std::ostringstream ss;
         ss = std::move(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
     }
     {
         std::wostringstream ss0(L" 123 456");
         std::wostringstream ss;
         ss = std::move(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp

int main()
     {
         std::ostringstream ss0(" 123 456");
         std::ostringstream ss;
         swap(ss, ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
-        ss0 << i << ' ' << 567;;
+        ss0 << i << ' ' << 567;
         assert(ss0.str() == "234 567");
     }
     {
         std::wostringstream ss0(L" 123 456");
         std::wostringstream ss;
         swap(ss, ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
-        ss0 << i << ' ' << 567;;
+        ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
 }

test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::ostringstream ss0(" 123 456");
         std::ostringstream ss(std::move(ss0));
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
     }
     {
         std::wostringstream ss0(L" 123 456");
         std::wostringstream ss(std::move(ss0));
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp

 int main()
 {
     {
         std::ostringstream ss(" 123 456");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
     }
     {
         std::ostringstream ss(" 123 456", std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == "234 5676");
     }
     {
         std::wostringstream ss(L" 123 456");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
     {
         std::wostringstream ss(L" 123 456", std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456");
         int i = 234;
-        ss << i << ' ' << 567;;
+        ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
 }

test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp

typename base::int_type
         {++overflow_called; return base::overflow(c);}
 
     void pbump(int n) {base::pbump(n);}
 };
 
 int main()
 {
     {  // sanity check
-    testbuf<char> tb("");;
+    testbuf<char> tb("");
     tb.overflow();
     }
     {
         testbuf<char> sb("abc");
         assert(sb.sputc('1') == '1');
         assert(sb.str() == "1bc");
         assert(sb.sputc('2') == '2');
         assert(sb.str() == "12c");

test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp

typename base::int_type
         {return base::pbackfail(c);}
 
     void pbump(int n) {base::pbump(n);}
 };
 
 int main()
 {
     {  // sanity check
-    testbuf<char> tb("");;
+    testbuf<char> tb("");
     tb.pbackfail();
     }
     {
         testbuf<char> sb("123", std::ios_base::in);
         assert(sb.sgetc() == '1');
         assert(sb.snextc() == '2');
         assert(sb.snextc() == '3');
         assert(sb.sgetc() == '3');

test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp

 }
 
 template <std::size_t N>
 void test_op_and()
 {
     std::bitset<N> v1 = make_bitset<N>();
     std::bitset<N> v2 = make_bitset<N>();
     std::bitset<N> v3 = v1;
-    assert((v1 & v2) == (v3 &= v2));;
+    assert((v1 & v2) == (v3 &= v2));
 }
 
 int main()
 {
     test_op_and<0>();
     test_op_and<1>();
     test_op_and<31>();
     test_op_and<32>();
     test_op_and<33>();
     test_op_and<63>();
     test_op_and<64>();
     test_op_and<65>();
     test_op_and<1000>();
 }

test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp

 }
 
 template <std::size_t N>
 void test_op_not()
 {
     std::bitset<N> v1 = make_bitset<N>();
     std::bitset<N> v2 = make_bitset<N>();
     std::bitset<N> v3 = v1;
-    assert((v1 ^ v2) == (v3 ^= v2));;
+    assert((v1 ^ v2) == (v3 ^= v2));
 }
 
 int main()
 {
     test_op_not<0>();
     test_op_not<1>();
     test_op_not<31>();
     test_op_not<32>();
     test_op_not<33>();
     test_op_not<63>();
     test_op_not<64>();
     test_op_not<65>();
     test_op_not<1000>();
 }

test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp

 }
 
 template <std::size_t N>
 void test_op_or()
 {
     std::bitset<N> v1 = make_bitset<N>();
     std::bitset<N> v2 = make_bitset<N>();
     std::bitset<N> v3 = v1;
-    assert((v1 | v2) == (v3 |= v2));;
+    assert((v1 | v2) == (v3 |= v2));
 }
 
 int main()
 {
     test_op_or<0>();
     test_op_or<1>();
     test_op_or<31>();
     test_op_or<32>();
     test_op_or<33>();
     test_op_or<63>();
     test_op_or<64>();
     test_op_or<65>();
     test_op_or<1000>();
 }

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp

 // template <size_t I, class... Types>
 //   const typename tuple_element<I, tuple<Types...> >::type&&
 //   get(const tuple<Types...>&& t);
 
 // UNSUPPORTED: c++98, c++03
 
 #include <tuple>
 
-template <class T> void cref(T const&) {};
+template <class T> void cref(T const&) {}
 template <class T> void cref(T const&&) = delete;
 
 std::tuple<int> const tup4() { return std::make_tuple(4); }
 
 int main()
 {
     // LWG2485: tuple should not open a hole in the type system, get() should
     // imitate [expr.ref]'s rules for accessing data members
     {
         cref(std::get<0>(tup4()));  // expected-error {{call to deleted function 'cref'}}
     }
 }

test/support/uses_alloc_types.hpp

public:
     UsesAllocatorV1() : Base(&makeArgumentID<>()) {}
 
     UsesAllocatorV1(UsesAllocatorV1 const&)
         : Base(&makeArgumentID<UsesAllocatorV1 const&>()) {}
     UsesAllocatorV1(UsesAllocatorV1 &&)
         : Base(&makeArgumentID<UsesAllocatorV1 &&>()) {}
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
-    UsesAllocatorV1(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+    UsesAllocatorV1(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     UsesAllocatorV1(std::allocator_arg_t tag, CtorAlloc const & a, Args&&... args)
         : Base(tag, a, std::forward<Args>(args)...)
     { }
 
     // BLOWS UP: Uses Allocator Last Ctor
public:
     UsesAllocatorV2() : Base(&makeArgumentID<>()) {}
     UsesAllocatorV2(UsesAllocatorV2 const&)
         : Base(&makeArgumentID<UsesAllocatorV2 const&>()) {}
     UsesAllocatorV2(UsesAllocatorV2 &&)
         : Base(&makeArgumentID<UsesAllocatorV2 &&>()) {}
 
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
-    UsesAllocatorV2(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+    UsesAllocatorV2(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     UsesAllocatorV2(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
public:
     UsesAllocatorV3() : Base(&makeArgumentID<>()) {}
     UsesAllocatorV3(UsesAllocatorV3 const&)
         : Base(&makeArgumentID<UsesAllocatorV3 const&>()) {}
     UsesAllocatorV3(UsesAllocatorV3 &&)
         : Base(&makeArgumentID<UsesAllocatorV3 &&>()) {}
 
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
-    UsesAllocatorV3(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+    UsesAllocatorV3(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     UsesAllocatorV3(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
         : Base(tag, alloc, std::forward<Args>(args)...)
     {}
 
     // Uses Allocator Last Ctor
public:
 
     NotUsesAllocator() : Base(&makeArgumentID<>()) {}
     NotUsesAllocator(NotUsesAllocator const&)
         : Base(&makeArgumentID<NotUsesAllocator const&>()) {}
     NotUsesAllocator(NotUsesAllocator &&)
         : Base(&makeArgumentID<NotUsesAllocator &&>()) {}
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
-    NotUsesAllocator(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+    NotUsesAllocator(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
         : Base(tag, alloc, std::forward<Args>(args)...)
     {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     NotUsesAllocator(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
 #endif /* USES_ALLOC_TYPES_HPP */