func-error.cpp | searchcode

/src/tests/functional/func-error.cpp

https://github.com/jinhou/clBLAS
C++ | 1354 lines | 1095 code | 224 blank | 35 comment | 44 complexity | 89b4cef0486c093a07d85744daad4a1b MD5 | raw file
Possible License(s): Apache-2.0

/* ************************************************************************
 * 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 <clBLAS.h>
#include "blas-wrapper.h"
#include "clBLAS-wrapper.h"
#include "BlasBase.h"
#include "blas-random.h"
#include "timer.h"
#include "func.h"



template <typename M>
class ErrorClass
{
    M metod;
protected:
    bool generateData();
public:
    void error(cl_int err_etalon);
//    nano_time_t runRepeat(int rep, cl_int* err);
};

template <typename T> bool
ErrorClass<T>::generateData()
{
    metod.generateData();
    bool ret = metod.prepareDataToRun();

    if (!ret) {
        ::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
            << ::std::endl
            << ">> Can't execute the test, because data is not transfered to GPU."
            << ::std::endl
            << ">> Test skipped." << ::std::endl;
        SUCCEED();
    }
    return ret;
}

template <typename M> void
ErrorClass<M>::error(cl_int err_etalon)
{
    metod.initDefault(1024, 1);
    cl_command_queue queues = metod.queues[0];
    if (generateData()) {
        switch (err_etalon) {
        case CL_INVALID_EVENT_WAIT_LIST:
            metod.inEvent = NULL;
            metod.inEventCount = 1;
            break;
        case CL_INVALID_EVENT:
            metod.outEvent = NULL;
            metod.inEventCount = 1;
            break;
            case CL_INVALID_CONTEXT:
            clReleaseContext(metod.context);
            break;
        case CL_INVALID_COMMAND_QUEUE:
            metod.queues[0] = NULL;
            break;
        case clblasInvalidMatA:
        case clblasInvalidVecX:
        case CL_INVALID_MEM_OBJECT:
            metod.bufA = NULL;
            metod.bufAP = NULL;
            metod.bufX = NULL;
            metod.bufY = NULL;
            break;
        case CL_INVALID_DEVICE:
            break;
        case clblasInsufficientMemMatA:
        case clblasInsufficientMemMatB:
        case clblasInsufficientMemVecX:
        case CL_INVALID_VALUE:
			metod.size = 2048;
            //metod.bufA = NULL;
            break;
        default:
            FAIL() << "Unknown Error cod " << err_etalon;
        }

        cl_int err = metod.run();

	    metod.queues[0] = queues;

        ASSERT_EQ(err, err_etalon) << "clFinish()";

    }
    metod.destroy();
}

#ifdef DO_THEIRS
// Instantiate the test
TEST(ERROR, InvalidCommandQueue) {
    ErrorClass<GemmMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitList) {
    ErrorClass<GemmMetod<float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObject) {
    ErrorClass<GemmMetod<float> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValue) {
    ErrorClass<GemmMetod<float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevice) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<GemmMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}

// Instantiate the test
#endif

#ifdef DO_TRMV
TEST(ERROR, InvalidCommandQueuetrmv) {
    ErrorClass<TrmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListtrmv) {
    ErrorClass<TrmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecttrmv) {
    ErrorClass<TrmvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuetrmv) {
    ErrorClass<TrmvMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicetrmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
	ErrorClass<TrmvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_TRSV
TEST(ERROR, InvalidCommandQueue_trsv) {
    ErrorClass<TrsvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitList_trsv) {
    ErrorClass<TrsvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObject_trsv) {
    ErrorClass<TrsvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValue_trsv) {
    ErrorClass<TrsvMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevice_trsv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<TrsvMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_TPSV
TEST(ERROR, InvalidCommandQueue_tpsv) {
    ErrorClass<TpsvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitList_tpsv) {
    ErrorClass<TpsvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObject_tpsv) {
    ErrorClass<TpsvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValue_tpsv) {
    ErrorClass<TpsvMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevice_tpsv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<TpsvMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_TPMV
TEST(ERROR, InvalidCommandQueue_tpmv) {
    ErrorClass<TpmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitList_tpmv) {
    ErrorClass<TpmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObject_tpmv) {
    ErrorClass<TpmvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValue_tpmv) {
    ErrorClass<TpmvMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevice_tpmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<TpmvMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_SYMM
TEST(ERROR, InvalidCommandQueuesymm) {
    ErrorClass<SymmMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListsymm) {
    ErrorClass<SymmMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectsymm) {
    ErrorClass<SymmMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuesymm) {
    ErrorClass<SymmMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatB);
}

TEST(ERROR, InvalidDevicesymm) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SymmMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SYR
TEST(ERROR, InvalidCommandQueuesyr) {
    ErrorClass<SyrMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListsyr) {
    ErrorClass<SyrMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectsyr) {
    ErrorClass<SyrMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuesyr) {
    ErrorClass<SyrMetod<cl_float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicesyr) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SyrMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SPR
TEST(ERROR, InvalidCommandQueuespr) {
    ErrorClass<SprMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListspr) {
    ErrorClass<SprMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectspr) {
    ErrorClass<SprMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuespr) {
    ErrorClass<SprMetod<cl_float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicespr) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SprMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_SYR2
TEST(ERROR, InvalidCommandQueuesyr2) {
    ErrorClass<Syr2Metod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListsyr2) {
    ErrorClass<Syr2Metod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectsyr2) {
    ErrorClass<Syr2Metod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuesyr2) {
    ErrorClass<Syr2Metod<cl_float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicesyr2) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Syr2Metod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_GER
TEST(ERROR, InvalidCommandQueueger) {
    ErrorClass<GerMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListger) {
    ErrorClass<GerMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectger) {
    ErrorClass<GerMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValueger) {
    ErrorClass<GerMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceger) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<GerMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_GERC
TEST(ERROR, InvalidCommandQueuegerc) {
    ErrorClass<GercMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListgerc) {
    ErrorClass<GercMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectgerc) {
    ErrorClass<GercMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuegerc) {
    ErrorClass<GercMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicegerc) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
        ErrorClass<GercMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_HER
TEST(ERROR, InvalidCommandQueueher) {
    ErrorClass<HerMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListher) {
    ErrorClass<HerMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecther) {
    ErrorClass<HerMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueher) {

    ErrorClass<HerMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceher) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HerMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HER2
TEST(ERROR, InvalidCommandQueueher2) {
    ErrorClass<Her2Metod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListher2) {
    ErrorClass<Her2Metod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecther2) {
    ErrorClass<Her2Metod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueher2) {

    ErrorClass<Her2Metod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceher2) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Her2Metod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HEMM
TEST(ERROR, InvalidCommandQueuehemm) {
    ErrorClass<HemmMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhemm) {
    ErrorClass<HemmMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthemm) {
    ErrorClass<HemmMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehemm) {

    ErrorClass<HemmMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatB);
}

TEST(ERROR, InvalidDevicehemm) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HemmMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HEMV
TEST(ERROR, InvalidCommandQueuehemv) {
    ErrorClass<HemvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhemv) {
    ErrorClass<HemvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthemv) {
    ErrorClass<HemvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehemv) {

    ErrorClass<HemvMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicehemv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HemvMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HERK
TEST(ERROR, InvalidCommandQueueherk) {
    ErrorClass<HerkMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListherk) {
    ErrorClass<HerkMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectherk) {
    ErrorClass<HerkMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueherk) {
    ErrorClass<HerkMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceherk) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HerkMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_HPMV

TEST(ERROR, InvalidCommandQueuehpmv) {
    ErrorClass<HpmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhpmv) {
    ErrorClass<HpmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthpmv) {
    ErrorClass<HpmvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehpmv) {

    ErrorClass<HpmvMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicehpmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HpmvMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_SPMV
TEST(ERROR, InvalidCommandQueuespmv) {
    ErrorClass<SpmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListspmv) {
    ErrorClass<SpmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectspmv) {
    ErrorClass<SpmvMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuespmv) {

    ErrorClass<SpmvMetod<cl_double> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicespmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SpmvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SPR2
TEST(ERROR, InvalidCommandQueuespr2) {
    ErrorClass<Spr2Metod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListspr2) {
    ErrorClass<Spr2Metod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectspr2) {
    ErrorClass<Spr2Metod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}
TEST(ERROR, InvalidValuespr2) {
    ErrorClass<Spr2Metod<cl_float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicespr2) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Spr2Metod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_HPR
TEST(ERROR, InvalidCommandQueuehpr) {
    ErrorClass<HprMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhpr) {
    ErrorClass<HprMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthpr) {
    ErrorClass<HprMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehpr) {

    ErrorClass<HprMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicehpr) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HprMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HPR2
TEST(ERROR, InvalidCommandQueuehpr2) {
    ErrorClass<Hpr2Metod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhpr2) {
    ErrorClass<Hpr2Metod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthpr2) {
    ErrorClass<Hpr2Metod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehpr2) {

    ErrorClass<Hpr2Metod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicehpr2) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Hpr2Metod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_GBMV
TEST(ERROR, InvalidCommandQueueGBMV) {
    ErrorClass<GbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListGBMV) {
    ErrorClass<GbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectGBMV) {
    ErrorClass<GbmvMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueGBMV) {
    ErrorClass<GbmvMetod<cl_double> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceGBMV) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<GbmvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SBMV
TEST(ERROR, InvalidCommandQueuesbmv) {
    ErrorClass<SbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListsbmv) {
    ErrorClass<SbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectsbmv) {
    ErrorClass<SbmvMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuesbmv) {
    ErrorClass<SbmvMetod<cl_float> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicesbmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SbmvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HBMV
TEST(ERROR, InvalidCommandQueuehbmv) {
    ErrorClass<HbmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListhbmv) {
    ErrorClass<HbmvMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecthbmv) {
    ErrorClass<HbmvMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValuehbmv) {
    ErrorClass<HbmvMetod<FloatComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDevicehbmv) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<HbmvMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_TBMV
TEST(ERROR, InvalidCommandQueueTBMV) {
    ErrorClass<TbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListTBMV) {
    ErrorClass<TbmvMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectTBMV) {
    ErrorClass<TbmvMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueTBMV) {

    ErrorClass<TbmvMetod<cl_double> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceTBMV) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<TbmvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_TBSV
TEST(ERROR, InvalidCommandQueueTBSV) {
    ErrorClass<TbsvMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListTBSV) {
    ErrorClass<TbsvMetod<cl_float> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectTBSV) {
    ErrorClass<TbsvMetod<cl_float> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueTBSV) {

    ErrorClass<TbsvMetod<cl_double> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDeviceTBSV) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<TbsvMetod<cl_double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_HER2K
TEST(ERROR, InvalidCommandQueueher2k) {
    ErrorClass<Her2kMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListher2k) {
    ErrorClass<Her2kMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjecther2k) {
    ErrorClass<Her2kMetod<FloatComplex> > ec;
    ec.error(clblasInvalidMatA);
}

TEST(ERROR, InvalidValueher2k) {
    ErrorClass<Her2kMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemMatA);
}

TEST(ERROR, InvalidDeviceher2k) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Her2kMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SCAL
TEST(ERROR, InvalidCommandQueuescal) {
    ErrorClass<ScalMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListscal) {
    ErrorClass<ScalMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectscal) {
    ErrorClass<ScalMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValuescal) {
    ErrorClass<ScalMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicescal) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<ScalMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SSCAL
TEST(ERROR, InvalidCommandQueuesscal) {
    ErrorClass<SscalMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListsscal) {
    ErrorClass<SscalMetod<DoubleComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectsscal) {
    ErrorClass<SscalMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValuesscal) {
    ErrorClass<SscalMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicesscal) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SscalMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_SWAP
TEST(ERROR, InvalidCommandQueueswap) {
    ErrorClass<SwapMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListswap) {
    ErrorClass<SwapMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectswap) {
    ErrorClass<SwapMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValueswap) {
    ErrorClass<SwapMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDeviceswap) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<SwapMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_COPY
TEST(ERROR, InvalidCommandQueuecopy) {
    ErrorClass<CopyMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListcopy) {
    ErrorClass<CopyMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectcopy) {
    ErrorClass<CopyMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValuecopy) {
    ErrorClass<CopyMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicecopy) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<CopyMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_AXPY
TEST(ERROR, InvalidCommandQueueaxpy) {
    ErrorClass<AxpyMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListaxpy) {
    ErrorClass<AxpyMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectaxpy) {
    ErrorClass<AxpyMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValueaxpy) {
    ErrorClass<AxpyMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDeviceaxpy) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<AxpyMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

//DOT
#ifdef DO_DOT
TEST(ERROR, InvalidCommandQueuedot) {
    ErrorClass<DotMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListdot) {
    ErrorClass<DotMetod<cl_double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectdot) {
    ErrorClass<DotMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}
TEST(ERROR, InvalidValuedot) {
    ErrorClass<DotMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicedot) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<DotMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_ASUM
TEST(ERROR, InvalidCommandQueueasum) {
    ErrorClass<AsumMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListasum) {
    ErrorClass<AsumMetod<cl_double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectasum) {
    ErrorClass<AsumMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}
TEST(ERROR, InvalidValueasum) {
    ErrorClass<AsumMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDeviceasum) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<AsumMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_iAMAX
TEST(ERROR, InvalidCommandQueueiamax) {
    ErrorClass<iAmaxMetod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListiamax) {
    ErrorClass<iAmaxMetod<cl_double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectiamax) {
    ErrorClass<iAmaxMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}
TEST(ERROR, InvalidValueiamax) {
    ErrorClass<iAmaxMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDeviceiamax) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<iAmaxMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

//DOTC
#ifdef DO_DOTC
TEST(ERROR, InvalidCommandQueuedotc) {
    ErrorClass<DotcMetod<FloatComplex> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListdotc) {
    ErrorClass<DotcMetod<DoubleComplex> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectdotc) {
    ErrorClass<DotcMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}
TEST(ERROR, InvalidValuedotc) {
    ErrorClass<DotcMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicedotc) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<DotMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif


#ifdef DO_ROTG
TEST(ERROR, InvalidCommandQueuerotg) {
    ErrorClass<RotgMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListrotg) {
    ErrorClass<RotgMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectrotg) {
    ErrorClass<RotgMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

/*  Skipping Invalid value- because rotg doesn't depend on parameter N,
                            So even passing an invalid N doesn't matter
TEST(ERROR, InvalidValuerotg) {
    ErrorClass<RotgMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}
*/

