libcxx: Rename last two .hpp files in libcxx to .h

libcxx/trunk/test/std/input.output/filesystems/fs.enum/check_bitmask_types.h

+#ifndef TEST_BITMASK_TYPE_H
+#define TEST_BITMASK_TYPE_H
+
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+
+template <class EnumType, EnumType Val1, EnumType Val2,
+          class UT = typename std::underlying_type<EnumType>::type,
+          UT UVal1 = static_cast<UT>(Val1),
+          UT UVal2 = static_cast<UT>(Val2),
+          UT UZero = static_cast<UT>(0),
+          EnumType Zero = static_cast<EnumType>(0)
+        >
+struct check_bitmask_type {
+
+  static constexpr UT dcast(EnumType e) { return static_cast<UT>(e); }
+  static constexpr UT unpromote(decltype((~UZero)) promoted) { return static_cast<UT>(promoted); }
+  // We need two values that are non-zero and share at least one bit.
+  static_assert(Val1 != Zero && Val2 != Zero, "");
+  static_assert(Val1 != Val2, "");
+  static_assert((UVal1 & UVal2) == 0, "");
+
+
+  static bool check()
+  {
+    {
+      EnumType ValRef = Val1;
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 & Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 | Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 ^ Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype((~Val1)));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef &= Val2));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef |= Val2));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef ^= Val2));
+    }
+
+    static_assert((Val1 & Zero) == Zero, "");
+    static_assert((Val1 & Val1) == Val1, "");
+    static_assert(dcast(Val1 & Val2) == (UVal1 & UVal2), "");
+
+    static_assert((Val1 | Zero) == Val1, "");
+    static_assert(dcast(Val1 | Val2) == (UVal1 | UVal2), "");
+
+    static_assert((Val1 ^ Zero) == Val1, "");
+    static_assert(dcast(Val1 ^ Val2) == (UVal1 ^ UVal2), "");
+
+    static_assert(dcast(~Zero) == unpromote(~UZero), "");
+    static_assert(dcast(~Val1) == unpromote(~UVal1), "");
+
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e &= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 & UVal2));
+    }
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e |= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 | UVal2));
+    }
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e ^= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 ^ UVal2));
+    }
+    return true;
+  }
+};
+
+#endif // TEST_BITMASK_TYPE

libcxx/trunk/test/std/input.output/filesystems/fs.enum/check_bitmask_types.hpp

-#ifndef TEST_BITMASK_TYPE_HPP
-#define TEST_BITMASK_TYPE_HPP
-
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-
-template <class EnumType, EnumType Val1, EnumType Val2,
-          class UT = typename std::underlying_type<EnumType>::type,
-          UT UVal1 = static_cast<UT>(Val1),
-          UT UVal2 = static_cast<UT>(Val2),
-          UT UZero = static_cast<UT>(0),
-          EnumType Zero = static_cast<EnumType>(0)
-        >
-struct check_bitmask_type {
-
-  static constexpr UT dcast(EnumType e) { return static_cast<UT>(e); }
-  static constexpr UT unpromote(decltype((~UZero)) promoted) { return static_cast<UT>(promoted); }
-  // We need two values that are non-zero and share at least one bit.
-  static_assert(Val1 != Zero && Val2 != Zero, "");
-  static_assert(Val1 != Val2, "");
-  static_assert((UVal1 & UVal2) == 0, "");
-
-
-  static bool check()
-  {
-    {
-      EnumType ValRef = Val1;
-      ASSERT_SAME_TYPE(EnumType, decltype(Val1 & Val2));
-      ASSERT_SAME_TYPE(EnumType, decltype(Val1 | Val2));
-      ASSERT_SAME_TYPE(EnumType, decltype(Val1 ^ Val2));
-      ASSERT_SAME_TYPE(EnumType, decltype((~Val1)));
-      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef &= Val2));
-      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef |= Val2));
-      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef ^= Val2));
-    }
-
-    static_assert((Val1 & Zero) == Zero, "");
-    static_assert((Val1 & Val1) == Val1, "");
-    static_assert(dcast(Val1 & Val2) == (UVal1 & UVal2), "");
-
-    static_assert((Val1 | Zero) == Val1, "");
-    static_assert(dcast(Val1 | Val2) == (UVal1 | UVal2), "");
-
-    static_assert((Val1 ^ Zero) == Val1, "");
-    static_assert(dcast(Val1 ^ Val2) == (UVal1 ^ UVal2), "");
-
-    static_assert(dcast(~Zero) == unpromote(~UZero), "");
-    static_assert(dcast(~Val1) == unpromote(~UVal1), "");
-
-    {
-      EnumType e = Val1;
-      EnumType& eref = (e &= Val2);
-      assert(&eref == &e);
-      assert(dcast(eref) == (UVal1 & UVal2));
-    }
-    {
-      EnumType e = Val1;
-      EnumType& eref = (e |= Val2);
-      assert(&eref == &e);
-      assert(dcast(eref) == (UVal1 | UVal2));
-    }
-    {
-      EnumType e = Val1;
-      EnumType& eref = (e ^= Val2);
-      assert(&eref == &e);
-      assert(dcast(eref) == (UVal1 ^ UVal2));
-    }
-    return true;
-  }
-};
-
-#endif // TEST_BITMASK_TYPE

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp

 // <filesystem>
 
 // enum class copy_options;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
