Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 232 insertions, 0 deletions

diff --git a/mfbt/tests/TestFunctionTypeTraits.cpp b/mfbt/tests/TestFunctionTypeTraits.cpp
new file mode 100644
index 0000000000..eb9593fbbf
--- /dev/null
+++ b/mfbt/tests/TestFunctionTypeTraits.cpp
@@ -0,0 +1,232 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/FunctionTypeTraits.h"
+
+#include <functional>
+
+using mozilla::FunctionTypeTraits;
+
+void f0() {}
+
+int f1(char) { return 0; }
+
+#ifdef NS_HAVE_STDCALL
+void NS_STDCALL f0s() {}
+
+int NS_STDCALL f1s(char) { return 0; }
+#endif  // NS_HAVE_STDCALL
+
+struct S {
+  void f0() {}
+  void f0c() const {}
+  int f1(char) { return 0; }
+  int f1c(char) const { return 0; }
+#ifdef NS_HAVE_STDCALL
+  void NS_STDCALL f0s() {}
+  void NS_STDCALL f0cs() const {}
+  int NS_STDCALL f1s(char) { return 0; }
+  int NS_STDCALL f1cs(char) const { return 0; }
+#endif  // NS_HAVE_STDCALL
+};
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(f0)>::ReturnType,
+                 void>::value,
+    "f0 returns void");
+static_assert(FunctionTypeTraits<decltype(f0)>::arity == 0,
+              "f0 takes no parameters");
+static_assert(
+    std::is_same<
+        typename FunctionTypeTraits<decltype(f0)>::template ParameterType<0>,
+        void>::value,
+    "f0 has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f0)>::ReturnType,
+                 void>::value,
+    "S::f0 returns void");
+static_assert(FunctionTypeTraits<decltype(&S::f0)>::arity == 0,
+              "S::f0 takes no parameters");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f0)>::template ParameterType<0>,
+                           void>::value,
+              "S::f0 has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f0c)>::ReturnType,
+                 void>::value,
+    "S::f0c returns void");
+static_assert(FunctionTypeTraits<decltype(&S::f0c)>::arity == 0,
+              "S::f0c takes no parameters");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f0c)>::template ParameterType<0>,
+                           void>::value,
+              "S::f0c has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(f1)>::ReturnType,
+                 int>::value,
+    "f1 returns int");
+static_assert(FunctionTypeTraits<decltype(f1)>::arity == 1,
+              "f1 takes one parameter");
+static_assert(
+    std::is_same<
+        typename FunctionTypeTraits<decltype(f1)>::template ParameterType<0>,
+        char>::value,
+    "f1 takes a char");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f1)>::ReturnType,
+                 int>::value,
+    "S::f1 returns int");
+static_assert(FunctionTypeTraits<decltype(&S::f1)>::arity == 1,
+              "S::f1 takes one parameter");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f1)>::template ParameterType<0>,
+                           char>::value,
+              "S::f1 takes a char");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f1c)>::ReturnType,
+                 int>::value,
+    "S::f1c returns int");
+static_assert(FunctionTypeTraits<decltype(&S::f1c)>::arity == 1,
+              "S::f1c takes one parameter");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f1c)>::template ParameterType<0>,
+                           char>::value,
+              "S::f1c takes a char");
+
+#ifdef NS_HAVE_STDCALL
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(f0s)>::ReturnType,
+                 void>::value,
+    "f0s returns void");
+static_assert(FunctionTypeTraits<decltype(f0s)>::arity == 0,
+              "f0s takes no parameters");
+static_assert(
+    std::is_same<
+        typename FunctionTypeTraits<decltype(f0s)>::template ParameterType<0>,
+        void>::value,
+    "f0s has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f0s)>::ReturnType,
+                 void>::value,
+    "S::f0s returns void");
+static_assert(FunctionTypeTraits<decltype(&S::f0s)>::arity == 0,
+              "S::f0s takes no parameters");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f0s)>::template ParameterType<0>,
+                           void>::value,
+              "S::f0s has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f0cs)>::ReturnType,
+                 void>::value,
+    "S::f0cs returns void");
+static_assert(FunctionTypeTraits<decltype(&S::f0cs)>::arity == 0,
+              "S::f0cs takes no parameters");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f0cs)>::template ParameterType<0>,
+                           void>::value,
+              "S::f0cs has no first parameter");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(f1s)>::ReturnType,
+                 int>::value,
+    "f1s returns int");
+static_assert(FunctionTypeTraits<decltype(f1s)>::arity == 1,
+              "f1s takes one parameter");
+static_assert(
+    std::is_same<
+        typename FunctionTypeTraits<decltype(f1s)>::template ParameterType<0>,
+        char>::value,
+    "f1s takes a char");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f1s)>::ReturnType,
+                 int>::value,
+    "S::f1s returns int");
+static_assert(FunctionTypeTraits<decltype(&S::f1s)>::arity == 1,
+              "S::f1s takes one parameter");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f1s)>::template ParameterType<0>,
+                           char>::value,
+              "S::f1s takes a char");
+
+static_assert(
+    std::is_same<typename FunctionTypeTraits<decltype(&S::f1cs)>::ReturnType,
+                 int>::value,
+    "S::f1cs returns int");
+static_assert(FunctionTypeTraits<decltype(&S::f1cs)>::arity == 1,
+              "S::f1cs takes one parameter");
+static_assert(std::is_same<typename FunctionTypeTraits<
+                               decltype(&S::f1cs)>::template ParameterType<0>,
+                           char>::value,
+              "S::f1cs takes a char");
+#endif  // NS_HAVE_STDCALL
+
+template <typename F>
+void TestVoidVoid(F&&) {
+  static_assert(
+      std::is_same<typename FunctionTypeTraits<F>::ReturnType, void>::value,
+      "Should return void");
+  static_assert(FunctionTypeTraits<F>::arity == 0, "Should take no parameters");
+  static_assert(
+      std::is_same<typename FunctionTypeTraits<F>::template ParameterType<0>,
+                   void>::value,
+      "Should have no first parameter");
+}
+
+template <typename F>
+void TestIntChar(F&&) {
+  static_assert(
+      std::is_same<typename FunctionTypeTraits<F>::ReturnType, int>::value,
+      "Should return int");
+  static_assert(FunctionTypeTraits<F>::arity == 1, "Should take one parameter");
+  static_assert(
+      std::is_same<typename FunctionTypeTraits<F>::template ParameterType<0>,
+                   char>::value,
+      "Should take a char");
+}
+
+int main() {
+  TestVoidVoid(f0);
+  TestVoidVoid(&f0);
+  TestVoidVoid(&S::f0);
+  TestVoidVoid(&S::f0c);
+  TestVoidVoid([]() {});
+  std::function<void()> ff0 = f0;
+  TestVoidVoid(ff0);
+
+  TestIntChar(f1);
+  TestIntChar(&f1);
+  TestIntChar(&S::f1);
+  TestIntChar(&S::f1c);
+  TestIntChar([](char) { return 0; });
+  std::function<int(char)> ff1 = f1;
+  TestIntChar(ff1);
+
+#ifdef NS_HAVE_STDCALL
+  TestVoidVoid(f0s);
+  TestVoidVoid(&f0s);
+  TestVoidVoid(&S::f0s);
+  TestVoidVoid(&S::f0cs);
+  std::function<void()> ff0s = f0s;
+  TestVoidVoid(ff0s);
+
+  TestIntChar(f1s);
+  TestIntChar(&f1s);
+  TestIntChar(&S::f1s);
+  TestIntChar(&S::f1cs);
+  std::function<int(char)> ff1s = f1s;
+  TestIntChar(ff1s);
+#endif  // NS_HAVE_STDCALL
+
+  return 0;
+}