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

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

-#ifndef TEST_BITMASK_TYPE_HPP
-#define TEST_BITMASK_TYPE_HPP
+#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,

libcxx/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/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/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/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/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/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/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/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/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.h

-#ifndef POINTER_COMPARISON_TEST_HELPER_HPP
-#define POINTER_COMPARISON_TEST_HELPER_HPP
+#ifndef POINTER_COMPARISON_TEST_HELPER_H
+#define POINTER_COMPARISON_TEST_HELPER_H
 
 #include <vector>
 #include <memory>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
for (size_t i=0; i < test_size; ++i) {
             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
+#endif // POINTER_COMPARISON_TEST_HELPER_H