-#include "check_bitmask_types.hpp"
+#include "check_bitmask_types.h"
 #include "test_macros.h"
 
 
 constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); }
 
 int main(int, char**) {
   typedef fs::copy_options E;
   static_assert(std::is_enum<E>::value, "");

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp

 // enum class directory_options;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 #include <sys/stat.h>
 
 #include "test_macros.h"
-#include "check_bitmask_types.hpp"
+#include "check_bitmask_types.h"
 
 
 constexpr fs::directory_options ME(int val) { return static_cast<fs::directory_options>(val); }
 
 int main(int, char**) {
   typedef fs::directory_options E;
   static_assert(std::is_enum<E>::value, "");
 

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp

 // enum class perm_options;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 #include <sys/stat.h>
 
 #include "test_macros.h"
-#include "check_bitmask_types.hpp"
+#include "check_bitmask_types.h"
 
 
 constexpr fs::perm_options ME(int val) {
   return static_cast<fs::perm_options>(val);
 }
 
 int main(int, char**) {
   typedef fs::perm_options E;

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp

 // enum class perms;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 #include <sys/stat.h>
 
 #include "test_macros.h"
-#include "check_bitmask_types.hpp"
+#include "check_bitmask_types.h"
 
 
 constexpr fs::perms ME(int val) { return static_cast<fs::perms>(val); }
 
 int main(int, char**) {
   typedef fs::perms E;
   static_assert(std::is_enum<E>::value, "");
 

libcxx/trunk/test/std/utilities/function.objects/comparisons/greater.pass.cpp

 
 // greater
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "pointer_comparison_test_helper.hpp"
+#include "pointer_comparison_test_helper.h"
 
 int main(int, char**)
 {
     typedef std::greater<int> F;
     const F f = F();
     static_assert((std::is_same<int, F::first_argument_type>::value), "" );
     static_assert((std::is_same<int, F::second_argument_type>::value), "" );
     static_assert((std::is_same<bool, F::result_type>::value), "" );

libcxx/trunk/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp

 
 // greater_equal
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "pointer_comparison_test_helper.hpp"
+#include "pointer_comparison_test_helper.h"
 
 int main(int, char**)
 {
     typedef std::greater_equal<int> F;
     const F f = F();
     static_assert((std::is_same<int, F::first_argument_type>::value), "" );
     static_assert((std::is_same<int, F::second_argument_type>::value), "" );
     static_assert((std::is_same<bool, F::result_type>::value), "" );

libcxx/trunk/test/std/utilities/function.objects/comparisons/less.pass.cpp

 
 // less
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "pointer_comparison_test_helper.hpp"
+#include "pointer_comparison_test_helper.h"
 
 int main(int, char**)
 {
     typedef std::less<int> F;
     const F f = F();
     static_assert((std::is_same<int, F::first_argument_type>::value), "" );
     static_assert((std::is_same<int, F::second_argument_type>::value), "" );
     static_assert((std::is_same<bool, F::result_type>::value), "" );

libcxx/trunk/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp

 
 // less_equal
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "pointer_comparison_test_helper.hpp"
+#include "pointer_comparison_test_helper.h"
 
 int main(int, char**)
 {
     typedef std::less_equal<int> F;
     const F f = F();
     static_assert((std::is_same<int, F::first_argument_type>::value), "" );
     static_assert((std::is_same<int, F::second_argument_type>::value), "" );
     static_assert((std::is_same<bool, F::result_type>::value), "" );

libcxx/trunk/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.h

+#ifndef POINTER_COMPARISON_TEST_HELPER_H
+#define POINTER_COMPARISON_TEST_HELPER_H
+
+#include <vector>
+#include <memory>
+#include <cstdint>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T, template<class> class CompareTemplate>
+void do_pointer_comparison_test() {
+    typedef CompareTemplate<T*> Compare;
+    typedef CompareTemplate<std::uintptr_t> UIntCompare;
+#if TEST_STD_VER > 11
+    typedef CompareTemplate<void> VoidCompare;
+#else
+    typedef Compare VoidCompare;
+#endif
+    std::vector<std::shared_ptr<T> > pointers;
+    const std::size_t test_size = 100;
+    for (size_t i=0; i < test_size; ++i)
+        pointers.push_back(std::shared_ptr<T>(new T()));
+    Compare comp;
+    UIntCompare ucomp;
+    VoidCompare vcomp;
+    for (size_t i=0; i < test_size; ++i) {
+        for (size_t j=0; j < test_size; ++j) {
+            T* lhs = pointers[i].get();
+            T* rhs = pointers[j].get();
+            std::uintptr_t lhs_uint = reinterpret_cast<std::uintptr_t>(lhs);
+            std::uintptr_t rhs_uint = reinterpret_cast<std::uintptr_t>(rhs);
+            assert(comp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
+            assert(vcomp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
+        }
+    }
+}
+
+#endif // POINTER_COMPARISON_TEST_HELPER_H

libcxx/trunk/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp

-#ifndef POINTER_COMPARISON_TEST_HELPER_HPP
-#define POINTER_COMPARISON_TEST_HELPER_HPP
-
-#include <vector>
-#include <memory>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class T, template<class> class CompareTemplate>
-void do_pointer_comparison_test() {
-    typedef CompareTemplate<T*> Compare;
-    typedef CompareTemplate<std::uintptr_t> UIntCompare;
-#if TEST_STD_VER > 11
-    typedef CompareTemplate<void> VoidCompare;
-#else
-    typedef Compare VoidCompare;
-#endif
-    std::vector<std::shared_ptr<T> > pointers;
-    const std::size_t test_size = 100;
-    for (size_t i=0; i < test_size; ++i)
-        pointers.push_back(std::shared_ptr<T>(new T()));
-    Compare comp;
-    UIntCompare ucomp;
-    VoidCompare vcomp;
-    for (size_t i=0; i < test_size; ++i) {
-        for (size_t j=0; j < test_size; ++j) {
-            T* lhs = pointers[i].get();
-            T* rhs = pointers[j].get();
-            std::uintptr_t lhs_uint = reinterpret_cast<std::uintptr_t>(lhs);
-            std::uintptr_t rhs_uint = reinterpret_cast<std::uintptr_t>(rhs);
-            assert(comp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
-            assert(vcomp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
-        }
-    }
-}
-
-#endif // POINTER_COMPARISON_TEST_HELPER_HPP