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

Add helper functions to iterate over ChainedStructs 

This CL adds two helpers for more ergonomic processing of
ChainedStructs.

1. FindInChain(): Iterates through the chain and automatically
   casts the ChainedStruct into the appropriate child type before
   returning.
2. ValidateSTypes(): Verifies that the chain only contains structs
   with sTypes from a pre-defined set. This also allows the caller
   to specify one-of constraints.
3. ValidateSingleSType(): Verifies that the chain contains a
   single struct with a specific sType or is an empty chain. This
   is a common case of |ValidateSTypes()| and is separated out as
   a fast-path.

Change-Id: I938df0bf2a9b1800b1105fb7f80fbde20bef8ec8
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/47680
Commit-Queue: Brian Ho <hob@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Brian Ho 2021-04-22 17:49:42 +00:00 committed by Commit Bot service account
parent b48d1f4b3d
commit 5346e770c9
10 changed files with 459 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/codegen.md
View File

@ -18,6 +18,7 @@ At this time it is used to generate:
- validation helper functions for dawn_native
- the definition of dawn_native's proc table
- dawn_native's internal version of the webgpu.h types
- utilities for working with dawn_native's chained structs
- a lot of dawn_wire parts, see below
Internally `dawn.json` is a dictionary from the "canonical name" of things to their definition. The "canonical name" is a space-separated (mostly) lower-case version of the name that's parsed into a `Name` Python object. Then that name can be turned into various casings with `.CamelCase()` `.SNAKE_CASE()`, etc. When `dawn.json` things reference each other, it is always via these "canonical names".

8
generator/dawn_json_generator.py
View File

@ -765,6 +765,14 @@ class MultiGeneratorFromDawnJSON(Generator):
renders.append(
FileRender('dawn_native/ProcTable.cpp',
'src/dawn_native/ProcTable.cpp', frontend_params))
renders.append(
FileRender('dawn_native/ChainUtils.h',
'src/dawn_native/ChainUtils_autogen.h',
frontend_params))
renders.append(
FileRender('dawn_native/ChainUtils.cpp',
'src/dawn_native/ChainUtils_autogen.cpp',
frontend_params))
if 'dawn_wire' in targets:
additional_params = compute_wire_params(api_params, wire_json)

61
generator/templates/dawn_native/ChainUtils.cpp Normal file
View File

@ -0,0 +1,61 @@
// Copyright 2021 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 "dawn_native/ChainUtils_autogen.h"
#include <unordered_set>
namespace dawn_native {
{% for value in types["s type"].values %}
{% if value.valid %}
void FindInChain(const ChainedStruct* chain, const {{as_cppEnum(value.name)}}** out) {
for (; chain; chain = chain->nextInChain) {
if (chain->sType == wgpu::SType::{{as_cppEnum(value.name)}}) {
*out = static_cast<const {{as_cppEnum(value.name)}}*>(chain);
break;
}
}
}
{% endif %}
{% endfor %}
MaybeError ValidateSTypes(const ChainedStruct* chain,
std::vector<std::vector<wgpu::SType>> oneOfConstraints) {
std::unordered_set<wgpu::SType> allSTypes;
for (; chain; chain = chain->nextInChain) {
if (allSTypes.find(chain->sType) != allSTypes.end()) {
return DAWN_VALIDATION_ERROR("Chain cannot have duplicate sTypes");
}
allSTypes.insert(chain->sType);
}
for (const auto& oneOfConstraint : oneOfConstraints) {
bool satisfied = false;
for (wgpu::SType oneOfSType : oneOfConstraint) {
if (allSTypes.find(oneOfSType) != allSTypes.end()) {
if (satisfied) {
return DAWN_VALIDATION_ERROR("Unsupported sType combination");
}
satisfied = true;
allSTypes.erase(oneOfSType);
}
}
}
if (!allSTypes.empty()) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
return {};
}
} // namespace dawn_native

81
generator/templates/dawn_native/ChainUtils.h Normal file
View File

