[clfft] 101/128: Adding radix 7 test cases.

[Ghislain Vaillant]

This is an automated email from the git hooks/post-receive script.

ghisvail-guest pushed a commit to branch master
in repository clfft.

commit bb9cb39a531c1d8945a7e2e6208314a0293c6ea7
Author: santanu-thangaraj <t.santanu at gmail.com>
Date:   Fri Oct 9 09:17:26 2015 +0530

    Adding radix 7 test cases.
---
 src/tests/CMakeLists.txt         |    1 +
 src/tests/accuracy_test_pow7.cpp | 7356 ++++++++++++++++++++++++++++++++++++++
 src/tests/test_constants.h       |    7 +
 3 files changed, 7364 insertions(+)

diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 5dd237c..87c333c 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -25,6 +25,7 @@ set( clFFT.Test.Source
 	 accuracy_test_pow2.cpp
 	 accuracy_test_pow3.cpp
 	 accuracy_test_pow5.cpp
+	 accuracy_test_pow7.cpp
 	 accuracy_test_mixed_radices.cpp
 	 accuracy_test_random.cpp
 	 accuracy_test_mixed_precallback.cpp
diff --git a/src/tests/accuracy_test_pow7.cpp b/src/tests/accuracy_test_pow7.cpp
new file mode 100644
index 0000000..ca14282
--- /dev/null
+++ b/src/tests/accuracy_test_pow7.cpp
@@ -0,0 +1,7356 @@
+/* ************************************************************************
+* Copyright 2013 Advanced Micro Devices, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+* ************************************************************************/
+
+
+#include <gtest/gtest.h>
+#include<math.h>
+
+#include "test_constants.h"
+#include "fftw_transform.h"
+#include "cl_transform.h"
+#include "typedefs.h"
+#include "accuracy_test_common.h"
+#include <stdexcept>
+#include <vector>
+
+/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
+/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
+class accuracy_test_pow7_single : public ::testing::Test {
+protected:
+    accuracy_test_pow7_single() {}
+    virtual ~accuracy_test_pow7_single() {}
+    virtual void SetUp() {}
+    virtual void TearDown() {
+    }
+};
+
+/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
+/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
+class accuracy_test_pow7_double : public ::testing::Test {
+protected:
+    accuracy_test_pow7_double() {}
+    virtual ~accuracy_test_pow7_double() {}
+    virtual void SetUp() {}
+    virtual void TearDown() {
+    }
+};
+
+namespace power7
+{
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ normal 1D ^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ small 1D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ large 1D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ normal 2D ^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ small 2D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ large 2D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(MaxLength2D<T>(7));
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ normal 3D ^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { normal_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { normal_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { normal_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { normal_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { normal_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { normal_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_3D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { normal_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ small 3D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { small_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { small_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { small_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { small_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { small_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { small_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { small_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { small_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, _small_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, _small_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { small_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ large 3D ^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_in_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_in_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_out_of_place_complex_planar_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_out_of_place_complex_planar_to_complex_planar)
+    {
+        try { large_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
+    {
+        try { large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(3);
+        lengths.push_back(3);
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
+    {
+        try { large_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(3);
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
+    {
+        try { large_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_in_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(3);
+        lengths.push_back(3);
+        lengths.push_back(large7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_in_place_real_to_hermitian_interleaved)
+    {
+        try { large_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_in_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_in_place_hermitian_interleaved_to_real)
+    {
+        try { large_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_out_of_place_real_to_hermitian_interleaved()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_out_of_place_real_to_hermitian_interleaved)
+    {
+        try { large_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_out_of_place_hermitian_interleaved_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_out_of_place_hermitian_interleaved_to_real)
+    {
+        try { large_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_out_of_place_real_to_hermitian_planar()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_out_of_place_real_to_hermitian_planar)
+    {
+        try { large_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_3D_out_of_place_hermitian_planar_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(3);
+        lengths.push_back(large7);
+        lengths.push_back(3);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_3D_out_of_place_hermitian_planar_to_real)
+    {
+        try { large_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^ special ^^^^^^^^^^^^^^^^^^^^^^^^ //
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_complex_to_complex)
+    {
+        try { normal_1D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_complex_to_complex)
+    {
+        try { normal_1D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_complex_to_complex_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_complex_to_complex_with_odd_batch_size)
+    {
+        try { normal_1D_array_complex_to_complex_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_complex_to_complex_with_odd_batch_size)
+    {
+        try { normal_1D_array_complex_to_complex_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_real_to_hermitian)
+    {
+        try { normal_1D_array_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_real_to_hermitian)
+    {
+        try { normal_1D_array_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_real_to_hermitian_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_real_to_hermitian_with_odd_batch_size)
+    {
+        try { normal_1D_array_real_to_hermitian_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_real_to_hermitian_with_odd_batch_size)
+    {
+        try { normal_1D_array_real_to_hermitian_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_hermitian_to_real)
+    {
+        try { normal_1D_array_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_hermitian_to_real)
+    {
+        try { normal_1D_array_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_array_hermitian_to_real_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_array_hermitian_to_real_with_odd_batch_size)
+    {
+        try { normal_1D_array_hermitian_to_real_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_array_hermitian_to_real_with_odd_batch_size)
+    {
+        try { normal_1D_array_hermitian_to_real_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_array_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_array_real_to_hermitian)
+    {
+        try { small_2D_array_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_array_real_to_hermitian)
+    {
+        try { small_2D_array_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_array_real_to_hermitian_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_array_real_to_hermitian_with_odd_batch_size)
+    {
+        try { small_2D_array_real_to_hermitian_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_array_real_to_hermitian_with_odd_batch_size)
+    {
+        try { small_2D_array_real_to_hermitian_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_array_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_array_hermitian_to_real)
+    {
+        try { small_2D_array_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_array_hermitian_to_real)
+    {
+        try { small_2D_array_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_array_hermitian_to_real_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_array_hermitian_to_real_with_odd_batch_size)
+    {
+        try { small_2D_array_hermitian_to_real_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_array_hermitian_to_real_with_odd_batch_size)
+    {
+        try { small_2D_array_hermitian_to_real_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_array_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_array_complex_to_complex)
+    {
+        try { large_1D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_array_complex_to_complex)
+    {
+        try { large_1D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void astoundingly_large_1D_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(2187);
+        size_t batch = 65536;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, DISABLED_astoundingly_large_1D_complex_to_complex)
+    {
+        try { astoundingly_large_1D_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, DISABLED_astoundingly_large_1D_complex_to_complex)
+    {
+        try { astoundingly_large_1D_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_non_unit_stride_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_non_unit_stride_complex_to_complex)
+    {
+        try { very_small_1D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_non_unit_stride_complex_to_complex)
+    {
+        try { very_small_1D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_non_unit_stride_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_1D_non_unit_stride_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_non_unit_stride_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(27);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { very_small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { very_small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_non_unit_stride_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(27);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { very_small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { very_small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_very_small_1D_non_unit_stride_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = impulse;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_very_small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { very_very_small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_very_small_1D_non_unit_stride_real_to_hermitian)
+    {
+        try { very_very_small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_very_small_1D_non_unit_stride_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = impulse;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_very_small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { very_very_small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_very_small_1D_non_unit_stride_hermitian_to_real)
+    {
+        try { very_very_small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_non_unit_stride_and_distance_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(42);
+        output_strides.push_back(42);
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 14;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 14;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { normal_1D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { normal_1D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_non_unit_stride_and_distance_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(2);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 2;
+
+        std::vector<size_t> output_strides(input_strides);
+        size_t output_distance = input_distance;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = impulse;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(16);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 128;
+
+        std::vector<size_t> output_strides;
+        output_strides.push_back(2);
+
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 2;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = impulse;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(16);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 128;
+
+        std::vector<size_t> output_strides;
+        output_strides.push_back(2);
+
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 2;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+
+        data_pattern pattern = impulse;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+    {
+        try { very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_forward_user_defined_scale_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.0f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_forward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_1D_forward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_forward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_1D_forward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_backward_user_defined_scale_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.5f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_backward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_1D_backward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_backward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_1D_backward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_non_unit_stride_and_distance_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(42);
+        output_strides.push_back(42);
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 14;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 14;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_non_unit_stride_and_distance_real_to_hermitian)
+    {
+        try { normal_1D_non_unit_stride_and_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_non_unit_stride_and_distance_real_to_hermitian)
+    {
+        try { normal_1D_non_unit_stride_and_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_user_defined_scale_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = impulse;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness, 42.0f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_user_defined_scale_real_to_hermitian)
+    {
+        try { normal_1D_user_defined_scale_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_user_defined_scale_real_to_hermitian)
+    {
+        try { normal_1D_user_defined_scale_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_non_unit_stride_and_distance_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(42);
+        output_strides.push_back(42);
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 14;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 14;
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_non_unit_stride_and_distance_hermitian_to_real)
+    {
+        try { normal_1D_non_unit_stride_and_distance_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_non_unit_stride_and_distance_hermitian_to_real)
+    {
+        try { normal_1D_non_unit_stride_and_distance_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_stride_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(5);
+        input_strides.push_back(lengths[0] * input_strides[0] + 1);
+
+        std::vector<size_t> output_strides;
+        output_strides.push_back(2);
+        output_strides.push_back(lengths[0] * output_strides[0] + 2);
+
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_stride_real_to_hermitian)
+    {
+        try { small_2D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_stride_real_to_hermitian)
+    {
+        try { small_2D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_distance_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+
+        size_t input_distance = lengths[0] * lengths[1] + 4;
+        size_t output_distance = lengths[0] * lengths[1] + 5;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_distance_real_to_hermitian)
+    {
+        try { small_2D_non_unit_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_distance_real_to_hermitian)
+    {
+        try { small_2D_non_unit_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_stride_and_distance_real_to_hermitian()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(5);
+        input_strides.push_back(lengths[0] * input_strides[0] + 1);
+
+        std::vector<size_t> output_strides;
+        output_strides.push_back(2);
+        output_strides.push_back(lengths[0] * output_strides[0] + 2);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 30;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 42;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        real_to_complex<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_stride_and_distance_real_to_hermitian)
+    {
+        try { small_2D_non_unit_stride_and_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_stride_and_distance_real_to_hermitian)
+    {
+        try { small_2D_non_unit_stride_and_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_stride_and_distance_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(9);
+        lengths.push_back(9);
+        size_t batch = 2;
+
+        std::vector<size_t> input_strides;
+        input_strides.push_back(12);
+        input_strides.push_back(lengths[0] * input_strides[0] + 9);
+
+        std::vector<size_t> output_strides;
+        output_strides.push_back(7);
+        output_strides.push_back(lengths[0] * output_strides[0] + 32);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 50;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 60;
+
+        layout::buffer_layout_t layout = layout::hermitian_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_stride_and_distance_hermitian_to_real)
+    {
+        try { small_2D_non_unit_stride_and_distance_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_stride_and_distance_hermitian_to_real)
+    {
+        try { small_2D_non_unit_stride_and_distance_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_user_defined_scale_hermitian_to_real()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t layout = layout::hermitian_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+
+        data_pattern pattern = sawtooth;
+        complex_to_real<T, cl_T, fftw_T>(pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness, 42.0f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_user_defined_scale_hermitian_to_real)
+    {
+        try { normal_1D_user_defined_scale_hermitian_to_real< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_user_defined_scale_hermitian_to_real)
+    {
+        try { normal_1D_user_defined_scale_hermitian_to_real< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_1D_forward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_1D_forward_complex_to_complex)
+    {
+        try { single_point_1D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_1D_forward_complex_to_complex)
+    {
+        try { single_point_1D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_1D_backward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_1D_backward_complex_to_complex)
+    {
+        try { single_point_1D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_1D_backward_complex_to_complex)
+    {
+        try { single_point_1D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_stride_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(3);
+        output_strides.push_back(3);
+        input_strides.push_back(lengths[0] * input_strides[0] + 20);
+        output_strides.push_back(lengths[0] * output_strides[0] + 20);
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_stride_complex_to_complex)
+    {
+        try { small_2D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_stride_complex_to_complex)
+    {
+        try { small_2D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_2D_non_unit_stride_and_distance_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        input_strides.push_back(42);
+        output_strides.push_back(42);
+        input_strides.push_back(lengths[0] * input_strides[0] + 19);
+        output_strides.push_back(lengths[0] * output_strides[0] + 19);
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 14;
+        size_t output_distance = lengths[lengths.size() - 1] * output_strides[output_strides.size() - 1] + 14;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_2D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { small_2D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_2D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { small_2D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_forward_user_defined_scale_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.0f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_forward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_2D_forward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_forward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_2D_forward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_backward_user_defined_scale_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.5f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_backward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_2D_backward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_backward_user_defined_scale_complex_to_complex)
+    {
+        try { normal_2D_backward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void rectangular_2D_array_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(normal7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, rectangular_2D_array_complex_to_complex)
+    {
+        try { rectangular_2D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, rectangular_2D_array_complex_to_complex)
+    {
+        try { rectangular_2D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_array_complex_to_complex_with_odd_batch_size()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(small7);
+        size_t batch = 5;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_array_complex_to_complex_with_odd_batch_size)
+    {
+        try { normal_2D_array_complex_to_complex_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_array_complex_to_complex_with_odd_batch_size)
+    {
+        try { normal_2D_array_complex_to_complex_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_array_forward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(large7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_array_forward_complex_to_complex)
+    {
+        try { large_2D_array_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_array_forward_complex_to_complex)
+    {
+        try { large_2D_array_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_2D_array_backward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(large7);
+        size_t batch = 8;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::in_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_2D_array_backward_complex_to_complex)
+    {
+        try { large_2D_array_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_2D_array_backward_complex_to_complex)
+    {
+        try { large_2D_array_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_2D_forward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_2D_forward_complex_to_complex)
+    {
+        try { single_point_2D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_2D_forward_complex_to_complex)
+    {
+        try { single_point_2D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_2D_backward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_2D_backward_complex_to_complex)
+    {
+        try { single_point_2D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_2D_backward_complex_to_complex)
+    {
+        try { single_point_2D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_3D_forward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        lengths.push_back(1);
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_3D_forward_complex_to_complex)
+    {
+        try { single_point_3D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_3D_forward_complex_to_complex)
+    {
+        try { single_point_3D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void single_point_3D_backward_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(1);
+        lengths.push_back(1);
+        lengths.push_back(1);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        std::vector<size_t> output_strides;
+        size_t input_distance = 0;
+        size_t output_distance = 0;
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::backward;
+
+        data_pattern pattern = impulse;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f);
+    }
+
+    TEST_F(accuracy_test_pow7_single, single_point_3D_backward_complex_to_complex)
+    {
+        try { single_point_3D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, single_point_3D_backward_complex_to_complex)
+    {
+        try { single_point_3D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_non_unit_stride_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        std::vector<size_t> input_strides;
+        input_strides.push_back(2);
+        input_strides.push_back(lengths[0] * input_strides[0] + 20);
+        input_strides.push_back(lengths[1] * input_strides[1] + 17);
+
+        std::vector<size_t> output_strides(input_strides);
+
+        size_t input_distance = 0;
+        size_t output_distance = input_distance;
+
+        layout::buffer_layout_t in_layout = layout::complex_planar;
+        layout::buffer_layout_t out_layout = layout::complex_interleaved;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_non_unit_stride_complex_to_complex)
+    {
+        try { small_3D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_non_unit_stride_complex_to_complex)
+    {
+        try { small_3D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_non_unit_stride_and_distance_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 2;
+        std::vector<size_t> input_strides;
+        input_strides.push_back(2);
+        input_strides.push_back(lengths[0] * input_strides[0] + 19);
+        input_strides.push_back(lengths[1] * input_strides[1] + 3);
+
+        size_t input_distance = lengths[lengths.size() - 1] * input_strides[input_strides.size() - 1] + 14;
+
+        std::vector<size_t> output_strides(input_strides);
+        size_t output_distance = input_distance;
+
+        layout::buffer_layout_t in_layout = layout::complex_interleaved;
+        layout::buffer_layout_t out_layout = layout::complex_planar;
+        placeness::placeness_t placeness = placeness::out_of_place;
+        direction::direction_t direction = direction::forward;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { small_3D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_non_unit_stride_and_distance_complex_to_complex)
+    {
+        try { small_3D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_round_trip_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        layout::buffer_layout_t layout = layout::complex_interleaved;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch, layout);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_round_trip_complex_to_complex)
+    {
+        try { normal_1D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_round_trip_complex_to_complex)
+    {
+        try { normal_1D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_round_trip_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+        layout::buffer_layout_t layout = layout::complex_planar;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch, layout);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_round_trip_complex_to_complex)
+    {
+        try { normal_2D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_round_trip_complex_to_complex)
+    {
+        try { normal_2D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_round_trip_complex_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+        layout::buffer_layout_t layout = layout::complex_planar;
+
+        data_pattern pattern = sawtooth;
+        complex_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch, layout);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_round_trip_complex_to_complex)
+    {
+        try { small_3D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_round_trip_complex_to_complex)
+    {
+        try { small_3D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_1D_round_trip_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        size_t batch = 1;
+
+        data_pattern pattern = impulse;
+        real_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_1D_round_trip_real_to_complex)
+    {
+        try { normal_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_1D_round_trip_real_to_complex)
+    {
+        try { normal_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void large_1D_round_trip_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(large7);
+        size_t batch = 1;
+
+        data_pattern pattern = impulse;
+        real_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch);
+    }
+
+    TEST_F(accuracy_test_pow7_single, large_1D_round_trip_real_to_complex)
+    {
+        try { large_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, large_1D_round_trip_real_to_complex)
+    {
+        try { large_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void normal_2D_round_trip_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(normal7);
+        lengths.push_back(normal7);
+        size_t batch = 1;
+
+        data_pattern pattern = impulse;
+        real_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch);
+    }
+
+    TEST_F(accuracy_test_pow7_single, normal_2D_round_trip_real_to_complex)
+    {
+        try { normal_2D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, normal_2D_round_trip_real_to_complex)
+    {
+        try { normal_2D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    // *****************************************************
+    // *****************************************************
+    template< class T, class cl_T, class fftw_T >
+    void small_3D_round_trip_real_to_complex()
+    {
+        std::vector<size_t> lengths;
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        lengths.push_back(small7);
+        size_t batch = 1;
+
+        data_pattern pattern = impulse;
+        real_to_complex_round_trip<T, cl_T, fftw_T>(pattern, lengths, batch);
+    }
+
+    TEST_F(accuracy_test_pow7_single, small_3D_round_trip_real_to_complex)
+    {
+        try { small_3D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+    TEST_F(accuracy_test_pow7_double, small_3D_round_trip_real_to_complex)
+    {
+        try { small_3D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+        catch (const std::exception& err) { handle_exception(err); }
+    }
+
+} //namespace
diff --git a/src/tests/test_constants.h b/src/tests/test_constants.h
index a83e3f7..e16a2fe 100644
--- a/src/tests/test_constants.h
+++ b/src/tests/test_constants.h
@@ -134,6 +134,11 @@ const size_t normal5 = 625;
 const size_t large5 = 15625;
 const size_t dlarge5 = 3125;
 
+const size_t small7 = 49;
+const size_t normal7 = 2401;
+const size_t large7 = 16807;
+const size_t dlarge7 = 2401;
+
 const size_t large_batch_size = 2048;
 const size_t do_not_output_any_mismatches = 0;
 const size_t default_number_of_mismatches_to_output = 10;
@@ -172,6 +177,7 @@ inline size_t MaxLength2D<float>(size_t rad)
 	case 2:		return large2;
 	case 3:		return large3;
 	case 5:		return large5;
+    case 7:		return large7;
 	default:	return 0;
 	}
 }
@@ -184,6 +190,7 @@ inline size_t MaxLength2D<double>(size_t rad)
 	case 2:		return dlarge2;
 	case 3:		return dlarge3;
 	case 5:		return dlarge5;
+    case 7:		return dlarge7;
 	default:	return 0;
 	}
 }

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/clfft.git