src/tests/unittests/validation/ValidationTest.cpp - dawn - Git at Google

 // Copyright 2017 The Dawn 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 "tests/unittests/validation/ValidationTest.h"

 #include "common/Assert.h"
 #include "common/SystemUtils.h"
 #include "dawn/dawn_proc.h"
 #include "dawn/webgpu.h"
 #include "dawn_native/NullBackend.h"
 #include "tests/ToggleParser.h"
 #include "utils/WireHelper.h"

 #include <algorithm>

 namespace {

     bool gUseWire = false;
     std::string gWireTraceDir = "";
     std::unique_ptr<ToggleParser> gToggleParser = nullptr;

 }  // namespace

 void InitDawnValidationTestEnvironment(int argc, char** argv) {
     gToggleParser = std::make_unique<ToggleParser>();

     for (int i = 1; i < argc; ++i) {
         if (strcmp("-w", argv[i]) == 0 || strcmp("--use-wire", argv[i]) == 0) {
             gUseWire = true;
             continue;
         }

         constexpr const char kWireTraceDirArg[] = "--wire-trace-dir=";
         size_t argLen = sizeof(kWireTraceDirArg) - 1;
         if (strncmp(argv[i], kWireTraceDirArg, argLen) == 0) {
             gWireTraceDir = argv[i] + argLen;
             continue;
         }

         if (gToggleParser->ParseEnabledToggles(argv[i])) {
             continue;
         }

         if (gToggleParser->ParseDisabledToggles(argv[i])) {
             continue;
         }

         if (strcmp("-h", argv[i]) == 0 || strcmp("--help", argv[i]) == 0) {
             dawn::InfoLog()
                 << "\n\nUsage: " << argv[0]
                 << " [GTEST_FLAGS...] [-w]\n"
                    "    [--enable-toggles=toggles] [--disable-toggles=toggles]\n"
                    "  -w, --use-wire: Run the tests through the wire (defaults to no wire)\n"
                    "  --enable-toggles: Comma-delimited list of Dawn toggles to enable.\n"
                    "    ex.) skip_validation,disable_robustness,turn_off_vsync\n"
                    "  --disable-toggles: Comma-delimited list of Dawn toggles to disable\n";
             continue;
         }

         // Skip over args that look like they're for Googletest.
         constexpr const char kGtestArgPrefix[] = "--gtest_";
         if (strncmp(kGtestArgPrefix, argv[i], sizeof(kGtestArgPrefix) - 1) == 0) {
             continue;
         }

         dawn::WarningLog() << " Unused argument: " << argv[i];
     }
 }

 ValidationTest::ValidationTest()
     : mWireHelper(utils::CreateWireHelper(gUseWire, gWireTraceDir.c_str())) {
 }

 void ValidationTest::SetUp() {
     instance = std::make_unique<dawn::native::Instance>();
     instance->DiscoverDefaultAdapters();

     std::vector<dawn::native::Adapter> adapters = instance->GetAdapters();

     // Validation tests run against the null backend, find the corresponding adapter
     bool foundNullAdapter = false;
     for (auto& currentAdapter : adapters) {
         wgpu::AdapterProperties adapterProperties;
         currentAdapter.GetProperties(&adapterProperties);

         if (adapterProperties.backendType == wgpu::BackendType::Null) {
             adapter = currentAdapter;
             foundNullAdapter = true;
             break;
         }
     }

     ASSERT(foundNullAdapter);

     std::tie(device, backendDevice) = mWireHelper->RegisterDevice(CreateTestDevice());
     device.SetUncapturedErrorCallback(ValidationTest::OnDeviceError, this);

     std::string traceName =
         std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
         "_" + ::testing::UnitTest::GetInstance()->current_test_info()->name();
     mWireHelper->BeginWireTrace(traceName.c_str());
 }

 ValidationTest::~ValidationTest() {
     // We need to destroy Dawn objects before setting the procs to null otherwise the dawn*Release
     // will call a nullptr
     device = wgpu::Device();
     mWireHelper.reset();
 }

 void ValidationTest::TearDown() {
     FlushWire();
     ASSERT_FALSE(mExpectError);

     if (device) {
         EXPECT_EQ(mLastWarningCount,
                   dawn::native::GetDeprecationWarningCountForTesting(backendDevice));
     }
 }

 void ValidationTest::StartExpectDeviceError(testing::Matcher<std::string> errorMatcher) {
     mExpectError = true;
     mError = false;
     mErrorMatcher = errorMatcher;
 }

 void ValidationTest::StartExpectDeviceError() {
     StartExpectDeviceError(testing::_);
 }

 bool ValidationTest::EndExpectDeviceError() {
     mExpectError = false;
     mErrorMatcher = testing::_;
     return mError;
 }
 std::string ValidationTest::GetLastDeviceErrorMessage() const {
     return mDeviceErrorMessage;
 }

 wgpu::Device ValidationTest::RegisterDevice(WGPUDevice backendDevice) {
     return mWireHelper->RegisterDevice(backendDevice).first;
 }

 bool ValidationTest::UsesWire() const {
     return gUseWire;
 }

 void ValidationTest::FlushWire() {
     EXPECT_TRUE(mWireHelper->FlushClient());
     EXPECT_TRUE(mWireHelper->FlushServer());
 }

 void ValidationTest::WaitForAllOperations(const wgpu::Device& device) {
     bool done = false;
     device.GetQueue().OnSubmittedWorkDone(
         0u, [](WGPUQueueWorkDoneStatus, void* userdata) { *static_cast<bool*>(userdata) = true; },
         &done);

     // Force the currently submitted operations to completed.
     while (!done) {
         device.Tick();
         FlushWire();
     }

     // TODO(cwallez@chromium.org): It's not clear why we need this additional tick. Investigate it
     // once WebGPU has defined the ordering of callbacks firing.
     device.Tick();
     FlushWire();
 }

 bool ValidationTest::HasToggleEnabled(const char* toggle) const {
     auto toggles = dawn::native::GetTogglesUsed(backendDevice);
     return std::find_if(toggles.begin(), toggles.end(), [toggle](const char* name) {
                return strcmp(toggle, name) == 0;
            }) != toggles.end();
 }

 wgpu::SupportedLimits ValidationTest::GetSupportedLimits() {
     WGPUSupportedLimits supportedLimits;
     supportedLimits.nextInChain = nullptr;
     dawn::native::GetProcs().deviceGetLimits(backendDevice, &supportedLimits);
     return *reinterpret_cast<wgpu::SupportedLimits*>(&supportedLimits);
 }

 WGPUDevice ValidationTest::CreateTestDevice() {
     // Disabled disallowing unsafe APIs so we can test them.
     std::vector<const char*> forceEnabledToggles;
     std::vector<const char*> forceDisabledToggles = {"disallow_unsafe_apis"};

     for (const std::string& toggle : gToggleParser->GetEnabledToggles()) {
         forceEnabledToggles.push_back(toggle.c_str());
     }

     for (const std::string& toggle : gToggleParser->GetDisabledToggles()) {
         forceDisabledToggles.push_back(toggle.c_str());
     }

     wgpu::DeviceDescriptor deviceDescriptor;
     wgpu::DawnTogglesDeviceDescriptor togglesDesc;
     deviceDescriptor.nextInChain = &togglesDesc;

     togglesDesc.forceEnabledToggles = forceEnabledToggles.data();
     togglesDesc.forceEnabledTogglesCount = forceEnabledToggles.size();
     togglesDesc.forceDisabledToggles = forceDisabledToggles.data();
     togglesDesc.forceDisabledTogglesCount = forceDisabledToggles.size();

     return adapter.CreateDevice(&deviceDescriptor);
 }

 // static
 void ValidationTest::OnDeviceError(WGPUErrorType type, const char* message, void* userdata) {
     ASSERT(type != WGPUErrorType_NoError);
     auto self = static_cast<ValidationTest*>(userdata);
     self->mDeviceErrorMessage = message;

     ASSERT_TRUE(self->mExpectError) << "Got unexpected device error: " << message;
     ASSERT_FALSE(self->mError) << "Got two errors in expect block";
     if (self->mExpectError) {
         ASSERT_THAT(message, self->mErrorMatcher);
     }
     self->mError = true;
 }

 ValidationTest::DummyRenderPass::DummyRenderPass(const wgpu::Device& device)
     : attachmentFormat(wgpu::TextureFormat::RGBA8Unorm), width(400), height(400) {
     wgpu::TextureDescriptor descriptor;
     descriptor.dimension = wgpu::TextureDimension::e2D;
     descriptor.size.width = width;
     descriptor.size.height = height;
     descriptor.size.depthOrArrayLayers = 1;
     descriptor.sampleCount = 1;
     descriptor.format = attachmentFormat;
     descriptor.mipLevelCount = 1;
     descriptor.usage = wgpu::TextureUsage::RenderAttachment;
     attachment = device.CreateTexture(&descriptor);

     wgpu::TextureView view = attachment.CreateView();
     mColorAttachment.view = view;
     mColorAttachment.resolveTarget = nullptr;
     mColorAttachment.clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
     mColorAttachment.loadOp = wgpu::LoadOp::Clear;
     mColorAttachment.storeOp = wgpu::StoreOp::Store;

     colorAttachmentCount = 1;
     colorAttachments = &mColorAttachment;
     depthStencilAttachment = nullptr;
 }
	// Copyright 2017 The Dawn 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 "tests/unittests/validation/ValidationTest.h"

	#include "common/Assert.h"
	#include "common/SystemUtils.h"
	#include "dawn/dawn_proc.h"
	#include "dawn/webgpu.h"
	#include "dawn_native/NullBackend.h"
	#include "tests/ToggleParser.h"
	#include "utils/WireHelper.h"

	#include <algorithm>

	namespace {

	bool gUseWire = false;
	std::string gWireTraceDir = "";
	std::unique_ptr<ToggleParser> gToggleParser = nullptr;

	} // namespace

	void InitDawnValidationTestEnvironment(int argc, char** argv) {
	gToggleParser = std::make_unique<ToggleParser>();

	for (int i = 1; i < argc; ++i) {
	if (strcmp("-w", argv[i]) == 0 \|\| strcmp("--use-wire", argv[i]) == 0) {
	gUseWire = true;
	continue;
	}

	constexpr const char kWireTraceDirArg[] = "--wire-trace-dir=";
	size_t argLen = sizeof(kWireTraceDirArg) - 1;
	if (strncmp(argv[i], kWireTraceDirArg, argLen) == 0) {
	gWireTraceDir = argv[i] + argLen;
	continue;
	}

	if (gToggleParser->ParseEnabledToggles(argv[i])) {
	continue;
	}

	if (gToggleParser->ParseDisabledToggles(argv[i])) {
	continue;
	}

	if (strcmp("-h", argv[i]) == 0 \|\| strcmp("--help", argv[i]) == 0) {
	dawn::InfoLog()
	<< "\n\nUsage: " << argv[0]
	<< " [GTEST_FLAGS...] [-w]\n"
	" [--enable-toggles=toggles] [--disable-toggles=toggles]\n"
	" -w, --use-wire: Run the tests through the wire (defaults to no wire)\n"
	" --enable-toggles: Comma-delimited list of Dawn toggles to enable.\n"
	" ex.) skip_validation,disable_robustness,turn_off_vsync\n"
	" --disable-toggles: Comma-delimited list of Dawn toggles to disable\n";
	continue;
	}

	// Skip over args that look like they're for Googletest.
	constexpr const char kGtestArgPrefix[] = "--gtest_";
	if (strncmp(kGtestArgPrefix, argv[i], sizeof(kGtestArgPrefix) - 1) == 0) {
	continue;
	}

	dawn::WarningLog() << " Unused argument: " << argv[i];
	}
	}

	ValidationTest::ValidationTest()
	: mWireHelper(utils::CreateWireHelper(gUseWire, gWireTraceDir.c_str())) {
	}

	void ValidationTest::SetUp() {
	instance = std::make_unique<dawn::native::Instance>();
	instance->DiscoverDefaultAdapters();

	std::vector<dawn::native::Adapter> adapters = instance->GetAdapters();

	// Validation tests run against the null backend, find the corresponding adapter
	bool foundNullAdapter = false;
	for (auto& currentAdapter : adapters) {
	wgpu::AdapterProperties adapterProperties;
	currentAdapter.GetProperties(&adapterProperties);

	if (adapterProperties.backendType == wgpu::BackendType::Null) {
	adapter = currentAdapter;
	foundNullAdapter = true;
	break;
	}
	}

	ASSERT(foundNullAdapter);

	std::tie(device, backendDevice) = mWireHelper->RegisterDevice(CreateTestDevice());
	device.SetUncapturedErrorCallback(ValidationTest::OnDeviceError, this);

	std::string traceName =
	std::string(::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()) +
	"_" + ::testing::UnitTest::GetInstance()->current_test_info()->name();
	mWireHelper->BeginWireTrace(traceName.c_str());
	}

	ValidationTest::~ValidationTest() {
	// We need to destroy Dawn objects before setting the procs to null otherwise the dawn*Release
	// will call a nullptr
	device = wgpu::Device();
	mWireHelper.reset();
	}

	void ValidationTest::TearDown() {
	FlushWire();
	ASSERT_FALSE(mExpectError);

	if (device) {
	EXPECT_EQ(mLastWarningCount,
	dawn::native::GetDeprecationWarningCountForTesting(backendDevice));
	}
	}

	void ValidationTest::StartExpectDeviceError(testing::Matcher<std::string> errorMatcher) {
	mExpectError = true;
	mError = false;
	mErrorMatcher = errorMatcher;
	}

	void ValidationTest::StartExpectDeviceError() {
	StartExpectDeviceError(testing::_);
	}

	bool ValidationTest::EndExpectDeviceError() {
	mExpectError = false;
	mErrorMatcher = testing::_;
	return mError;
	}
	std::string ValidationTest::GetLastDeviceErrorMessage() const {
	return mDeviceErrorMessage;
	}

	wgpu::Device ValidationTest::RegisterDevice(WGPUDevice backendDevice) {
	return mWireHelper->RegisterDevice(backendDevice).first;
	}

	bool ValidationTest::UsesWire() const {
	return gUseWire;
	}

	void ValidationTest::FlushWire() {
	EXPECT_TRUE(mWireHelper->FlushClient());
	EXPECT_TRUE(mWireHelper->FlushServer());
	}

	void ValidationTest::WaitForAllOperations(const wgpu::Device& device) {
	bool done = false;
	device.GetQueue().OnSubmittedWorkDone(
	0u, [](WGPUQueueWorkDoneStatus, void* userdata) { static_cast<bool>(userdata) = true; },
	&done);

	// Force the currently submitted operations to completed.
	while (!done) {
	device.Tick();
	FlushWire();
	}

	// TODO(cwallez@chromium.org): It's not clear why we need this additional tick. Investigate it
	// once WebGPU has defined the ordering of callbacks firing.
	device.Tick();
	FlushWire();
	}

	bool ValidationTest::HasToggleEnabled(const char* toggle) const {
	auto toggles = dawn::native::GetTogglesUsed(backendDevice);
	return std::find_if(toggles.begin(), toggles.end(), [toggle](const char* name) {
	return strcmp(toggle, name) == 0;
	}) != toggles.end();
	}

	wgpu::SupportedLimits ValidationTest::GetSupportedLimits() {
	WGPUSupportedLimits supportedLimits;
	supportedLimits.nextInChain = nullptr;
	dawn::native::GetProcs().deviceGetLimits(backendDevice, &supportedLimits);
	return reinterpret_cast<wgpu::SupportedLimits>(&supportedLimits);
	}

	WGPUDevice ValidationTest::CreateTestDevice() {
	// Disabled disallowing unsafe APIs so we can test them.
	std::vector<const char*> forceEnabledToggles;
	std::vector<const char*> forceDisabledToggles = {"disallow_unsafe_apis"};

	for (const std::string& toggle : gToggleParser->GetEnabledToggles()) {
	forceEnabledToggles.push_back(toggle.c_str());
	}

	for (const std::string& toggle : gToggleParser->GetDisabledToggles()) {
	forceDisabledToggles.push_back(toggle.c_str());
	}

	wgpu::DeviceDescriptor deviceDescriptor;
	wgpu::DawnTogglesDeviceDescriptor togglesDesc;
	deviceDescriptor.nextInChain = &togglesDesc;

	togglesDesc.forceEnabledToggles = forceEnabledToggles.data();
	togglesDesc.forceEnabledTogglesCount = forceEnabledToggles.size();
	togglesDesc.forceDisabledToggles = forceDisabledToggles.data();
	togglesDesc.forceDisabledTogglesCount = forceDisabledToggles.size();

	return adapter.CreateDevice(&deviceDescriptor);
	}

	// static
	void ValidationTest::OnDeviceError(WGPUErrorType type, const char* message, void* userdata) {
	ASSERT(type != WGPUErrorType_NoError);
	auto self = static_cast<ValidationTest*>(userdata);
	self->mDeviceErrorMessage = message;

	ASSERT_TRUE(self->mExpectError) << "Got unexpected device error: " << message;
	ASSERT_FALSE(self->mError) << "Got two errors in expect block";
	if (self->mExpectError) {
	ASSERT_THAT(message, self->mErrorMatcher);
	}
	self->mError = true;
	}

	ValidationTest::DummyRenderPass::DummyRenderPass(const wgpu::Device& device)
	: attachmentFormat(wgpu::TextureFormat::RGBA8Unorm), width(400), height(400) {
	wgpu::TextureDescriptor descriptor;
	descriptor.dimension = wgpu::TextureDimension::e2D;
	descriptor.size.width = width;
	descriptor.size.height = height;
	descriptor.size.depthOrArrayLayers = 1;
	descriptor.sampleCount = 1;
	descriptor.format = attachmentFormat;
	descriptor.mipLevelCount = 1;
	descriptor.usage = wgpu::TextureUsage::RenderAttachment;
	attachment = device.CreateTexture(&descriptor);

	wgpu::TextureView view = attachment.CreateView();
	mColorAttachment.view = view;
	mColorAttachment.resolveTarget = nullptr;
	mColorAttachment.clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
	mColorAttachment.loadOp = wgpu::LoadOp::Clear;
	mColorAttachment.storeOp = wgpu::StoreOp::Store;

	colorAttachmentCount = 1;
	colorAttachments = &mColorAttachment;
	depthStencilAttachment = nullptr;
	}