From 23426476da849e198e0b4b607430b8d6a81ea21c Mon Sep 17 00:00:00 2001
From: "E. G. Patrick Bos" <egpbos@gmail.com>
Date: Thu, 5 Oct 2017 16:03:30 +0200
Subject: [PATCH] Tried making gtest work with template types

Fails, because gtest uses typedef all over the place, which at some point breaks template compatibility. I guess already when defining MyTypes it fails, since there the template arguments of the "_front" classes are already lost. If that were done using an alias and the aliasing was propagated properly, it might work, but that would be a gtest overhaul.
---
 test/c2c_1D.cpp | 49 +++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/test/c2c_1D.cpp b/test/c2c_1D.cpp
index 9eb67d3..a2bdacc 100644
--- a/test/c2c_1D.cpp
+++ b/test/c2c_1D.cpp
@@ -12,6 +12,7 @@
 #include <iostream>
 #include <xtensor/xio.hpp>
 #include <xtensor/xrandom.hpp>
+#include <cmath> // pow
 
 #include <xtensor-fftw/fft.hpp>
 
@@ -20,11 +21,42 @@
 template <typename T>
 class TransformAndInvert : public ::testing::Test {};
 
-typedef ::testing::Types<float, double, long double> MyTypes;
+// Define a class that holds the two types we want to pass to our GoogleTest typed tests
+// (https://stackoverflow.com/a/29382470/1199693). The variadic template parameter `typename...`
+// is because `xarray` and `xtensor` have more template parameters than we care about here.
+template <template<typename /* precision */, std::size_t /* dim */, typename...> class _container, typename _precision>
+struct TDefs {
+  template<typename T, std::size_t dim> using container = _container<T, dim>;
+  using precision = _precision;
+};
+
+// make a uniform template interface for xarray and xtensor (where dim does nothing for xarray)
+template<typename precision, std::size_t dim> using xarray_front = xt::xarray<precision>;
+template<typename precision, std::size_t dim> using xtensor_front = xt::xtensor<precision, dim>;
+
+// the GoogleTest list of typed test cases
+typedef ::testing::Types<
+    TDefs<xarray_front, float>,
+    TDefs<xarray_front, double>,
+    TDefs<xarray_front, long double>,
+    TDefs<xtensor_front, float>,
+    TDefs<xtensor_front, double>,
+    TDefs<xtensor_front, long double>
+  > MyTypes;
 TYPED_TEST_CASE(TransformAndInvert, MyTypes);
 
-TYPED_TEST(TransformAndInvert, R2C_1D) {
-  xt::xarray<TypeParam> a = xt::random::rand<TypeParam>({8}, 0, std::numeric_limits<TypeParam>::max()/8);
+// forward declaration (definition below)
+template <typename T, size_t dim> auto generate_data(size_t n);
+std::size_t data_size = 4;
+
+TYPED_TEST(TransformAndInvert, R2C2R_1D) {
+  std::size_t dim = 1;
+
+  using precision = typename TypeParam::precision;
+  template <typename real_t, std::size_t dim> using container = class TypeParam::template container<real_t, dim>;
+//using container = typename TypeParam::template container;
+  // actual test logic
+  container<precision, dim> a = generate_data<precision, dim>(data_size);
 
   auto a_fourier = xt::fftw::fft(a);
 
@@ -34,4 +66,13 @@ TYPED_TEST(TransformAndInvert, R2C_1D) {
   std::cout << "fourier transform of input: " << a_fourier << std::endl;
   std::cout << "real output: " << should_be_a << std::endl;
   ASSERT_TRUE(xt::allclose(a, should_be_a));
-}
\ No newline at end of file
+}
+
+
+// Generates a dim-dimensional array of size n in each dimension, filled with random numbers between 0 and the numeric
+// limit of type T divided by pow(n, dim) (the latter to keep the FFTs from generating infs and nans).
+template <typename T, std::size_t dim>
+auto generate_data(std::size_t n) {
+  return xt::random::rand<T>(std::array<std::size_t, dim>().fill(n),
+                             0, std::numeric_limits<T>::max() / std::pow(n, dim));
+}