Function trsTest

test/transpose.cpp:55–106

template<typename T>
void trsTest(string pTestFile, bool isSubRef = false,
             const vector<af_seq> *seqv = NULL) {
    SUPPORTED_TYPE_CHECK(T);

    vector<dim4> numDims;

    vector<vector<T>> in;
    vector<vector<T>> tests;
    readTests<T, T, int>(pTestFile, numDims, in, tests);
    dim4 dims = numDims[0];

    af_array outArray = 0;
    af_array inArray  = 0;
    T *outData;
    ASSERT_SUCCESS(af_create_array(&inArray, &(in[0].front()), dims.ndims(),
                                   dims.get(),
                                   (af_dtype)dtype_traits<T>::af_type));

    // check if the test is for indexed Array
    if (isSubRef) {
        dim4 newDims(dims[1] - 4, dims[0] - 4, dims[2], dims[3]);
        af_array subArray = 0;
        ASSERT_SUCCESS(
            af_index(&subArray, inArray, seqv->size(), &seqv->front()));
        ASSERT_SUCCESS(af_transpose(&outArray, subArray, false));
        // destroy the temporary indexed Array
        ASSERT_SUCCESS(af_release_array(subArray));

        dim_t nElems;
        ASSERT_SUCCESS(af_get_elements(&nElems, outArray));
        outData = new T[nElems];
    } else {
        ASSERT_SUCCESS(af_transpose(&outArray, inArray, false));
        outData = new T[dims.elements()];
    }

    ASSERT_SUCCESS(af_get_data_ptr((void *)outData, outArray));

    for (size_t testIter = 0; testIter < tests.size(); ++testIter) {
        vector<T> currGoldBar = tests[testIter];
        size_t nElems         = currGoldBar.size();
        for (size_t elIter = 0; elIter < nElems; ++elIter) {
            ASSERT_EQ(currGoldBar[elIter], outData[elIter])
                << "at: " << elIter << endl;
        }
    }

    // cleanup
    delete[] outData;
    ASSERT_SUCCESS(af_release_array(inArray));
    ASSERT_SUCCESS(af_release_array(outArray));
}

TYPED_TEST(Transpose, Vector) {
    trsTest<TypeParam>(string(TEST_DIR "/transpose/vector.test"));