encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Mock API: special case the SetErrorCallback procs. 

Also add a suppression for these procs in wiretests, unless we are
specifically testing them.
This commit is contained in:
Corentin Wallez 2017-05-16 22:05:51 +02:00 committed by Corentin Wallez
parent 0a58812f34
commit 1b7c5e3f70
3 changed files with 91 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
generator/templates/mock_api.cpp
View File

@ -23,8 +23,8 @@ namespace {
, {{as_annotated_cType(arg)}}
{%- endfor -%}
) {
auto tablePtr = reinterpret_cast<ProcTableAsClass**>(self);
return (*tablePtr)->{{as_MethodSuffix(type.name, method.name)}}(self
auto object = reinterpret_cast<ProcTableAsClass::Object*>(self);
return object->procs->{{as_MethodSuffix(type.name, method.name)}}(self
{%- for arg in method.arguments -%}
, {{as_varName(arg.name)}}
{%- endfor -%}
@ -36,9 +36,6 @@ namespace {
}
ProcTableAsClass::~ProcTableAsClass() {
for (auto ptr : selfPtrs) {
delete ptr;
}
}
void ProcTableAsClass::GetProcTableAndDevice(nxtProcTable* table, nxtDevice* device) {
@ -51,10 +48,29 @@ void ProcTableAsClass::GetProcTableAndDevice(nxtProcTable* table, nxtDevice* dev
{% endfor %}
}
{% for type in by_category["object"] %}
{{as_cType(type.name)}} ProcTableAsClass::GetNew{{type.name.CamelCase()}}() {
auto self = new ProcTableAsClass*(this);
selfPtrs.push_back(self);
return reinterpret_cast<{{as_cType(type.name)}}>(self);
void ProcTableAsClass::DeviceSetErrorCallback(nxtDevice self, nxtDeviceErrorCallback callback, nxtCallbackUserdata userdata) {
auto object = reinterpret_cast<ProcTableAsClass::Object*>(self);
object->deviceErrorCallback = callback;
object->userdata1 = userdata;
this->OnDeviceSetErrorCallback(self, callback, userdata);
}
{% for type in by_category["object"] if type.is_builder %}
void ProcTableAsClass::{{as_MethodSuffix(type.name, Name("set error callback"))}}({{as_cType(type.name)}} self, nxtBuilderErrorCallback callback, nxtCallbackUserdata userdata1, nxtCallbackUserdata userdata2) {
auto object = reinterpret_cast<ProcTableAsClass::Object*>(self);
object->builderErrorCallback = callback;
object->userdata1 = userdata1;
object->userdata2 = userdata2;
this->OnBuilderSetErrorCallback(reinterpret_cast<nxtBufferBuilder>(self), callback, userdata1, userdata2);
}
{% endfor %}
{% for type in by_category["object"] %}
{{as_cType(type.name)}} ProcTableAsClass::GetNew{{type.name.CamelCase()}}() {
objects.emplace_back(new Object);
objects.back()->procs = this;
return reinterpret_cast<{{as_cType(type.name)}}>(objects.back().get());
}
{% endfor %}

40
generator/templates/mock_api.h
View File

@ -18,18 +18,25 @@
#include <gmock/gmock.h>
#include <nxt/nxt.h>
// An abstract base class representing a proc table so that API calls can be mocked. Most API calls
// are directly represented by a delete virtual method but others need minimal state tracking to be
// useful as mocks.
class ProcTableAsClass {
public:
virtual ~ProcTableAsClass();
void GetProcTableAndDevice(nxtProcTable* table, nxtDevice* device);
// Creates an object that can be returned by a mocked call as in WillOnce(Return(foo)).
// It returns an object of the write type that isn't equal to any previously returned object.
// Otherwise some mock expectation could be triggered by two different objects having the same
// value.
{% for type in by_category["object"] %}
{{as_cType(type.name)}} GetNew{{type.name.CamelCase()}}();
{% endfor %}
{% for type in by_category["object"] %}
{% for method in native_methods(type) if len(method.arguments) < 10 %}
{% for method in type.methods if len(method.arguments) < 10 %}
virtual {{as_cType(method.return_type.name)}} {{as_MethodSuffix(type.name, method.name)}}(
{{-as_cType(type.name)}} {{as_varName(type.name)}}
{%- for arg in method.arguments -%}
@ -37,17 +44,39 @@ class ProcTableAsClass {
{%- endfor -%}
) = 0;
{% endfor %}
virtual void {{as_MethodSuffix(type.name, Name("reference"))}}({{as_cType(type.name)}} self) = 0;
virtual void {{as_MethodSuffix(type.name, Name("release"))}}({{as_cType(type.name)}} self) = 0;
// Stores callback and userdata and calls OnBuilderSetErrorCallback
{% if type.is_builder %}
void {{as_MethodSuffix(type.name, Name("set error callback"))}}({{as_cType(type.name)}} self, nxtBuilderErrorCallback callback, nxtCallbackUserdata userdata1, nxtCallbackUserdata userdata2);
{% endif %}
{% endfor %}
// Stores callback and userdata and calls OnDeviceSetErrorCallback
void DeviceSetErrorCallback(nxtDevice self, nxtDeviceErrorCallback callback, nxtCallbackUserdata userdata);
// Special cased mockable methods
virtual void OnDeviceSetErrorCallback(nxtDevice device, nxtDeviceErrorCallback callback, nxtCallbackUserdata userdata) = 0;
virtual void OnBuilderSetErrorCallback(nxtBufferBuilder builder, nxtBuilderErrorCallback callback, nxtCallbackUserdata userdata1, nxtCallbackUserdata userdata2) = 0;
struct Object {
ProcTableAsClass* procs = nullptr;
nxtDeviceErrorCallback deviceErrorCallback = nullptr;
nxtBuilderErrorCallback builderErrorCallback = nullptr;
nxtCallbackUserdata userdata1 = 0;
nxtCallbackUserdata userdata2 = 0;
};
private:
std::vector<ProcTableAsClass**> selfPtrs;
// Remembers the values returned by GetNew* so they can be freed.
std::vector<std::unique_ptr<Object>> objects;
};
class MockProcTable : public ProcTableAsClass {
public:
{% for type in by_category["object"] %}
{% for method in native_methods(type) if len(method.arguments) < 10 %}
{% for method in type.methods if len(method.arguments) < 10 %}
MOCK_METHOD{{len(method.arguments) + 1}}(
{{-as_MethodSuffix(type.name, method.name)}},
{{as_cType(method.return_type.name)}}(
@ -58,7 +87,12 @@ class MockProcTable : public ProcTableAsClass {
));
{% endfor %}
MOCK_METHOD1({{as_MethodSuffix(type.name, Name("reference"))}}, void({{as_cType(type.name)}} self));
MOCK_METHOD1({{as_MethodSuffix(type.name, Name("release"))}}, void({{as_cType(type.name)}} self));
{% endfor %}
MOCK_METHOD3(OnDeviceSetErrorCallback, void(nxtDevice device, nxtDeviceErrorCallback callback, nxtCallbackUserdata userdata));
MOCK_METHOD4(OnBuilderSetErrorCallback, void(nxtBufferBuilder builder, nxtBuilderErrorCallback callback, nxtCallbackUserdata userdata1, nxtCallbackUserdata userdata2));
};
#endif // MOCK_NXT_H

29
src/tests/unittests/WireTests.cpp
View File

@ -18,16 +18,27 @@
#include "wire/TerribleCommandBuffer.h"
#include "wire/Wire.h"
#include <iostream>
using namespace testing;
using namespace nxt::wire;
class WireTests : public Test {
class WireTestsBase : public Test {
protected:
WireTestsBase(bool ignoreSetCallbackCalls)
: ignoreSetCallbackCalls(ignoreSetCallbackCalls) {
}
void SetUp() override {
nxtProcTable mockProcs;
nxtDevice mockDevice;
api.GetProcTableAndDevice(&mockProcs, &mockDevice);
if (ignoreSetCallbackCalls) {
EXPECT_CALL(api, OnDeviceSetErrorCallback(_, _, _)).Times(Exactly(1));
EXPECT_CALL(api, OnBuilderSetErrorCallback(_, _, _, _)).Times(AnyNumber());
}
s2cBuf = new TerribleCommandBuffer();
c2sBuf = new TerribleCommandBuffer(wireServer);
@ -63,12 +74,20 @@ class WireTests : public Test {
nxtDevice device;
private:
bool ignoreSetCallbackCalls = false;
CommandHandler* wireServer = nullptr;
CommandHandler* wireClient = nullptr;
TerribleCommandBuffer* s2cBuf = nullptr;
TerribleCommandBuffer* c2sBuf = nullptr;
};
class WireTests : public WireTestsBase {
public:
WireTests() : WireTestsBase(true) {
}
};
// One call gets forwarded correctly.
TEST_F(WireTests, CallForwarded) {
nxtCommandBufferBuilder builder = nxtDeviceCreateCommandBufferBuilder(device);
@ -189,3 +208,11 @@ TEST_F(WireTests, OneObjectAsPointerArgument) {
// - Test multiple objects as value work
// - Object creation, then calls do nothing after error on builder
// - Object creation then error then create object, then should do nothing.
// - Device error gets forwarded properly
// - Builder error
// - An error gets forwarded properly
// - No other call to builder after error
// - No call to object after error
// - No error -> success
// - Builder destroyed on client side -> gets unknown
// - Same for getresult then destroyed object