@ -0,0 +1,81 @@
// Copyright 2021 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.
#ifndef DAWNNATIVE_CHAIN_UTILS_H_
#define DAWNNATIVE_CHAIN_UTILS_H_
#include "dawn_native/dawn_platform.h"
#include "dawn_native/Error.h"
namespace dawn_native {
{% for value in types["s type"].values %}
{% if value.valid %}
void FindInChain(const ChainedStruct* chain, const {{as_cppEnum(value.name)}}** out);
{% endif %}
{% endfor %}
// Verifies that |chain| only contains ChainedStructs of types enumerated in
// |oneOfConstraints| and contains no duplicate sTypes. Each vector in
// |oneOfConstraints| defines a set of sTypes that cannot coexist in the same chain.
// For example:
// ValidateSTypes(chain, { { ShaderModuleSPIRVDescriptor, ShaderModuleWGSLDescriptor } }))
// ValidateSTypes(chain, { { Extension1 }, { Extension2 } })
MaybeError ValidateSTypes(const ChainedStruct* chain,
std::vector<std::vector<wgpu::SType>> oneOfConstraints);
template <typename T>
MaybeError ValidateSingleSTypeInner(const ChainedStruct* chain, T sType) {
if (chain->sType != sType) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
return {};
}
template <typename T, typename... Args>
MaybeError ValidateSingleSTypeInner(const ChainedStruct* chain, T sType, Args... sTypes) {
if (chain->sType == sType) {
return {};
}
return ValidateSingleSTypeInner(chain, sTypes...);
}
// Verifies that |chain| contains a single ChainedStruct of type |sType| or no ChainedStructs
// at all.
template <typename T>
MaybeError ValidateSingleSType(const ChainedStruct* chain, T sType) {
if (chain == nullptr) {
return {};
}
if (chain->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("Chain can only contain a single chained struct");
}
return ValidateSingleSTypeInner(chain, sType);
}
// Verifies that |chain| contains a single ChainedStruct with a type enumerated in the
// parameter pack or no ChainedStructs at all.
template <typename T, typename... Args>
MaybeError ValidateSingleSType(const ChainedStruct* chain, T sType, Args... sTypes) {
if (chain == nullptr) {
return {};
}
if (chain->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("Chain can only contain a single chained struct");
}
return ValidateSingleSTypeInner(chain, sType, sTypes...);
}
} // namespace dawn_native
#endif // DAWNNATIVE_CHAIN_UTILS_H_

2
src/dawn_native/BUILD.gn
View File

