#include <gna2-inference-api.h>
#include <gna2-model-export-api.h>
#endif
-
#include "gna_mock_api.hpp"
static GNACppApi * current = nullptr;
GNA2_API enum Gna2Status Gna2DeviceOpen(
uint32_t deviceIndex) {
+ if (current != nullptr) {
+ return current->Gna2DeviceOpen(deviceIndex);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2DeviceSetNumberOfThreads(
uint32_t deviceIndex,
uint32_t numberOfThreads) {
+ if (current != nullptr) {
+ return current->Gna2DeviceSetNumberOfThreads(deviceIndex, numberOfThreads);
+ }
return Gna2StatusSuccess;
}
GNA2_API Gna2Status Gna2DeviceClose(
uint32_t deviceIndex) {
+ if (current != nullptr) {
+ return current->Gna2DeviceClose(deviceIndex);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2MemoryFree(
void * memory) {
+ if (current != nullptr) {
+ return current->Gna2MemoryFree(memory);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2StatusGetMessage(enum Gna2Status status,
char * messageBuffer, uint32_t messageBufferSize) {
+ if (current != nullptr) {
+ return current->Gna2StatusGetMessage(status, messageBuffer, messageBufferSize);
+ }
return Gna2StatusSuccess;
}
uint32_t deviceIndex,
struct Gna2Model const * model,
uint32_t * modelId) {
+ if (current != nullptr) {
+ return current->Gna2ModelCreate(deviceIndex, model, modelId);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2ModelRelease(
uint32_t modelId) {
+ if (current != nullptr) {
+ return current->Gna2ModelRelease(modelId);
+ }
return Gna2StatusSuccess;
}
-GNA2_API enum Gna2Status Gna2ModelGetLastError(struct Gna2ModelError* error) {
+GNA2_API enum Gna2Status Gna2ModelGetLastError(
+ struct Gna2ModelError* error) {
+ if (current != nullptr) {
+ return current->Gna2ModelGetLastError(error);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2RequestConfigCreate(
uint32_t modelId,
uint32_t * requestConfigId) {
+ if (current != nullptr) {
+ return current->Gna2RequestConfigCreate(modelId, requestConfigId);
+ }
return Gna2StatusSuccess;
}
uint32_t operationIndex,
uint32_t numberOfIndices,
uint32_t const * indices) {
+ if (current != nullptr) {
+ return current->Gna2RequestConfigEnableActiveList(requestConfigId, operationIndex, numberOfIndices, indices);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2RequestConfigEnableHardwareConsistency(
uint32_t requestConfigId,
enum Gna2DeviceVersion deviceVersion) {
+ if (current != nullptr) {
+ return current->Gna2RequestConfigEnableHardwareConsistency(requestConfigId, deviceVersion);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2RequestConfigSetAccelerationMode(
uint32_t requestConfigId,
enum Gna2AccelerationMode accelerationMode) {
+ if (current != nullptr) {
+ return current->Gna2RequestConfigSetAccelerationMode(requestConfigId, accelerationMode);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2RequestEnqueue(
uint32_t requestConfigId,
uint32_t * requestId) {
+ if (current != nullptr) {
+ return current->Gna2RequestEnqueue(requestConfigId, requestId);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2RequestWait(
uint32_t requestId,
uint32_t timeoutMilliseconds) {
+ if (current != nullptr) {
+ return current->Gna2RequestWait(requestId, timeoutMilliseconds);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2ModelExportConfigCreate(
Gna2UserAllocator userAllocator,
uint32_t * exportConfigId) {
+ if (current != nullptr) {
+ return current->Gna2ModelExportConfigCreate(userAllocator, exportConfigId);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2ModelExportConfigRelease(
uint32_t exportConfigId) {
+ if (current != nullptr) {
+ return current->Gna2ModelExportConfigRelease(exportConfigId);
+ }
return Gna2StatusSuccess;
}
uint32_t exportConfigId,
uint32_t sourceDeviceIndex,
uint32_t sourceModelId) {
+ if (current != nullptr) {
+ return current->Gna2ModelExportConfigSetSource(exportConfigId, sourceDeviceIndex, sourceModelId);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2ModelExportConfigSetTarget(
uint32_t exportConfigId,
enum Gna2DeviceVersion targetDeviceVersion) {
+ if (current != nullptr) {
+ return current->Gna2ModelExportConfigSetTarget(exportConfigId, targetDeviceVersion);
+ }
return Gna2StatusSuccess;
}
enum Gna2ModelExportComponent componentType,
void ** exportBuffer,
uint32_t * exportBufferSize) {
+ if (current != nullptr) {
+ return current->Gna2ModelExport(exportConfigId, componentType, exportBuffer, exportBufferSize);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2DeviceGetVersion(
uint32_t deviceIndex,
enum Gna2DeviceVersion * deviceVersion) {
+ if (current != nullptr) {
+ return current->Gna2DeviceGetVersion(deviceIndex,deviceVersion);
+ }
*deviceVersion = Gna2DeviceVersionSoftwareEmulation;
return Gna2StatusSuccess;
}
enum Gna2InstrumentationPoint* selectedInstrumentationPoints,
uint64_t * results,
uint32_t * instrumentationConfigId) {
+ if (current != nullptr) {
+ return current->Gna2InstrumentationConfigCreate(numberOfInstrumentationPoints, selectedInstrumentationPoints, results, instrumentationConfigId);
+ }
return Gna2StatusSuccess;
}
GNA2_API enum Gna2Status Gna2InstrumentationConfigAssignToRequestConfig(
uint32_t instrumentationConfigId,
uint32_t requestConfigId) {
+ if (current != nullptr) {
+ return current->Gna2InstrumentationConfigAssignToRequestConfig(instrumentationConfigId, requestConfigId);
+ }
return Gna2StatusSuccess;
}
delete this;
}
};
+#if GNA_LIB_VER == 2
+void expect_enqueue_calls(GNACppApi &mockApi, bool enableHardwareConsistency = true){
+ EXPECT_CALL(mockApi, Gna2ModelCreate(_,_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t deviceIndex,
+ struct Gna2Model const * model,
+ uint32_t * modelId) {
+ *modelId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigCreate(_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t modelId,
+ uint32_t * requestConfigId) {
+ *requestConfigId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ if (enableHardwareConsistency) {
+ EXPECT_CALL(mockApi, Gna2RequestConfigEnableHardwareConsistency(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+ }
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigSetAccelerationMode(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigAssignToRequestConfig(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+
+ {
+ ::testing::InSequence enqueue_wait_sequence;
+ EXPECT_CALL(mockApi, Gna2RequestEnqueue(_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t requestConfigId,
+ uint32_t * requestId) {
+ *requestId = 0;
+ return Gna2StatusSuccess;
+ }));
+ EXPECT_CALL(mockApi, Gna2RequestWait(_, _)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+ }
+}
+#endif
void GNAPropagateMatcher :: match() {
try {
if (_env.config[GNA_CONFIG_KEY(DEVICE_MODE)].compare(GNA_CONFIG_VALUE(SW_FP32)) != 0 &&
!_env.matchThrows) {
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAAlloc(_,_,_)).WillOnce(Invoke([&data](
intel_gna_handle_t nGNADevice, // handle to GNA accelerator
uint32_t sizeRequested,
} else {
EXPECT_CALL(mockApi, gmmSetThreads(_)).Times(0);
}
-#else
+#elif GNA_LIB_VER == 2
EXPECT_CALL(mockApi, Gna2MemoryAlloc(_, _, _)).WillOnce(Invoke([&data](
uint32_t sizeRequested,
uint32_t *sizeGranted,
*memoryAddress = &data.front();
return Gna2StatusSuccess;
}));
+
+ EXPECT_CALL(mockApi, Gna2DeviceGetVersion(_,_)).WillOnce(Invoke([](
+ uint32_t deviceIndex,
+ enum Gna2DeviceVersion * deviceVersion) {
+ *deviceVersion = Gna2DeviceVersionSoftwareEmulation;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2DeviceOpen(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigCreate(_,_,_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+
+
+ if(_env.is_setup_of_omp_theads_expected == true) {
+ EXPECT_CALL(mockApi, Gna2DeviceSetNumberOfThreads(_,_)).WillOnce(Return(Gna2StatusSuccess));
+ }
+#else
+#error "Unsupported GNA_LIB_VER"
#endif
std::unique_ptr<NNetComponentMatcher> combined(new NNetComponentMatcher());
combined->add(new NNetPrecisionMatcher(_env.nnet_precision, INTEL_AFFINE));
break;
case GnaPluginTestEnvironment::matchProcType :
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAPropagateForward(_, _, _, _, _, Eq(_env.proc_type)))
.WillOnce(Return(GNA_NOERROR));
+#elif GNA_LIB_VER == 2
+ if(_env.proc_type == (GNA_SOFTWARE & GNA_HARDWARE)) {
+ expect_enqueue_calls(mockApi);
+ } else {
+ expect_enqueue_calls(mockApi, false);
+ }
#endif
break;
case GnaPluginTestEnvironment::matchPwlInserted :
combined->add(new DiagLayerMatcher(_env.matchInserted, matchWhat.matchQuantity));
break;
case GnaPluginTestEnvironment::saveArgs :
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAPropagateForward(_, _, _, _, _, _))
.WillOnce(DoAll(SaveArgPointee<1>(savedNet), Return(GNA_NOERROR)));
+#elif GNA_LIB_VER == 2
+ expect_enqueue_calls(mockApi);
#endif
break;
case GnaPluginTestEnvironment::matchInputData :
SaveWeights(combined, _env.transposedData, _env.transposedArgsForSaving);
break;
default:
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAPropagateForward(_, _, _, _, _, _))
.WillOnce(Return(GNA_NOERROR));
+#elif GNA_LIB_VER == 2
+ expect_enqueue_calls(mockApi);
#endif
break;
}
}
if (combined && !combined->empty()) {
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAPropagateForward(_, ::testing::MakeMatcher(combined.release()), _, _, _,_)).WillOnce(Return(GNA_NOERROR));
+#elif GNA_LIB_VER == 2
+ expect_enqueue_calls(mockApi);
#endif
}
}
}
GNACppApi mockApi;
- std::vector<uint8_t> data(10000);
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+ std::vector<std::vector<uint8_t>> data;
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAAlloc(_,_,_)).WillOnce(DoAll(SetArgPointee<2>(10000), Return(&data.front())));
EXPECT_CALL(mockApi, GNADeviceOpenSetThreads(_, _)).WillOnce(Return(1));
+#elif GNA_LIB_VER == 2
+ EXPECT_CALL(mockApi, Gna2MemoryAlloc(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Invoke([&data](
+ uint32_t sizeRequested,
+ uint32_t *sizeGranted,
+ void **memoryAddress) {
+ data.push_back(std::vector<uint8_t>(sizeRequested));
+ *sizeGranted = sizeRequested;
+ *memoryAddress = data.back().data();
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2DeviceGetVersion(_,_)).WillOnce(Invoke([](
+ uint32_t deviceIndex,
+ enum Gna2DeviceVersion * deviceVersion) {
+ *deviceVersion = Gna2DeviceVersionSoftwareEmulation;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2DeviceOpen(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigCreate(_,_,_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelCreate(_,_,_)).WillOnce(Invoke([](
+ uint32_t deviceIndex,
+ struct Gna2Model const * model,
+ uint32_t * modelId) {
+ *modelId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigCreate(_,_)).WillOnce(Invoke([](
+ uint32_t modelId,
+ uint32_t * requestConfigId) {
+ *requestConfigId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigEnableHardwareConsistency(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigAssignToRequestConfig(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
#else
- EXPECT_CALL(mockApi, Gna2MemoryAlloc(_, _, _)).WillOnce(Invoke([&data](
- uint32_t sizeRequested,
- uint32_t *sizeGranted,
- void **memoryAddress
- ) {
- data.resize(sizeRequested);
- *sizeGranted = sizeRequested;
- *memoryAddress = &data.front();
- return Gna2StatusSuccess;
- }));
+#error "Not supported GNA_LIB_VER"
#endif
plugin.LoadNetwork(network);
plugin.Export(_env.exportedModelFileName);
GNACppApi mockApi;
std::vector<uint8_t> data(10000);
+
+#if GNA_LIB_VER == 1
if (!_env.matchThrows) {
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
EXPECT_CALL(mockApi, GNAAlloc(_,_,_)).WillOnce(DoAll(SetArgPointee<2>(10000), Return(&data.front())));
EXPECT_CALL(mockApi, GNADeviceOpenSetThreads(_, _)).WillOnce(Return(1));
intel_gna_model_header header = {};
EXPECT_CALL(mockApi, GNADumpXnn(_, _, _, _, _,_)).WillOnce(DoAll(SetArgPointee<3>(header), Return((void*)::operator new[](1))));
EXPECT_CALL(mockApi, GNAFree(_)).WillOnce(Return(GNA_NOERROR));
EXPECT_CALL(mockApi, GNADeviceClose(_)).WillOnce(Return(GNA_NOERROR));
-#endif
}
+#elif GNA_LIB_VER == 2
+ if (!_env.matchThrows) {
+ EXPECT_CALL(mockApi, Gna2MemoryAlloc(_, _, _)).
+ WillOnce(DoAll(SetArgPointee<1>(10000), SetArgPointee<2>(&data.front()), Return(Gna2StatusSuccess)));
+
+ EXPECT_CALL(mockApi, Gna2DeviceGetVersion(_,_)).WillOnce(Invoke([](
+ uint32_t deviceIndex,
+ enum Gna2DeviceVersion * deviceVersion) {
+ *deviceVersion = Gna2DeviceVersionSoftwareEmulation;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2DeviceOpen(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigCreate(_,_,_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelCreate(_,_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t deviceIndex,
+ struct Gna2Model const * model,
+ uint32_t * modelId) {
+ *modelId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2MemoryFree(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2DeviceClose(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelExportConfigCreate(_,_)).WillOnce(DoAll(SetArgPointee<1>(0), Return(Gna2StatusSuccess)));
+
+ EXPECT_CALL(mockApi, Gna2ModelExportConfigSetSource(_,_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelExportConfigSetTarget(_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelExport(_,_,_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([] (
+ uint32_t exportConfigId,
+ enum Gna2ModelExportComponent componentType,
+ void ** exportBuffer,
+ uint32_t * exportBufferSize) {
+ *exportBufferSize = 64;
+ *exportBuffer = gnaUserAllocator(sizeof(Gna2ModelSueCreekHeader));
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2ModelExportConfigRelease(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelRelease(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigCreate(_,_)).WillOnce(Invoke([](
+ uint32_t modelId,
+ uint32_t * requestConfigId) {
+ *requestConfigId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ ON_CALL(mockApi, Gna2RequestConfigSetAccelerationMode(_,_)).WillByDefault(Return(Gna2StatusSuccess));
+
+ ON_CALL(mockApi, Gna2RequestConfigEnableHardwareConsistency(_,_)).WillByDefault(Return(Gna2StatusSuccess));
+
+ ON_CALL(mockApi, Gna2InstrumentationConfigAssignToRequestConfig(_,_)).WillByDefault(Return(Gna2StatusSuccess));
+ }
+#else
+#error "Not supported GNA_LIB_VER"
+#endif
+
try {
// matching gna DumpXNN forward call.
}
};
-#if GNA_LIB_VER == 1 // TODO: GNA2: handle new API
+#if GNA_LIB_VER == 1
EXPECT_CALL(mockApi, GNAAlloc(_,_,_)).WillOnce(DoAll(SetArgPointee<2>(10000), Return(&data.front())));
EXPECT_CALL(mockApi, GNADeviceOpenSetThreads(_, _)).WillOnce(Return(1));
EXPECT_CALL(mockApi, GNAFree(_)).WillOnce(Return(GNA_NOERROR));
#else
EXPECT_CALL(mockApi, Gna2MemoryAlloc(_, _, _)).
WillOnce(DoAll(SetArgPointee<1>(10000), SetArgPointee<2>(&data.front()), Return(Gna2StatusSuccess)));
+
+ EXPECT_CALL(mockApi, Gna2DeviceGetVersion(_,_)).WillOnce(Invoke([](
+ uint32_t deviceIndex,
+ enum Gna2DeviceVersion * deviceVersion) {
+ *deviceVersion = Gna2DeviceVersionSoftwareEmulation;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2DeviceOpen(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigCreate(_,_,_,_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2MemoryFree(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2DeviceClose(_)).WillOnce(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2ModelCreate(_,_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t deviceIndex,
+ struct Gna2Model const * model,
+ uint32_t * modelId) {
+ *modelId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigCreate(_,_)).Times(AtLeast(1)).WillRepeatedly(Invoke([](
+ uint32_t modelId,
+ uint32_t * requestConfigId) {
+ *requestConfigId = 0;
+ return Gna2StatusSuccess;
+ }));
+
+ EXPECT_CALL(mockApi, Gna2RequestConfigEnableHardwareConsistency(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
+
+ EXPECT_CALL(mockApi, Gna2InstrumentationConfigAssignToRequestConfig(_,_)).Times(AtLeast(1)).WillRepeatedly(Return(Gna2StatusSuccess));
#endif
try {
loadNetwork();
#pragma once
#include <gmock/gmock-generated-function-mockers.h>
-
+#if GNA_LIB_VER == 1
+#include <gna-api.h>
+#include <gna-api-instrumentation.h>
+#include <gna-api-dumper.h>
+#else
+#include <gna2-instrumentation-api.h>
+#include <gna2-inference-api.h>
+#include <gna2-model-export-api.h>
+#endif
#if defined(_WIN32)
#ifdef libGNAStubs_EXPORTS
#define GNA_STUBS_EXPORT __declspec(dllexport)
uint32_t sizeRequested,
uint32_t * sizeGranted,
void ** memoryAddress));
+
+ MOCK_METHOD1(Gna2DeviceOpen, Gna2Status (
+ uint32_t deviceIndex));
+
+ MOCK_METHOD2(Gna2DeviceSetNumberOfThreads, Gna2Status(
+ uint32_t deviceIndex,
+ uint32_t numberOfThreads));
+
+ MOCK_METHOD1(Gna2DeviceClose, Gna2Status (
+ uint32_t deviceIndex));
+
+ MOCK_METHOD1(Gna2MemoryFree, Gna2Status (
+ void * memory));
+
+ MOCK_METHOD3(Gna2StatusGetMessage, Gna2Status (
+ enum Gna2Status status,
+ char * messageBuffer,
+ uint32_t messageBufferSize));
+
+ MOCK_METHOD3(Gna2ModelCreate, Gna2Status (
+ uint32_t deviceIndex,
+ struct Gna2Model const * model,
+ uint32_t * modelId));
+
+ MOCK_METHOD1(Gna2ModelRelease, Gna2Status (
+ uint32_t modelId));
+
+ MOCK_METHOD1(Gna2ModelGetLastError, Gna2Status (
+ struct Gna2ModelError* error));
+
+ MOCK_METHOD2(Gna2RequestConfigCreate, Gna2Status (
+ uint32_t modelId,
+ uint32_t * requestConfigId));
+
+ MOCK_METHOD4(Gna2RequestConfigEnableActiveList, Gna2Status (
+ uint32_t requestConfigId,
+ uint32_t operationIndex,
+ uint32_t numberOfIndices,
+ uint32_t const * indices));
+
+ MOCK_METHOD2(Gna2RequestConfigEnableHardwareConsistency, Gna2Status (
+ uint32_t requestConfigId,
+ enum Gna2DeviceVersion deviceVersion));
+
+ MOCK_METHOD2(Gna2RequestConfigSetAccelerationMode, Gna2Status (
+ uint32_t requestConfigId,
+ enum Gna2AccelerationMode accelerationMode));
+
+ MOCK_METHOD2(Gna2RequestEnqueue, Gna2Status (
+ uint32_t requestConfigId,
+ uint32_t * requestId));
+
+ MOCK_METHOD2(Gna2RequestWait, Gna2Status (
+ uint32_t requestId,
+ uint32_t timeoutMilliseconds));
+
+ MOCK_METHOD2(Gna2ModelExportConfigCreate, Gna2Status (
+ Gna2UserAllocator userAllocator,
+ uint32_t * exportConfigId));
+
+ MOCK_METHOD1(Gna2ModelExportConfigRelease, Gna2Status (
+ uint32_t exportConfigId));
+
+ MOCK_METHOD3(Gna2ModelExportConfigSetSource, Gna2Status (
+ uint32_t exportConfigId,
+ uint32_t sourceDeviceIndex,
+ uint32_t sourceModelId));
+
+ MOCK_METHOD2(Gna2ModelExportConfigSetTarget, Gna2Status (
+ uint32_t exportConfigId,
+ enum Gna2DeviceVersion targetDeviceVersion));
+
+ MOCK_METHOD4(Gna2ModelExport, Gna2Status (
+ uint32_t exportConfigId,
+ enum Gna2ModelExportComponent componentType,
+ void ** exportBuffer,
+ uint32_t * exportBufferSize));
+
+ MOCK_METHOD2(Gna2DeviceGetVersion, Gna2Status (
+ uint32_t deviceIndex,
+ enum Gna2DeviceVersion * deviceVersion));
+
+ MOCK_METHOD4(Gna2InstrumentationConfigCreate, Gna2Status (
+ uint32_t numberOfInstrumentationPoints,
+ enum Gna2InstrumentationPoint* selectedInstrumentationPoints,
+ uint64_t * results,
+ uint32_t * instrumentationConfigId));
+
+ MOCK_METHOD2(Gna2InstrumentationConfigAssignToRequestConfig, Gna2Status (
+ uint32_t instrumentationConfigId,
+ uint32_t requestConfigId));
#endif
};