| // Copyright 2020 The Tint 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 "src/tint/reader/spirv/enum_converter.h" |
| |
| #include <string> |
| |
| #include "gmock/gmock.h" |
| #include "src/tint/type/texture_dimension.h" |
| #include "src/tint/utils/string_stream.h" |
| |
| namespace tint::reader::spirv { |
| namespace { |
| |
| // Pipeline stage |
| |
| struct PipelineStageCase { |
| spv::ExecutionModel model; |
| bool expect_success; |
| ast::PipelineStage expected; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, PipelineStageCase psc) { |
| out << "PipelineStageCase{ spv::ExecutionModel:::" << int(psc.model) |
| << " expect_success?:" << int(psc.expect_success) << " expected:" << int(psc.expected) |
| << "}"; |
| return out; |
| } |
| |
| class SpvPipelineStageTest : public testing::TestWithParam<PipelineStageCase> { |
| public: |
| SpvPipelineStageTest() |
| : success_(true), fail_stream_(&success_, &errors_), converter_(fail_stream_) {} |
| |
| std::string error() const { return errors_.str(); } |
| |
| protected: |
| bool success_ = true; |
| utils::StringStream errors_; |
| FailStream fail_stream_; |
| EnumConverter converter_; |
| }; |
| |
| TEST_P(SpvPipelineStageTest, Samples) { |
| const auto params = GetParam(); |
| |
| const auto result = converter_.ToPipelineStage(params.model); |
| EXPECT_EQ(success_, params.expect_success); |
| if (params.expect_success) { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_TRUE(error().empty()); |
| } else { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_THAT(error(), ::testing::StartsWith("unknown SPIR-V execution model:")); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(EnumConverterGood, |
| SpvPipelineStageTest, |
| testing::Values(PipelineStageCase{spv::ExecutionModel::Vertex, true, |
| ast::PipelineStage::kVertex}, |
| PipelineStageCase{spv::ExecutionModel::Fragment, true, |
| ast::PipelineStage::kFragment}, |
| PipelineStageCase{spv::ExecutionModel::GLCompute, true, |
| ast::PipelineStage::kCompute})); |
| |
| INSTANTIATE_TEST_SUITE_P(EnumConverterBad, |
| SpvPipelineStageTest, |
| testing::Values(PipelineStageCase{static_cast<spv::ExecutionModel>(9999), |
| false, ast::PipelineStage::kNone}, |
| PipelineStageCase{spv::ExecutionModel::TessellationControl, |
| false, ast::PipelineStage::kNone})); |
| |
| // Storage class |
| |
| struct StorageClassCase { |
| spv::StorageClass sc; |
| bool expect_success; |
| builtin::AddressSpace expected; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) { |
| out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc) |
| << " expect_success?:" << int(scc.expect_success) << " expected:" << int(scc.expected) |
| << "}"; |
| return out; |
| } |
| |
| class SpvStorageClassTest : public testing::TestWithParam<StorageClassCase> { |
| public: |
| SpvStorageClassTest() |
| : success_(true), fail_stream_(&success_, &errors_), converter_(fail_stream_) {} |
| |
| std::string error() const { return errors_.str(); } |
| |
| protected: |
| bool success_ = true; |
| utils::StringStream errors_; |
| FailStream fail_stream_; |
| EnumConverter converter_; |
| }; |
| |
| TEST_P(SpvStorageClassTest, Samples) { |
| const auto params = GetParam(); |
| |
| const auto result = converter_.ToAddressSpace(params.sc); |
| EXPECT_EQ(success_, params.expect_success); |
| if (params.expect_success) { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_TRUE(error().empty()); |
| } else { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_THAT(error(), ::testing::StartsWith("unknown SPIR-V storage class: ")); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterGood, |
| SpvStorageClassTest, |
| testing::Values( |
| StorageClassCase{spv::StorageClass::Input, true, builtin::AddressSpace::kIn}, |
| StorageClassCase{spv::StorageClass::Output, true, builtin::AddressSpace::kOut}, |
| StorageClassCase{spv::StorageClass::Uniform, true, builtin::AddressSpace::kUniform}, |
| StorageClassCase{spv::StorageClass::Workgroup, true, builtin::AddressSpace::kWorkgroup}, |
| StorageClassCase{spv::StorageClass::UniformConstant, true, |
| builtin::AddressSpace::kUndefined}, |
| StorageClassCase{spv::StorageClass::StorageBuffer, true, builtin::AddressSpace::kStorage}, |
| StorageClassCase{spv::StorageClass::Private, true, builtin::AddressSpace::kPrivate}, |
| StorageClassCase{spv::StorageClass::Function, true, builtin::AddressSpace::kFunction})); |
| |
| INSTANTIATE_TEST_SUITE_P(EnumConverterBad, |
| SpvStorageClassTest, |
| testing::Values(StorageClassCase{static_cast<spv::StorageClass>(9999), |
| false, |
| builtin::AddressSpace::kUndefined})); |
| |
| // Builtin |
| |
| struct BuiltinCase { |
| spv::BuiltIn builtin; |
| bool expect_success; |
| builtin::BuiltinValue expected; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, BuiltinCase bc) { |
| out << "BuiltinCase{ spv::BuiltIn::" << int(bc.builtin) |
| << " expect_success?:" << int(bc.expect_success) << " expected:" << int(bc.expected) << "}"; |
| return out; |
| } |
| |
| class SpvBuiltinTest : public testing::TestWithParam<BuiltinCase> { |
| public: |
| SpvBuiltinTest() |
| : success_(true), fail_stream_(&success_, &errors_), converter_(fail_stream_) {} |
| |
| std::string error() const { return errors_.str(); } |
| |
| protected: |
| bool success_ = true; |
| utils::StringStream errors_; |
| FailStream fail_stream_; |
| EnumConverter converter_; |
| }; |
| |
| TEST_P(SpvBuiltinTest, Samples) { |
| const auto params = GetParam(); |
| |
| const auto result = converter_.ToBuiltin(params.builtin); |
| EXPECT_EQ(success_, params.expect_success); |
| if (params.expect_success) { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_TRUE(error().empty()); |
| } else { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_THAT(error(), ::testing::StartsWith("unknown SPIR-V builtin: ")); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterGood_Input, |
| SpvBuiltinTest, |
| testing::Values( |
| BuiltinCase{spv::BuiltIn::Position, true, builtin::BuiltinValue::kPosition}, |
| BuiltinCase{spv::BuiltIn::InstanceIndex, true, builtin::BuiltinValue::kInstanceIndex}, |
| BuiltinCase{spv::BuiltIn::FrontFacing, true, builtin::BuiltinValue::kFrontFacing}, |
| BuiltinCase{spv::BuiltIn::FragCoord, true, builtin::BuiltinValue::kPosition}, |
| BuiltinCase{spv::BuiltIn::LocalInvocationId, true, |
| builtin::BuiltinValue::kLocalInvocationId}, |
| BuiltinCase{spv::BuiltIn::LocalInvocationIndex, true, |
| builtin::BuiltinValue::kLocalInvocationIndex}, |
| BuiltinCase{spv::BuiltIn::GlobalInvocationId, true, |
| builtin::BuiltinValue::kGlobalInvocationId}, |
| BuiltinCase{spv::BuiltIn::NumWorkgroups, true, builtin::BuiltinValue::kNumWorkgroups}, |
| BuiltinCase{spv::BuiltIn::WorkgroupId, true, builtin::BuiltinValue::kWorkgroupId}, |
| BuiltinCase{spv::BuiltIn::SampleId, true, builtin::BuiltinValue::kSampleIndex}, |
| BuiltinCase{spv::BuiltIn::SampleMask, true, builtin::BuiltinValue::kSampleMask})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterGood_Output, |
| SpvBuiltinTest, |
| testing::Values(BuiltinCase{spv::BuiltIn::Position, true, builtin::BuiltinValue::kPosition}, |
| BuiltinCase{spv::BuiltIn::FragDepth, true, builtin::BuiltinValue::kFragDepth}, |
| BuiltinCase{spv::BuiltIn::SampleMask, true, |
| builtin::BuiltinValue::kSampleMask})); |
| |
| INSTANTIATE_TEST_SUITE_P(EnumConverterBad, |
| SpvBuiltinTest, |
| testing::Values(BuiltinCase{static_cast<spv::BuiltIn>(9999), false, |
| builtin::BuiltinValue::kUndefined}, |
| BuiltinCase{static_cast<spv::BuiltIn>(9999), false, |
| builtin::BuiltinValue::kUndefined})); |
| |
| // Dim |
| |
| struct DimCase { |
| spv::Dim dim; |
| bool arrayed; |
| bool expect_success; |
| type::TextureDimension expected; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, DimCase dc) { |
| out << "DimCase{ spv::Dim:::" << int(dc.dim) << " arrayed?:" << int(dc.arrayed) |
| << " expect_success?:" << int(dc.expect_success) << " expected:" << int(dc.expected) << "}"; |
| return out; |
| } |
| |
| class SpvDimTest : public testing::TestWithParam<DimCase> { |
| public: |
| SpvDimTest() : success_(true), fail_stream_(&success_, &errors_), converter_(fail_stream_) {} |
| |
| std::string error() const { return errors_.str(); } |
| |
| protected: |
| bool success_ = true; |
| utils::StringStream errors_; |
| FailStream fail_stream_; |
| EnumConverter converter_; |
| }; |
| |
| TEST_P(SpvDimTest, Samples) { |
| const auto params = GetParam(); |
| |
| const auto result = converter_.ToDim(params.dim, params.arrayed); |
| EXPECT_EQ(success_, params.expect_success); |
| if (params.expect_success) { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_TRUE(error().empty()); |
| } else { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_THAT(error(), ::testing::HasSubstr("dimension")); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(EnumConverterGood, |
| SpvDimTest, |
| testing::Values( |
| // Non-arrayed |
| DimCase{spv::Dim::Dim1D, false, true, type::TextureDimension::k1d}, |
| DimCase{spv::Dim::Dim2D, false, true, type::TextureDimension::k2d}, |
| DimCase{spv::Dim::Dim3D, false, true, type::TextureDimension::k3d}, |
| DimCase{spv::Dim::Cube, false, true, type::TextureDimension::kCube}, |
| // Arrayed |
| DimCase{spv::Dim::Dim2D, true, true, type::TextureDimension::k2dArray}, |
| DimCase{spv::Dim::Cube, true, true, |
| type::TextureDimension::kCubeArray})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterBad, |
| SpvDimTest, |
| testing::Values( |
| // Invalid SPIR-V dimensionality. |
| DimCase{spv::Dim::Max, false, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::Max, true, false, type::TextureDimension::kNone}, |
| // Vulkan non-arrayed dimensionalities not supported by WGSL. |
| DimCase{spv::Dim::Rect, false, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::Buffer, false, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::SubpassData, false, false, type::TextureDimension::kNone}, |
| // Arrayed dimensionalities not supported by WGSL |
| DimCase{spv::Dim::Dim3D, true, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::Rect, true, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::Buffer, true, false, type::TextureDimension::kNone}, |
| DimCase{spv::Dim::SubpassData, true, false, type::TextureDimension::kNone})); |
| |
| // TexelFormat |
| |
| struct TexelFormatCase { |
| spv::ImageFormat format; |
| bool expect_success; |
| builtin::TexelFormat expected; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, TexelFormatCase ifc) { |
| out << "TexelFormatCase{ spv::ImageFormat:::" << int(ifc.format) |
| << " expect_success?:" << int(ifc.expect_success) << " expected:" << int(ifc.expected) |
| << "}"; |
| return out; |
| } |
| |
| class SpvImageFormatTest : public testing::TestWithParam<TexelFormatCase> { |
| public: |
| SpvImageFormatTest() |
| : success_(true), fail_stream_(&success_, &errors_), converter_(fail_stream_) {} |
| |
| std::string error() const { return errors_.str(); } |
| |
| protected: |
| bool success_ = true; |
| utils::StringStream errors_; |
| FailStream fail_stream_; |
| EnumConverter converter_; |
| }; |
| |
| TEST_P(SpvImageFormatTest, Samples) { |
| const auto params = GetParam(); |
| |
| const auto result = converter_.ToTexelFormat(params.format); |
| EXPECT_EQ(success_, params.expect_success) << params; |
| if (params.expect_success) { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_TRUE(error().empty()); |
| } else { |
| EXPECT_EQ(result, params.expected); |
| EXPECT_THAT(error(), ::testing::StartsWith("invalid image format: ")); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterGood, |
| SpvImageFormatTest, |
| testing::Values( |
| // Unknown. This is used for sampled images. |
| TexelFormatCase{spv::ImageFormat::Unknown, true, builtin::TexelFormat::kUndefined}, |
| // 8 bit channels |
| TexelFormatCase{spv::ImageFormat::Rgba8, true, builtin::TexelFormat::kRgba8Unorm}, |
| TexelFormatCase{spv::ImageFormat::Rgba8Snorm, true, builtin::TexelFormat::kRgba8Snorm}, |
| TexelFormatCase{spv::ImageFormat::Rgba8ui, true, builtin::TexelFormat::kRgba8Uint}, |
| TexelFormatCase{spv::ImageFormat::Rgba8i, true, builtin::TexelFormat::kRgba8Sint}, |
| // 16 bit channels |
| TexelFormatCase{spv::ImageFormat::Rgba16ui, true, builtin::TexelFormat::kRgba16Uint}, |
| TexelFormatCase{spv::ImageFormat::Rgba16i, true, builtin::TexelFormat::kRgba16Sint}, |
| TexelFormatCase{spv::ImageFormat::Rgba16f, true, builtin::TexelFormat::kRgba16Float}, |
| // 32 bit channels |
| // ... 1 channel |
| TexelFormatCase{spv::ImageFormat::R32ui, true, builtin::TexelFormat::kR32Uint}, |
| TexelFormatCase{spv::ImageFormat::R32i, true, builtin::TexelFormat::kR32Sint}, |
| TexelFormatCase{spv::ImageFormat::R32f, true, builtin::TexelFormat::kR32Float}, |
| // ... 2 channels |
| TexelFormatCase{spv::ImageFormat::Rg32ui, true, builtin::TexelFormat::kRg32Uint}, |
| TexelFormatCase{spv::ImageFormat::Rg32i, true, builtin::TexelFormat::kRg32Sint}, |
| TexelFormatCase{spv::ImageFormat::Rg32f, true, builtin::TexelFormat::kRg32Float}, |
| // ... 4 channels |
| TexelFormatCase{spv::ImageFormat::Rgba32ui, true, builtin::TexelFormat::kRgba32Uint}, |
| TexelFormatCase{spv::ImageFormat::Rgba32i, true, builtin::TexelFormat::kRgba32Sint}, |
| TexelFormatCase{spv::ImageFormat::Rgba32f, true, builtin::TexelFormat::kRgba32Float})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnumConverterBad, |
| SpvImageFormatTest, |
| testing::Values( |
| // Scanning in order from the SPIR-V spec. |
| TexelFormatCase{spv::ImageFormat::Rg16f, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::R11fG11fB10f, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::R16f, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rgb10A2, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg16, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg8, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::R16, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::R8, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rgba16Snorm, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg16Snorm, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg8Snorm, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg16i, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg8i, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::R8i, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rgb10a2ui, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg16ui, false, builtin::TexelFormat::kUndefined}, |
| TexelFormatCase{spv::ImageFormat::Rg8ui, false, builtin::TexelFormat::kUndefined})); |
| |
| } // namespace |
| } // namespace tint::reader::spirv |