TEST(ERROR, InvalidDevicerotg) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<RotgMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_ROTM
TEST(ERROR, InvalidCommandQueuerotm) {
    ErrorClass<RotmMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListrotm) {
    ErrorClass<RotmMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectrotm) {
    ErrorClass<RotmMetod<float> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValuerotm) {
    ErrorClass<RotmMetod<double> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicerotm) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<RotmMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_ROT
TEST(ERROR, InvalidCommandQueuerot) {
    ErrorClass<RotMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListrot) {
    ErrorClass<RotMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectrot) {
    ErrorClass<RotMetod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}

TEST(ERROR, InvalidValuerot) {
    ErrorClass<RotMetod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicerot) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<RotMetod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_ROTMG
TEST(ERROR, InvalidCommandQueuerotmg) {
    ErrorClass<RotmgMetod<float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListrotmg) {
    ErrorClass<RotmgMetod<double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectrotmg) {
    ErrorClass<RotmgMetod<float> > ec;
    ec.error(clblasInvalidVecX);
}

/*  Skipping Invalid value- because rotg doesn't depend on parameter N,
                            So even passing an invalid N doesn't matter
TEST(ERROR, InvalidValuerotmg) {
    ErrorClass<RotmgMetod<double> > ec;
    ec.error(clblasInsufficientMemVecX);
}
*/

TEST(ERROR, InvalidDevicerotmg) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<RotmgMetod<double> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif

#ifdef DO_NRM2
TEST(ERROR, InvalidCommandQueuenrm2) {
    ErrorClass<Nrm2Metod<cl_float> > ec;
    ec.error(CL_INVALID_COMMAND_QUEUE);
}

TEST(ERROR, InvalidEventWaitListnrm2) {
    ErrorClass<Nrm2Metod<cl_double> > ec;
    ec.error(CL_INVALID_EVENT_WAIT_LIST);
}

TEST(ERROR, InvalidMemObjectnrm2) {
    ErrorClass<Nrm2Metod<FloatComplex> > ec;
    ec.error(clblasInvalidVecX);
}
TEST(ERROR, InvalidValuenrm2) {
    ErrorClass<Nrm2Metod<DoubleComplex> > ec;
    ec.error(clblasInsufficientMemVecX);
}

TEST(ERROR, InvalidDevicenrm2) {
    clMath::BlasBase* base = clMath::BlasBase::getInstance();
    if (!base->isDevSupportDoublePrecision()) {
    ErrorClass<Nrm2Metod<DoubleComplex> > ec;
        ec.error(CL_INVALID_DEVICE);
    }
}
#endif