Bug 1338389 - Tests for Variant's detail::Nth and detail::SelectVariantType - r=froydnj
authorGerald Squelart <gsquelart@mozilla.com>
Tue, 06 Jun 2017 16:59:00 +1200
changeset 410885 0dec1e86d314c086283c590c2db4d2758ac219d9
parent 410884 e84a5251008fa4f6fe22ac89314fd53f5f1dba04
child 410886 b92c5e65face5f8f9e687c388e246c2969b6483e
push id7391
push usermtabara@mozilla.com
push dateMon, 12 Jun 2017 13:08:53 +0000
treeherdermozilla-beta@2191d7f87e2e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1338389
milestone55.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1338389 - Tests for Variant's detail::Nth and detail::SelectVariantType - r=froydnj MozReview-Commit-ID: 4QXdctmhNze
mfbt/tests/TestVariant.cpp
--- a/mfbt/tests/TestVariant.cpp
+++ b/mfbt/tests/TestVariant.cpp
@@ -2,62 +2,274 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/UniquePtr.h"
 #include "mozilla/Variant.h"
 
+using mozilla::IsSame;
 using mozilla::MakeUnique;
 using mozilla::UniquePtr;
 using mozilla::Variant;
 
 struct Destroyer {
   static int destroyedCount;
   ~Destroyer() {
     destroyedCount++;
   }
 };
 
 int Destroyer::destroyedCount = 0;
 
 static void
