--- /dev/null	2017-03-07 11:44:12.271151064 +0100
+++ new/test/native/metaprogramming/test_integerTypes.cpp	2017-07-14 18:05:49.542232382 +0200
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "memory/allocation.hpp"
+#include "metaprogramming/integerTypes.hpp"
+#include "metaprogramming/isSame.hpp"
+#include "unittest.hpp"
+#include "utilities/debug.hpp"
+
+class IntegerTypesTest: AllStatic {
+  template <typename SignedType, typename UnsignedType>
+  class TestIntegers: AllStatic {
+    static const bool _cts_unsigned_type_is_signed_type = IsSame<typename IntegerTypes::Signed<UnsignedType>::type, SignedType>::value;
+    STATIC_ASSERT(_cts_unsigned_type_is_signed_type);
+    static const bool _ctu_signed_type_is_unsigned_type = IsSame<typename IntegerTypes::Unsigned<SignedType>::type, UnsignedType>::value;
+    STATIC_ASSERT(_ctu_signed_type_is_unsigned_type);
+  };
+
+  const TestIntegers<int8_t,  uint8_t>  TestByte;
+  const TestIntegers<int16_t, uint16_t> TestShort;
+  const TestIntegers<int32_t, uint32_t> TestInt;
+  const TestIntegers<int64_t, uint64_t> TestLong;
+
+  typedef IntegerTypes::Canonical<intptr_t>::type CanonicalIntPtr;
+  typedef IntegerTypes::Canonical<uintptr_t>::type CanonicalUIntPtr;
+
+  static const bool _cts_voidptr_is_intptrt = IsSame<IntegerTypes::Signed<void*>::type, CanonicalIntPtr>::value;
+  STATIC_ASSERT(_cts_voidptr_is_intptrt);
+  static const bool _ctu_voidptr_is_uintptrt = IsSame<IntegerTypes::Unsigned<void*>::type, CanonicalUIntPtr>::value;
+  STATIC_ASSERT(_ctu_voidptr_is_uintptrt);
+
+  class A VALUE_OBJ_CLASS_SPEC {
+    intptr_t _value;
+  public:
+    operator void* () { return reinterpret_cast<void*>(_value); }
+    A(void* arg) : _value(reinterpret_cast<intptr_t>(arg)) {}
+  };
+
+  static const bool _cts_cvptrcv_is_intptrt = IsSame<IntegerTypes::Signed<const volatile void* const volatile>::type, CanonicalIntPtr>::value;
+  STATIC_ASSERT(_cts_cvptrcv_is_intptrt);
+  static const bool _ctu_cvptrcv_is_uintptrt = IsSame<IntegerTypes::Unsigned<const volatile void* const volatile>::type, CanonicalUIntPtr>::value;
+  STATIC_ASSERT(_ctu_cvptrcv_is_uintptrt);
+
+  static const bool _cts_float_is_int = IsSame<IntegerTypes::Signed<float>::type, int32_t>::value;
+  STATIC_ASSERT(_cts_float_is_int);
+  static const bool _ctu_float_is_uint = IsSame<IntegerTypes::Unsigned<float>::type, uint32_t>::value;
+  STATIC_ASSERT(_ctu_float_is_uint);
+
+  static const bool _cts_double_is_long = IsSame<IntegerTypes::Signed<double>::type, int64_t>::value;
+  STATIC_ASSERT(_cts_double_is_long);
+  static const bool _ctu_double_is_ulong = IsSame<IntegerTypes::Unsigned<double>::type, uint64_t>::value;
+  STATIC_ASSERT(_ctu_double_is_ulong);
+
+  static void test_cast() {
+    (void)IntegerTypes::cast<void*>(intptr_t(0));
+    (void)IntegerTypes::cast<float>(int32_t(0));
+    (void)IntegerTypes::cast<double>(int64_t(0));
+    (void)IntegerTypes::cast<int64_t>(int64_t(0));
+  }
+};
+
+TEST(IntegerTypesRTest, round_trip_int) {
+  int  sfive = 5;
+  int  mfive = -5;
+  uint ufive = 5u;
+
+  EXPECT_EQ(sfive, IntegerTypes::cast<int>(IntegerTypes::cast_to_signed(sfive)));
+  EXPECT_EQ(sfive, IntegerTypes::cast<int>(IntegerTypes::cast_to_unsigned(sfive)));
+
+  EXPECT_EQ(mfive, IntegerTypes::cast<int>(IntegerTypes::cast_to_signed(mfive)));
+  EXPECT_EQ(mfive, IntegerTypes::cast<int>(IntegerTypes::cast_to_unsigned(mfive)));
+
+  EXPECT_EQ(ufive, IntegerTypes::cast<uint>(IntegerTypes::cast_to_signed(ufive)));
+  EXPECT_EQ(ufive, IntegerTypes::cast<uint>(IntegerTypes::cast_to_unsigned(ufive)));
+}
+
+TEST(IntegerTypesRTest, round_trip_float) {
+  float  ffive = 5.0f;
+  double dfive = 5.0;
+
+  EXPECT_EQ(ffive, IntegerTypes::cast<float>(IntegerTypes::cast_to_signed(ffive)));
+  EXPECT_EQ(ffive, IntegerTypes::cast<float>(IntegerTypes::cast_to_unsigned(ffive)));
+
+  EXPECT_EQ(dfive, IntegerTypes::cast<double>(IntegerTypes::cast_to_signed(dfive)));
+  EXPECT_EQ(dfive, IntegerTypes::cast<double>(IntegerTypes::cast_to_unsigned(dfive)));
+}
+
+TEST(IntegerTypesRTest, round_trip_ptr) {
+  int five = 5;
+  int* pfive = &five;
+  const int* cpfive = &five;
+
+  EXPECT_EQ(pfive, IntegerTypes::cast<int*>(IntegerTypes::cast_to_signed(pfive)));
+  EXPECT_EQ(pfive, IntegerTypes::cast<int*>(IntegerTypes::cast_to_unsigned(pfive)));
+
+  EXPECT_EQ(cpfive, IntegerTypes::cast<const int*>(IntegerTypes::cast_to_signed(cpfive)));
+  EXPECT_EQ(cpfive, IntegerTypes::cast<const int*>(IntegerTypes::cast_to_unsigned(cpfive)));
+}