@ -91,6 +91,8 @@ config("dawn_native_vulkan_rpath") {
dawn_json_generator("dawn_native_utils_gen") {
target = "dawn_native_utils"
outputs = [
"src/dawn_native/ChainUtils_autogen.h",
"src/dawn_native/ChainUtils_autogen.cpp",
"src/dawn_native/ProcTable.cpp",
"src/dawn_native/wgpu_structs_autogen.h",
"src/dawn_native/wgpu_structs_autogen.cpp",

23
src/dawn_native/RenderPipeline.cpp
View File

@ -16,6 +16,7 @@
#include "common/BitSetIterator.h"
#include "common/VertexFormatUtils.h"
#include "dawn_native/ChainUtils_autogen.h"
#include "dawn_native/Commands.h"
#include "dawn_native/Device.h"
#include "dawn_native/ObjectContentHasher.h"
@ -133,16 +134,13 @@ namespace dawn_native {
MaybeError ValidatePrimitiveState(const DeviceBase* device,
const PrimitiveState* descriptor) {
const ChainedStruct* chained = descriptor->nextInChain;
if (chained != nullptr) {
if (chained->sType != wgpu::SType::PrimitiveDepthClampingState) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
if (!device->IsExtensionEnabled(Extension::DepthClamping)) {
DAWN_TRY(ValidateSingleSType(descriptor->nextInChain,
wgpu::SType::PrimitiveDepthClampingState));
const PrimitiveDepthClampingState* clampInfo = nullptr;
FindInChain(descriptor->nextInChain, &clampInfo);
if (clampInfo && !device->IsExtensionEnabled(Extension::DepthClamping)) {
return DAWN_VALIDATION_ERROR("The depth clamping feature is not supported");
}
}
DAWN_TRY(ValidatePrimitiveTopology(descriptor->topology));
DAWN_TRY(ValidateIndexFormat(descriptor->stripIndexFormat));
DAWN_TRY(ValidateFrontFace(descriptor->frontFace));
@ -426,11 +424,10 @@ namespace dawn_native {
}
mPrimitive = descriptor->primitive;
const ChainedStruct* chained = mPrimitive.nextInChain;
if (chained != nullptr) {
ASSERT(chained->sType == wgpu::SType::PrimitiveDepthClampingState);
const auto* clampState = static_cast<const PrimitiveDepthClampingState*>(chained);
mClampDepth = clampState->clampDepth;
const PrimitiveDepthClampingState* clampInfo = nullptr;
FindInChain(mPrimitive.nextInChain, &clampInfo);
if (clampInfo) {
mClampDepth = clampInfo->clampDepth;
}
mMultisample = descriptor->multisample;

51
src/dawn_native/ShaderModule.cpp
View File

@ -17,6 +17,7 @@
#include "common/HashUtils.h"
#include "common/VertexFormatUtils.h"
#include "dawn_native/BindGroupLayout.h"
#include "dawn_native/ChainUtils_autogen.h"
#include "dawn_native/CompilationMessages.h"
#include "dawn_native/Device.h"
#include "dawn_native/ObjectContentHasher.h"
@ -1069,19 +1070,20 @@ namespace dawn_native {
return DAWN_VALIDATION_ERROR("Shader module descriptor missing chained descriptor");
}
// For now only a single SPIRV or WGSL subdescriptor is allowed.
if (chainedDescriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR(
"Shader module descriptor chained nextInChain must be nullptr");
}
DAWN_TRY(ValidateSingleSType(chainedDescriptor,
wgpu::SType::ShaderModuleSPIRVDescriptor,
wgpu::SType::ShaderModuleWGSLDescriptor));
OwnedCompilationMessages* outMessages = parseResult->compilationMessages.get();
ScopedTintICEHandler scopedICEHandler(device);
switch (chainedDescriptor->sType) {
case wgpu::SType::ShaderModuleSPIRVDescriptor: {
const auto* spirvDesc =
static_cast<const ShaderModuleSPIRVDescriptor*>(chainedDescriptor);
const ShaderModuleSPIRVDescriptor* spirvDesc = nullptr;
FindInChain(chainedDescriptor, &spirvDesc);
const ShaderModuleWGSLDescriptor* wgslDesc = nullptr;
FindInChain(chainedDescriptor, &wgslDesc);
if (spirvDesc) {
std::vector<uint32_t> spirv(spirvDesc->code, spirvDesc->code + spirvDesc->codeSize);
if (device->IsToggleEnabled(Toggle::UseTintGenerator)) {
tint::Program program;
@ -1093,13 +1095,7 @@ namespace dawn_native {
}
parseResult->spirv = std::move(spirv);
}
break;
}
case wgpu::SType::ShaderModuleWGSLDescriptor: {
const auto* wgslDesc =
static_cast<const ShaderModuleWGSLDescriptor*>(chainedDescriptor);
} else if (wgslDesc) {
auto tintSource = std::make_unique<TintSource>("", wgslDesc->source);
tint::Program program;
@ -1124,10 +1120,6 @@ namespace dawn_native {
parseResult->spirv = std::move(spirv);
}
break;
}
default:
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
return {};
@ -1216,23 +1208,18 @@ namespace dawn_native {
ShaderModuleBase::ShaderModuleBase(DeviceBase* device, const ShaderModuleDescriptor* descriptor)
: CachedObject(device), mType(Type::Undefined) {
ASSERT(descriptor->nextInChain != nullptr);
switch (descriptor->nextInChain->sType) {
case wgpu::SType::ShaderModuleSPIRVDescriptor: {
const ShaderModuleSPIRVDescriptor* spirvDesc = nullptr;
FindInChain(descriptor->nextInChain, &spirvDesc);
const ShaderModuleWGSLDescriptor* wgslDesc = nullptr;
FindInChain(descriptor->nextInChain, &wgslDesc);
ASSERT(spirvDesc || wgslDesc);
if (spirvDesc) {
mType = Type::Spirv;
const auto* spirvDesc =
static_cast<const ShaderModuleSPIRVDescriptor*>(descriptor->nextInChain);
mOriginalSpirv.assign(spirvDesc->code, spirvDesc->code + spirvDesc->codeSize);
break;
}
case wgpu::SType::ShaderModuleWGSLDescriptor: {
} else if (wgslDesc) {
mType = Type::Wgsl;
const auto* wgslDesc =
static_cast<const ShaderModuleWGSLDescriptor*>(descriptor->nextInChain);
mWgsl = std::string(wgslDesc->source);
break;
}
default:
UNREACHABLE();
}
}

87
src/dawn_native/Surface.cpp
View File

@ -15,6 +15,7 @@
#include "dawn_native/Surface.h"
#include "common/Platform.h"
#include "dawn_native/ChainUtils_autogen.h"
#include "dawn_native/Instance.h"
#include "dawn_native/SwapChain.h"
@ -34,53 +35,45 @@ namespace dawn_native {
MaybeError ValidateSurfaceDescriptor(const InstanceBase* instance,
const SurfaceDescriptor* descriptor) {
// TODO(cwallez@chromium.org): Have some type of helper to iterate over all the chained
// structures.
if (descriptor->nextInChain == nullptr) {
return DAWN_VALIDATION_ERROR("Surface cannot be created with just the base descriptor");
}
const ChainedStruct* chainedDescriptor = descriptor->nextInChain;
if (chainedDescriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("Cannot specify two windows for a single surface");
}
DAWN_TRY(ValidateSingleSType(descriptor->nextInChain,
wgpu::SType::SurfaceDescriptorFromMetalLayer,
wgpu::SType::SurfaceDescriptorFromWindowsHWND,
wgpu::SType::SurfaceDescriptorFromXlib));
switch (chainedDescriptor->sType) {
#if defined(DAWN_ENABLE_BACKEND_METAL)
case wgpu::SType::SurfaceDescriptorFromMetalLayer: {
const SurfaceDescriptorFromMetalLayer* metalDesc =
static_cast<const SurfaceDescriptorFromMetalLayer*>(chainedDescriptor);
const SurfaceDescriptorFromMetalLayer* metalDesc = nullptr;
FindInChain(descriptor->nextInChain, &metalDesc);
if (!metalDesc) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
// Check that the layer is a CAMetalLayer (or a derived class).
if (!InheritsFromCAMetalLayer(metalDesc->layer)) {
return DAWN_VALIDATION_ERROR("layer must be a CAMetalLayer");
}
break;
}
#endif // defined(DAWN_ENABLE_BACKEND_METAL)
#if defined(DAWN_PLATFORM_WINDOWS)
case wgpu::SType::SurfaceDescriptorFromWindowsHWND: {
const SurfaceDescriptorFromWindowsHWND* hwndDesc =
static_cast<const SurfaceDescriptorFromWindowsHWND*>(chainedDescriptor);
// It is not possible to validate an HINSTANCE.
const SurfaceDescriptorFromWindowsHWND* hwndDesc = nullptr;
FindInChain(descriptor->nextInChain, &hwndDesc);
if (!hwndDesc) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
// Validate the hwnd using the windows.h IsWindow function.
if (IsWindow(static_cast<HWND>(hwndDesc->hwnd)) == 0) {
return DAWN_VALIDATION_ERROR("Invalid HWND");
}
break;
}
#endif // defined(DAWN_PLATFORM_WINDOWS)
#if defined(DAWN_USE_X11)
case wgpu::SType::SurfaceDescriptorFromXlib: {
const SurfaceDescriptorFromXlib* xDesc =
static_cast<const SurfaceDescriptorFromXlib*>(chainedDescriptor);
// It is not possible to validate an X Display.
const SurfaceDescriptorFromXlib* xDesc = nullptr;
FindInChain(descriptor->nextInChain, &xDesc);
if (!xDesc) {
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
// Check the validity of the window by calling a getter function on the window that
// returns a status code. If the window is bad the call return a status of zero. We
// need to set a temporary X11 error handler while doing this because the default
@ -95,52 +88,32 @@ namespace dawn_native {
if (status == 0) {
return DAWN_VALIDATION_ERROR("Invalid X Window");
}
break;
}
#endif // defined(DAWN_USE_X11)
case wgpu::SType::SurfaceDescriptorFromCanvasHTMLSelector:
default:
return DAWN_VALIDATION_ERROR("Unsupported sType");
}
return {};
}
Surface::Surface(InstanceBase* instance, const SurfaceDescriptor* descriptor)
: mInstance(instance) {
ASSERT(descriptor->nextInChain != nullptr);
const ChainedStruct* chainedDescriptor = descriptor->nextInChain;
switch (chainedDescriptor->sType) {
case wgpu::SType::SurfaceDescriptorFromMetalLayer: {
const SurfaceDescriptorFromMetalLayer* metalDesc =
static_cast<const SurfaceDescriptorFromMetalLayer*>(chainedDescriptor);
const SurfaceDescriptorFromMetalLayer* metalDesc = nullptr;
const SurfaceDescriptorFromWindowsHWND* hwndDesc = nullptr;
const SurfaceDescriptorFromXlib* xDesc = nullptr;
FindInChain(descriptor->nextInChain, &metalDesc);
FindInChain(descriptor->nextInChain, &hwndDesc);
FindInChain(descriptor->nextInChain, &xDesc);
ASSERT(metalDesc || hwndDesc || xDesc);
if (metalDesc) {
mType = Type::MetalLayer;
mMetalLayer = metalDesc->layer;
break;
}
case wgpu::SType::SurfaceDescriptorFromWindowsHWND: {
const SurfaceDescriptorFromWindowsHWND* hwndDesc =
static_cast<const SurfaceDescriptorFromWindowsHWND*>(chainedDescriptor);
} else if (hwndDesc) {
mType = Type::WindowsHWND;
mHInstance = hwndDesc->hinstance;
mHWND = hwndDesc->hwnd;
break;
}
case wgpu::SType::SurfaceDescriptorFromXlib: {
const SurfaceDescriptorFromXlib* xDesc =
static_cast<const SurfaceDescriptorFromXlib*>(chainedDescriptor);
} else if (xDesc) {
mType = Type::Xlib;
mXDisplay = xDesc->display;
mXWindow = xDesc->window;
break;
}
default:
UNREACHABLE();
}
}

1
src/tests/BUILD.gn
View File

@ -156,6 +156,7 @@ test("dawn_unittests") {
"unittests/BitSetIteratorTests.cpp",
"unittests/BuddyAllocatorTests.cpp",
"unittests/BuddyMemoryAllocatorTests.cpp",
"unittests/ChainUtilsTests.cpp",
"unittests/CommandAllocatorTests.cpp",
"unittests/EnumClassBitmasksTests.cpp",
"unittests/EnumMaskIteratorTests.cpp",

181
src/tests/unittests/ChainUtilsTests.cpp Normal file
View File

@ -0,0 +1,181 @@
// Copyright 2021 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 <gtest/gtest.h>
#include "dawn_native/ChainUtils_autogen.h"
#include "dawn_native/dawn_platform.h"
// Checks that we cannot find any structs in an empty chain
TEST(ChainUtilsTests, FindEmptyChain) {
const dawn_native::PrimitiveDepthClampingState* info = nullptr;
dawn_native::FindInChain(nullptr, &info);
ASSERT_EQ(nullptr, info);
}
// Checks that searching a chain for a present struct returns that struct
TEST(ChainUtilsTests, FindPresentInChain) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
chain1.nextInChain = &chain2;
const dawn_native::PrimitiveDepthClampingState* info1 = nullptr;
const dawn_native::ShaderModuleSPIRVDescriptor* info2 = nullptr;
dawn_native::FindInChain(&chain1, &info1);
dawn_native::FindInChain(&chain1, &info2);
ASSERT_NE(nullptr, info1);
ASSERT_NE(nullptr, info2);
}
// Checks that searching a chain for a struct that doesn't exist returns a nullptr
TEST(ChainUtilsTests, FindMissingInChain) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
chain1.nextInChain = &chain2;
const dawn_native::SurfaceDescriptorFromMetalLayer* info = nullptr;
dawn_native::FindInChain(&chain1, &info);
ASSERT_EQ(nullptr, info);
}
// Checks that validation rejects chains with duplicate STypes
TEST(ChainUtilsTests, ValidateDuplicateSTypes) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
dawn_native::PrimitiveDepthClampingState chain3;
chain1.nextInChain = &chain2;
chain2.nextInChain = &chain3;
dawn_native::MaybeError result = dawn_native::ValidateSTypes(&chain1, {});
ASSERT_TRUE(result.IsError());
result.AcquireError();
}
// Checks that validation rejects chains that contain unspecified STypes
TEST(ChainUtilsTests, ValidateUnspecifiedSTypes) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
dawn_native::ShaderModuleWGSLDescriptor chain3;
chain1.nextInChain = &chain2;
chain2.nextInChain = &chain3;
dawn_native::MaybeError result = dawn_native::ValidateSTypes(&chain1, {
{wgpu::SType::PrimitiveDepthClampingState},
{wgpu::SType::ShaderModuleSPIRVDescriptor},
});
ASSERT_TRUE(result.IsError());
result.AcquireError();
}
// Checks that validation rejects chains that contain multiple STypes from the same oneof
// constraint.
TEST(ChainUtilsTests, ValidateOneOfFailure) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
dawn_native::ShaderModuleWGSLDescriptor chain3;
chain1.nextInChain = &chain2;
chain2.nextInChain = &chain3;
dawn_native::MaybeError result = dawn_native::ValidateSTypes(&chain1,
{{wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::ShaderModuleWGSLDescriptor}});
ASSERT_TRUE(result.IsError());
result.AcquireError();
}
// Checks that validation accepts chains that match the constraints.
TEST(ChainUtilsTests, ValidateSuccess) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
chain1.nextInChain = &chain2;
dawn_native::MaybeError result = dawn_native::ValidateSTypes(&chain1, {
{wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::ShaderModuleWGSLDescriptor},
{wgpu::SType::PrimitiveDepthClampingState},
{wgpu::SType::SurfaceDescriptorFromMetalLayer},
});
ASSERT_TRUE(result.IsSuccess());
}
// Checks that validation always passes on empty chains.
TEST(ChainUtilsTests, ValidateEmptyChain) {
dawn_native::MaybeError result = dawn_native::ValidateSTypes(nullptr, {
{wgpu::SType::ShaderModuleSPIRVDescriptor},
{wgpu::SType::PrimitiveDepthClampingState},
});
ASSERT_TRUE(result.IsSuccess());
result = dawn_native::ValidateSTypes(nullptr, {});
ASSERT_TRUE(result.IsSuccess());
}
// Checks that singleton validation always passes on empty chains.
TEST(ChainUtilsTests, ValidateSingleEmptyChain) {
dawn_native::MaybeError result = dawn_native::ValidateSingleSType(nullptr,
wgpu::SType::ShaderModuleSPIRVDescriptor);
ASSERT_TRUE(result.IsSuccess());
result = dawn_native::ValidateSingleSType(nullptr,
wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::PrimitiveDepthClampingState);
ASSERT_TRUE(result.IsSuccess());
}
// Checks that singleton validation always fails on chains with multiple children.
TEST(ChainUtilsTests, ValidateSingleMultiChain) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::ShaderModuleSPIRVDescriptor chain2;
chain1.nextInChain = &chain2;
dawn_native::MaybeError result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::PrimitiveDepthClampingState);
ASSERT_TRUE(result.IsError());
result.AcquireError();
result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::PrimitiveDepthClampingState, wgpu::SType::ShaderModuleSPIRVDescriptor);
ASSERT_TRUE(result.IsError());
result.AcquireError();
}
// Checks that singleton validation passes when the oneof constraint is met.
TEST(ChainUtilsTests, ValidateSingleSatisfied) {
dawn_native::ShaderModuleWGSLDescriptor chain1;
dawn_native::MaybeError result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::ShaderModuleWGSLDescriptor);
ASSERT_TRUE(result.IsSuccess());
result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::ShaderModuleWGSLDescriptor);
ASSERT_TRUE(result.IsSuccess());
result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::ShaderModuleWGSLDescriptor, wgpu::SType::ShaderModuleSPIRVDescriptor);
ASSERT_TRUE(result.IsSuccess());
}
// Checks that singleton validation passes when the oneof constraint is not met.
TEST(ChainUtilsTests, ValidateSingleUnsatisfied) {
dawn_native::PrimitiveDepthClampingState chain1;
dawn_native::MaybeError result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::ShaderModuleWGSLDescriptor);
ASSERT_TRUE(result.IsError());
result.AcquireError();
result = dawn_native::ValidateSingleSType(&chain1,
wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::ShaderModuleWGSLDescriptor);
ASSERT_TRUE(result.IsError());
result.AcquireError();
}