Add ValidationTest and an example validation test.

Validation tests are tests of the backend state-tracking and validation
code that don't require a GPU as they are running on the null backend.
This commit adds a very simple (and almost useless) BufferValidationTest
as an example of a validation test.

src/tests/CMakeLists.txt

@@ -14,6 +14,7 @@
 
 set(TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(UNITTESTS_DIR ${TESTS_DIR}/unittests)
+set(VALIDATION_TESTS_DIR ${UNITTESTS_DIR}/validation)
 add_executable(nxt_unittests
     ${UNITTESTS_DIR}/BitSetIteratorTests.cpp
     ${UNITTESTS_DIR}/CommandAllocatorTests.cpp
@@ -24,6 +25,9 @@ add_executable(nxt_unittests
     ${UNITTESTS_DIR}/RefCountedTests.cpp
     ${UNITTESTS_DIR}/ToBackendTests.cpp
     ${UNITTESTS_DIR}/WireTests.cpp
+    ${VALIDATION_TESTS_DIR}/BufferValidationTest.cpp
+    ${VALIDATION_TESTS_DIR}/ValidationTest.cpp
+    ${VALIDATION_TESTS_DIR}/ValidationTest.h
     ${TESTS_DIR}/UnittestsMain.cpp
 )
 target_link_libraries(nxt_unittests gtest nxt_backend mock_nxt nxt_wire)

src/tests/unittests/validation/BufferValidationTest.cpp

@@ -0,0 +1,37 @@
+// Copyright 2017 The NXT Authors
+//
+// 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 "ValidationTest.h"
+
+class BufferValidationTest : public ValidationTest {
+};
+
+TEST_F(BufferValidationTest, Creation) {
+    // Success
+    nxt::Buffer buf0 = AssertWillBeSuccess(device.CreateBufferBuilder())
+        .SetSize(4)
+        .SetAllowedUsage(nxt::BufferUsageBit::Uniform)
+        .GetResult();
+
+    // Test failure when specifying properties multiple times
+    nxt::Buffer buf1 = AssertWillBeError(device.CreateBufferBuilder())
+        .SetSize(4)
+        .SetSize(3)
+        .GetResult();
+
+    // Test failure when properties are missing
+    nxt::Buffer buf2 = AssertWillBeError(device.CreateBufferBuilder())
+        .SetSize(4)
+        .GetResult();
+}

src/tests/unittests/validation/ValidationTest.cpp

@@ -0,0 +1,70 @@
+// Copyright 2017 The NXT Authors
+//
+// 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 "ValidationTest.h"
+
+#include "nxt/nxt.h"
+
+namespace backend {
+    namespace null {
+        void Init(nxtProcTable* procs, nxtDevice* device);
+    }
+}
+
+ValidationTest::ValidationTest() {
+    nxtProcTable procs;
+    nxtDevice cDevice;
+    backend::null::Init(&procs, &cDevice);
+
+    nxtSetProcs(&procs);
+    device = nxt::Device::Acquire(cDevice);
+}
+
+ValidationTest::~ValidationTest() {
+    // We need to destroy NXT objects before setting the procs to null otherwise the nxt*Release
+    // will call a nullptr
+    device = nxt::Device();
+    nxtSetProcs(nullptr);
+}
+
+void ValidationTest::TearDown() {
+    for (auto& expectation : expectations) {
+        std::string name = expectation.debugName;
+        if (name.empty()) {
+            name = "<no debug name set>";
+        }
+
+        ASSERT_TRUE(expectation.gotStatus) << "Didn't get a status for " << name;
+
+        ASSERT_NE(NXT_BUILDER_ERROR_STATUS_UNKNOWN, expectation.gotStatus) << "Got unknown status for " << name;
+
+        bool wasSuccess = expectation.status == NXT_BUILDER_ERROR_STATUS_SUCCESS;
+        ASSERT_EQ(expectation.expectSuccess, wasSuccess)
+            << "Got wrong status value for " << name
+            << ", status was " << expectation.status << " with \"" << expectation.statusMessage << "\"";
+    }
+}
+
+void ValidationTest::OnBuilderErrorStatus(nxtBuilderErrorStatus status, const char* message, nxt::CallbackUserdata userdata1, nxt::CallbackUserdata userdata2) {
+    auto* self = reinterpret_cast<ValidationTest*>(static_cast<uintptr_t>(userdata1));
+    size_t index = userdata2;
+
+    ASSERT_LT(index, self->expectations.size());
+
+    auto& expectation = self->expectations[index];
+    ASSERT_FALSE(expectation.gotStatus);
+    expectation.gotStatus = true;
+    expectation.status = status;
+    expectation.statusMessage = message;
+}

src/tests/unittests/validation/ValidationTest.h

@@ -0,0 +1,87 @@
+// Copyright 2017 The NXT Authors
+//
+// 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.
+
+#ifndef TESTS_UNITTESTS_VALIDATIONTEST_H_
+#define TESTS_UNITTESTS_VALIDATIONTEST_H_
+
+#include "gtest/gtest.h"
+#include "nxt/nxtcpp.h"
+#include "nxt/nxtcpp_traits.h"
+
+class ValidationTest : public testing::Test {
+    public:
+        ValidationTest();
+        ~ValidationTest();
+
+        // Use these methods to add expectations on the validation of a builder. The expectations are
+        // checked on test teardown. Adding an expectation is done like the following:
+        //
+        //     nxt::Foo foo = AssertWillBe[Success|Error](device.CreateFooBuilder(), "my foo")
+        //         .SetBar(1)
+        //         .GetResult();
+        //
+        // The string argument is optional but will be printed when an expectations is missed, this
+        // will help debug tests where multiple expectations are added.
+        template<typename Builder>
+        Builder AssertWillBeSuccess(Builder builder, std::string debugName = "");
+        template<typename Builder>
+        Builder AssertWillBeError(Builder builder, std::string debugName = "");
+
+        void TearDown() override;
+
+    protected:
+        nxt::Device device;
+
+    private:
+        struct BuilderStatusExpectations {
+            bool expectSuccess;
+            std::string debugName;
+
+            bool gotStatus = false;
+            std::string statusMessage;
+            nxtBuilderErrorStatus status;
+        };
+        std::vector<BuilderStatusExpectations> expectations;
+
+        template<typename Builder>
+        Builder AddExpectation(Builder& builder, std::string debugName, bool expectSuccess);
+
+        static void OnBuilderErrorStatus(nxtBuilderErrorStatus status, const char* message, nxt::CallbackUserdata userdata1, nxt::CallbackUserdata userdata2);
+};
+
+template<typename Builder>
+Builder ValidationTest::AssertWillBeSuccess(Builder builder, std::string debugName) {
+    return AddExpectation(builder, debugName, true);
+}
+
+template<typename Builder>
+Builder ValidationTest::AssertWillBeError(Builder builder, std::string debugName) {
+    return AddExpectation(builder, debugName, false);
+}
+
+template<typename Builder>
+Builder ValidationTest::AddExpectation(Builder& builder, std::string debugName, bool expectSuccess) {
+    uint64_t userdata1 = reinterpret_cast<uintptr_t>(this);
+    uint64_t userdata2 = expectations.size();
+    builder.SetErrorCallback(OnBuilderErrorStatus, userdata1, userdata2);
+
+    expectations.emplace_back();
+    auto& expectation = expectations.back();
+    expectation.expectSuccess = expectSuccess;
+    expectation.debugName = debugName;
+
+    return std::move(builder);
+}
+
+#endif // TESTS_UNITTESTS_VALIDATIONTEST_H_