+testDetails()
+{
+  printf("testDetails\n");
+
+  using mozilla::detail::Nth;
+
+  // Test Nth with a list of 1 item.
+  static_assert(IsSame<typename Nth<0, int>::Type, int>::value,
+                "Nth<0, int>::Type should be int");
+
+  // Test Nth with a list of more than 1 item.
+  static_assert(IsSame<typename Nth<0, int, char>::Type, int>::value,
+                "Nth<0, int, char>::Type should be int");
+  static_assert(IsSame<typename Nth<1, int, char>::Type, char>::value,
+                "Nth<1, int, char>::Type should be char");
+
+  using mozilla::detail::SelectVariantType;
+
+  // SelectVariantType for zero items (shouldn't happen, but `count` should
+  // still work ok.)
+  static_assert(SelectVariantType<int, char>::count == 0,
+                "SelectVariantType<int, char>::count should be 0");
+
+  // SelectVariantType for 1 type, for all combinations from/to T, const T,
+  // const T&, T&&
+  // - type to type
+  static_assert(IsSame<typename SelectVariantType<int, int>::Type, int>::value,
+                "SelectVariantType<int, int>::Type should be int");
+  static_assert(SelectVariantType<int, int>::count == 1,
+                "SelectVariantType<int, int>::count should be 1");
+
+  // - type to const type
+  static_assert(
+    IsSame<typename SelectVariantType<int, const int>::Type, const int>::value,
+    "SelectVariantType<int, const int>::Type should be const int");
+  static_assert(SelectVariantType<int, const int>::count == 1,
+                "SelectVariantType<int, const int>::count should be 1");
+
+  // - type to const type&
+  static_assert(
+    IsSame<typename SelectVariantType<int, const int&>::Type,
+           const int&>::value,
+    "SelectVariantType<int, const int&>::Type should be const int&");
+  static_assert(SelectVariantType<int, const int&>::count == 1,
+                "SelectVariantType<int, const int&>::count should be 1");
+
+  // - type to type&&
+  static_assert(
+    IsSame<typename SelectVariantType<int, int&&>::Type, int&&>::value,
+    "SelectVariantType<int, int&&>::Type should be int&&");
+  static_assert(SelectVariantType<int, int&&>::count == 1,
+                "SelectVariantType<int, int&&>::count should be 1");
+
+  // - const type to type
+  static_assert(
+    IsSame<typename SelectVariantType<const int, int>::Type, int>::value,
+    "SelectVariantType<const int, int>::Type should be int");
+  static_assert(SelectVariantType<const int, int>::count == 1,
+                "SelectVariantType<const int, int>::count should be 1");
+
+  // - const type to const type
+  static_assert(
+    IsSame<typename SelectVariantType<const int, const int>::Type,
+           const int>::value,
+    "SelectVariantType<const int, const int>::Type should be const int");
+  static_assert(SelectVariantType<const int, const int>::count == 1,
+                "SelectVariantType<const int, const int>::count should be 1");
+
+  // - const type to const type&
+  static_assert(
+    IsSame<typename SelectVariantType<const int, const int&>::Type,
+           const int&>::value,
+    "SelectVariantType<const int, const int&>::Type should be const int&");
+  static_assert(SelectVariantType<const int, const int&>::count == 1,
+                "SelectVariantType<const int, const int&>::count should be 1");
+
+  // - const type to type&&
+  static_assert(
+    IsSame<typename SelectVariantType<const int, int&&>::Type, int&&>::value,
+    "SelectVariantType<const int, int&&>::Type should be int&&");
+  static_assert(SelectVariantType<const int, int&&>::count == 1,
+                "SelectVariantType<const int, int&&>::count should be 1");
+
+  // - const type& to type
+  static_assert(
+    IsSame<typename SelectVariantType<const int&, int>::Type, int>::value,
+    "SelectVariantType<const int&, int>::Type should be int");
+  static_assert(SelectVariantType<const int&, int>::count == 1,
+                "SelectVariantType<const int&, int>::count should be 1");
+
+  // - const type& to const type
+  static_assert(
+    IsSame<typename SelectVariantType<const int&, const int>::Type,
+           const int>::value,
+    "SelectVariantType<const int&, const int>::Type should be const int");
+  static_assert(SelectVariantType<const int&, const int>::count == 1,
+                "SelectVariantType<const int&, const int>::count should be 1");
+
+  // - const type& to const type&
+  static_assert(
+    IsSame<typename SelectVariantType<const int&, const int&>::Type,
+           const int&>::value,
+    "SelectVariantType<const int&, const int&>::Type should be const int&");
+  static_assert(SelectVariantType<const int&, const int&>::count == 1,
+                "SelectVariantType<const int&, const int&>::count should be 1");
+
+  // - const type& to type&&
+  static_assert(
+    IsSame<typename SelectVariantType<const int&, int&&>::Type, int&&>::value,
+    "SelectVariantType<const int&, int&&>::Type should be int&&");
+  static_assert(SelectVariantType<const int&, int&&>::count == 1,
+                "SelectVariantType<const int&, int&&>::count should be 1");
+
+  // - type&& to type
+  static_assert(
+    IsSame<typename SelectVariantType<int&&, int>::Type, int>::value,
+    "SelectVariantType<int&&, int>::Type should be int");
+  static_assert(SelectVariantType<int&&, int>::count == 1,
+                "SelectVariantType<int&&, int>::count should be 1");
+
+  // - type&& to const type
+  static_assert(
+    IsSame<typename SelectVariantType<int&&, const int>::Type,
+           const int>::value,
+    "SelectVariantType<int&&, const int>::Type should be const int");
+  static_assert(SelectVariantType<int&&, const int>::count == 1,
+                "SelectVariantType<int&&, const int>::count should be 1");
+
+  // - type&& to const type&
+  static_assert(
+    IsSame<typename SelectVariantType<int&&, const int&>::Type,
+           const int&>::value,
+    "SelectVariantType<int&&, const int&>::Type should be const int&");
+  static_assert(SelectVariantType<int&&, const int&>::count == 1,
+                "SelectVariantType<int&&, const int&>::count should be 1");
+
+  // - type&& to type&&
+  static_assert(
+    IsSame<typename SelectVariantType<int&&, int&&>::Type, int&&>::value,
+    "SelectVariantType<int&&, int&&>::Type should be int&&");
+  static_assert(SelectVariantType<int&&, int&&>::count == 1,
+                "SelectVariantType<int&&, int&&>::count should be 1");
+
+  // SelectVariantType for two different types.
+  // (Don't test all combinations, trust that the above tests are sufficient.)
+  static_assert(
+    IsSame<typename SelectVariantType<int, int, char>::Type, int>::value,
+    "SelectVariantType<int, int, char>::Type should be int");
+  static_assert(SelectVariantType<int, int, char>::count == 1,
+                "SelectVariantType<int, int, char>::count should be 1");
+  static_assert(
+    IsSame<typename SelectVariantType<char, int, char>::Type, char>::value,
+    "SelectVariantType<char, int, char>::Type should be char");
+  static_assert(SelectVariantType<char, int, char>::count == 1,
+                "SelectVariantType<char, int, char>::count should be 1");
+
+  // SelectVariantType for two identical types.
+  static_assert(
+    IsSame<typename SelectVariantType<int, int, int>::Type, int>::value,
+    "SelectVariantType<int, int, int>::Type should be int");
+  static_assert(SelectVariantType<int, int, int>::count == 2,
+                "SelectVariantType<int, int, int>::count should be 2");
+
+  // SelectVariantType for two identical types, with others around.
+  static_assert(
+    IsSame<typename SelectVariantType<int, char, int, int>::Type, int>::value,
+    "SelectVariantType<int, char, int, int>::Type should be int");
+  static_assert(SelectVariantType<int, char, int, int>::count == 2,
+                "SelectVariantType<int, char, int, int>::count should be 2");
+
+  static_assert(
+    IsSame<typename SelectVariantType<int, int, char, int>::Type, int>::value,
+    "SelectVariantType<int, int, char, int>::Type should be int");
+  static_assert(SelectVariantType<int, int, char, int>::count == 2,
+                "SelectVariantType<int, int, char, int>::count should be 2");
+
+  static_assert(
+    IsSame<typename SelectVariantType<int, int, int, char>::Type, int>::value,
+    "SelectVariantType<int, int, int, char>::Type should be int");
+  static_assert(SelectVariantType<int, int, int, char>::count == 2,
+                "SelectVariantType<int, int, int, char>::count should be 2");
+
+  static_assert(
+    IsSame<typename SelectVariantType<int, char, int, char, int, char>::Type,
+           int>::value,
+    "SelectVariantType<int, char, int, char, int, char>::Type should be int");
+  static_assert(
+    SelectVariantType<int, char, int, char, int, char>::count == 2,
+    "SelectVariantType<int, char, int, char, int, char>::count should be 2");
+
+  // SelectVariantType for two identically-selectable types (first one wins!).
+  static_assert(
+    IsSame<typename SelectVariantType<int, int, const int>::Type, int>::value,
+    "SelectVariantType<int, int, const int>::Type should be int");
+  static_assert(SelectVariantType<int, int, const int>::count == 2,
+                "SelectVariantType<int, int, const int>::count should be 2");
+  static_assert(
+    IsSame<typename SelectVariantType<int, const int, int>::Type,
+           const int>::value,
+    "SelectVariantType<int, const int, int>::Type should be const int");
+  static_assert(SelectVariantType<int, const int, int>::count == 2,
+                "SelectVariantType<int, const int, int>::count should be 2");
+  static_assert(
+    IsSame<typename SelectVariantType<int, const int, int&&>::Type,
+           const int>::value,
+    "SelectVariantType<int, const int, int&&>::Type should be const int");
+  static_assert(SelectVariantType<int, const int, int&&>::count == 2,
+                "SelectVariantType<int, const int, int&&>::count should be 2");
+}
+
+static void
 testSimple()
 {
   printf("testSimple\n");
   Variant<uint32_t, uint64_t> v(uint64_t(1));
   MOZ_RELEASE_ASSERT(v.is<uint64_t>());
   MOZ_RELEASE_ASSERT(!v.is<uint32_t>());
   MOZ_RELEASE_ASSERT(v.as<uint64_t>() == 1);
 
   MOZ_RELEASE_ASSERT(v.is<1>());
   MOZ_RELEASE_ASSERT(!v.is<0>());
-  static_assert(mozilla::IsSame<decltype(v.as<1>()), uint64_t&>::value,
+  static_assert(IsSame<decltype(v.as<1>()), uint64_t&>::value,
                 "as<1>() should return a uint64_t");
   MOZ_RELEASE_ASSERT(v.as<1>() == 1);
 }
 
 static void
 testDuplicate()
 {
   printf("testDuplicate\n");
   Variant<uint32_t, uint64_t, uint32_t> v(uint64_t(1));
   MOZ_RELEASE_ASSERT(v.is<uint64_t>());
   MOZ_RELEASE_ASSERT(v.as<uint64_t>() == 1);
   // Note: uint32_t is not unique, so `v.is<uint32_t>()` is not allowed.
 
   MOZ_RELEASE_ASSERT(v.is<1>());
   MOZ_RELEASE_ASSERT(!v.is<0>());
   MOZ_RELEASE_ASSERT(!v.is<2>());
-  static_assert(mozilla::IsSame<decltype(v.as<0>()), uint32_t&>::value,
+  static_assert(IsSame<decltype(v.as<0>()), uint32_t&>::value,
                 "as<0>() should return a uint64_t");
-  static_assert(mozilla::IsSame<decltype(v.as<1>()), uint64_t&>::value,
+  static_assert(IsSame<decltype(v.as<1>()), uint64_t&>::value,
                 "as<1>() should return a uint64_t");
-  static_assert(mozilla::IsSame<decltype(v.as<2>()), uint32_t&>::value,
+  static_assert(IsSame<decltype(v.as<2>()), uint32_t&>::value,
                 "as<2>() should return a uint64_t");
   MOZ_RELEASE_ASSERT(v.as<1>() == 1);
   MOZ_RELEASE_ASSERT(v.extract<1>() == 1);
 }
 
 static void
 testConstructionWithVariantType()
 {
@@ -221,16 +433,17 @@ testRvalueMatcher()
   using V = Variant<uint8_t, uint32_t, uint64_t>;
   V v(uint8_t(1));
   MOZ_RELEASE_ASSERT(v.match(Describer()) == Describer::little);
 }
 
 int
 main()
 {
+  testDetails();
   testSimple();
   testDuplicate();
   testConstructionWithVariantType();
   testConstructionWithVariantIndex();
   testCopy();
   testMove();
   testDestructor();
   testEquality();