AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-19 11:30:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
2046e24498
SPIRV-Tools/test/val/val_id_test.cpp

3866 lines
132 KiB
C++
Raw Normal View History

Extend copyright to 2016.
2016-01-07 18:44:22 +00:00
// Copyright (c) 2015-2016 The Khronos Group Inc.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// 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
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// 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.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Fix validation of array length.
2016-04-04 19:55:05 +00:00
#include <sstream>
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
#include <string>
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
#include "gmock/gmock.h"
Renaming test files to comply with Google style guide. Also posfixing test files with `_test' to make it more clear.
2016-09-22 15:05:30 +00:00
#include "test_fixture.h"
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
#include "unit_spirv.h"
#include "val_fixtures.h"
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// NOTE: The tests in this file are ONLY testing ID usage, there for the input
// SPIR-V does not follow the logical layout rules from the spec in all cases in
// order to makes the tests smaller. Validation of the whole module is handled
// in stages, ID validation is only one of these stages. All validation stages
// are stand alone.
Put test classes in anonymous namespace. Put TestFixture.h classes in a namespace. Remove unused #includes.
2015-08-31 19:24:32 +00:00
namespace {
Fix validation of array length.
2016-04-04 19:55:05 +00:00
using ::testing::ValuesIn;
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
using ::testing::HasSubstr;
Add tests for SubgroupDispatch. Introduced in v1.1, SubgroupDispatch adds the following: - two new execution modes - one new capability - two new opcodes Extend ValidateBase methods to take a spv_target_env. Replace the context_ member with ScopedContext inside the said methods. Give ScopedContext wider visibility by moving it outside TextToBinaryTestBase.
2016-04-21 19:46:08 +00:00
using spvtest::ScopedContext;
Fix validation of array length.
2016-04-04 19:55:05 +00:00
using std::ostringstream;
using std::string;
using std::vector;
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
using ValidateIdWithMessage = spvtest::ValidateBase<bool>;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string kGLSL450MemoryModel = R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpCapability Shader
Validation of OpEntryPoint usage. According to the SPIRV Spec (2.16.1): * There is at least one OpEntryPoint instruction, unless the Linkage capability is being used. * No function can be targeted by both an OpEntryPoint instruction and an OpFunctionCall instruction. Also updated unit tests to includ OpEntryPoint.
2017-01-09 16:10:52 +00:00
OpCapability Linkage
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpCapability Addresses
OpCapability Pipes
OpCapability LiteralSampler
OpCapability DeviceEnqueue
Adding validation for vector data rule. Number of components in a vector can be 2 or 3 or 4. If Vector16 capability is used, 8 and 16 components are also allowed. Also added unit tests for vector data rule.
2016-11-04 22:31:21 +00:00
OpCapability Vector16
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
OpCapability Int8
OpCapability Int16
OpCapability Int64
OpCapability Float64
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpMemoryModel Logical GLSL450
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string kOpenCLMemoryModel32 = R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpCapability Addresses
OpCapability Linkage
OpCapability Kernel
%1 = OpExtInstImport "OpenCL.std"
OpMemoryModel Physical32 OpenCL
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string kOpenCLMemoryModel64 = R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpCapability Addresses
OpCapability Linkage
OpCapability Kernel
OpCapability Int64
%1 = OpExtInstImport "OpenCL.std"
OpMemoryModel Physical64 OpenCL
)";
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
string sampledImageSetup = R"(
%void = OpTypeVoid
%typeFuncVoid = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%image_type = OpTypeImage %float 2D 0 0 0 1 Unknown
%_ptr_UniformConstant_img = OpTypePointer UniformConstant %image_type
%tex = OpVariable %_ptr_UniformConstant_img UniformConstant
%sampler_type = OpTypeSampler
%_ptr_UniformConstant_sam = OpTypePointer UniformConstant %sampler_type
%s = OpVariable %_ptr_UniformConstant_sam UniformConstant
%sampled_image_type = OpTypeSampledImage %image_type
%v2float = OpTypeVector %float 2
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%const_vec_1_1 = OpConstantComposite %v2float %float_1 %float_1
%const_vec_2_2 = OpConstantComposite %v2float %float_2 %float_2
%bool_type = OpTypeBool
%spec_true = OpSpecConstantTrue %bool_type
%main = OpFunction %void None %typeFuncVoid
%label_1 = OpLabel
%image_inst = OpLoad %image_type %tex
%sampler_inst = OpLoad %sampler_type %s
)";
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpUndef
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpName) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpName %2 "name"
%1 = OpTypeInt 32 0
%2 = OpTypePointer UniformConstant %1
%3 = OpVariable %2 UniformConstant)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberName %2 0 "foo"
%1 = OpTypeInt 32 0
%2 = OpTypeStruct %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberName %1 0 "foo"
%1 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpMemberName Type <id> '1' is not a struct type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameMemberBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberName %2 1 "foo"
%1 = OpTypeInt 32 0
%2 = OpTypeStruct %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpMemberName Member <id> '1' index is larger than "
"Type <id> '1's member count."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLineGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpString "/path/to/source.file"
Update core instruction syntax to Rev32 Many instructions added and a few changed structure. Workarounds: - Some operands can be enabled by either one of two capabilities. The spv_operand_desc_t does not handle that now. For now just select the first one. Fixes to tests: - OpLoopMerge now takes a mandatory continue target. - OpTypePipe drops the type argument. Pipes are opaque. - OpLine no longer takes a target ID argument. The ID validator was fixed the OpLine and OpTypePipe changes. Those were the only ID validator tests affected. The patch to the spec doc generator was updated so it handles the two-capability case, even if in an hacky way.
2015-09-24 19:45:59 +00:00
OpLine %1 0 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %2
%4 = OpVariable %3 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLineFileBad) {
string spirv = kGLSL450MemoryModel + R"(
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
%1 = OpTypeInt 32 0
OpLine %1 0 0
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpLine Target <id> '1' is not an OpString."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpDecorateGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %2 GLSLShared
%1 = OpTypeInt 64 0
%2 = OpTypeStruct %1 %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpDecorateBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %1 GLSLShared)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("forward referenced IDs have not been defined"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberDecorate %2 0 Uniform
%1 = OpTypeInt 32 0
%2 = OpTypeStruct %1 %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberDecorate %1 0 Uniform
%1 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpMemberDecorate Structure type <id> '1' is not a struct type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateMemberBad) {
string spirv = kGLSL450MemoryModel + R"(
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
OpMemberDecorate %1 3 Uniform
%int = OpTypeInt 32 0
%1 = OpTypeStruct %int %int)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Index 3 provided in OpMemberDecorate for struct <id> "
"1 is out of bounds. The structure has 2 members. "
"Largest valid index is 1."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpDecorationGroup
OpDecorate %1 Uniform
OpDecorate %1 GLSLShared
OpGroupDecorate %1 %3 %4
%2 = OpTypeInt 32 0
%3 = OpConstant %2 42
%4 = OpConstant %2 23)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateDecorationGroupBad) {
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
string spirv = R"(
OpCapability Shader
OpCapability Linkage
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpGroupDecorate %1 %2 %3
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
%3 = OpConstant %2 42)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpGroupDecorate Decoration group <id> '1' is not a "
"decoration group."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateTargetBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpDecorationGroup
OpDecorate %1 Uniform
OpDecorate %1 GLSLShared
OpGroupDecorate %1 %3
%2 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("forward referenced IDs have not been defined"));
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateDecorationGroupBad) {
string spirv = R"(
OpCapability Shader
OpCapability Linkage
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpGroupMemberDecorate %1 %2 0
%2 = OpTypeInt 32 0)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpGroupMemberDecorate Decoration group <id> '1' is "
"not a decoration group."));
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateIdNotStructBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpDecorationGroup
OpGroupMemberDecorate %1 %2 0
%2 = OpTypeInt 32 0)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpGroupMemberDecorate Structure type <id> '2' is not "
"a struct type."));
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateIndexOutOfBoundBad) {
string spirv = kGLSL450MemoryModel + R"(
OpDecorate %1 Offset 0
%1 = OpDecorationGroup
OpGroupMemberDecorate %1 %struct 3
%float = OpTypeFloat 32
%struct = OpTypeStruct %float %float %float
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Index 3 provided in OpGroupMemberDecorate for struct "
"<id> 2 is out of bounds. The structure has 3 members. "
"Largest valid index is 2."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: OpExtInst
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointGood) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointFunctionBad) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %1 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpEntryPoint Entry Point <id> '1' is not a function."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointParameterCountBad) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1 %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpEntryPoint Entry Point <id> '1's function parameter "
"count is not zero"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointReturnTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpEntryPoint Entry Point <id> '1's function return "
"type is not void."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointInterfaceIsNotVariableTypeBad) {
string spirv = R"(
OpCapability Shader
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main" %ptr_builtin_1
OpMemberDecorate %struct_1 0 BuiltIn InvocationId
%int = OpTypeInt 32 1
%void = OpTypeVoid
%func = OpTypeFunction %void
%struct_1 = OpTypeStruct %int
%ptr_builtin_1 = OpTypePointer Input %struct_1
%main = OpFunction %void None %func
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Interfaces passed to OpEntryPoint must be of type "
"OpTypeVariable. Found OpTypePointer."));
}
TEST_F(ValidateIdWithMessage, OpEntryPointInterfaceStorageClassBad) {
string spirv = R"(
OpCapability Shader
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main" %in_1
OpMemberDecorate %struct_1 0 BuiltIn InvocationId
%int = OpTypeInt 32 1
%void = OpTypeVoid
%func = OpTypeFunction %void
%struct_1 = OpTypeStruct %int
%ptr_builtin_1 = OpTypePointer Uniform %struct_1
%in_1 = OpVariable %ptr_builtin_1 Uniform
%main = OpFunction %void None %func
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpEntryPoint interfaces must be OpVariables with "
"Storage Class of Input(1) or Output(3). Found Storage "
"Class 2 for Entry Point id 1."));
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeGood) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpExecutionMode %3 LocalSize 1 1 1
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeEntryPointMissing) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpExecutionMode %3 LocalSize 1 1 1
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpExecutionMode Entry Point <id> '1' is not the Entry "
"Point operand of an OpEntryPoint."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeEntryPointBad) {
string spirv = kGLSL450MemoryModel + R"(
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
OpEntryPoint GLCompute %3 "" %a
OpExecutionMode %a LocalSize 1 1 1
%void = OpTypeVoid
%ptr = OpTypePointer Input %void
%a = OpVariable %ptr Input
%2 = OpTypeFunction %void
%3 = OpFunction %void None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpExecutionMode Entry Point <id> '2' is not the Entry "
"Point operand of an OpEntryPoint."));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorFloat) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorInt) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorUInt) {
string spirv = kGLSL450MemoryModel + R"(
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%1 = OpTypeInt 64 0
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorBool) {
string spirv = kGLSL450MemoryModel + R"(
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%1 = OpTypeBool
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorComponentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypePointer UniformConstant %1
%3 = OpTypeVector %2 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpTypeVector Component Type <id> '2' is not a scalar type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeMatrixGood) {
string spirv = kGLSL450MemoryModel + R"(
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
%1 = OpTypeFloat 32
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeVector %1 2
%3 = OpTypeMatrix %2 3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeMatrixColumnTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeMatrix %1 3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Columns in a matrix must be of type vector."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeSamplerGood) {
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
// In Rev31, OpTypeSampler takes no arguments.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%s = OpTypeSampler)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpTypeArray %1 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayElementTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpTypeArray %2 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpTypeArray Element Type <id> '2' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
// Signed or unsigned.
enum Signed { kSigned, kUnsigned };
// Creates an assembly snippet declaring OpTypeArray with the given length.
string MakeArrayLength(const string& len, Signed isSigned, int width) {
ostringstream ss;
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
ss << R"(
OpCapability Shader
OpCapability Linkage
OpCapability Int16
OpCapability Int64
)";
ss << "OpMemoryModel Logical GLSL450\n";
ss << " %t = OpTypeInt " << width << (isSigned == kSigned ? " 1" : " 0");
ss << " %l = OpConstant %t " << len;
ss << " %a = OpTypeArray %t %l";
Fix validation of array length.
2016-04-04 19:55:05 +00:00
return ss.str();
}
// Tests OpTypeArray. Parameter is the width (in bits) of the array-length's
// type.
class OpTypeArrayLengthTest
: public spvtest::TextToBinaryTestBase<::testing::TestWithParam<int>> {
protected:
OpTypeArrayLengthTest()
Fix MSVC error C2797.
2016-04-04 20:05:31 +00:00
: position_(spv_position_t{0, 0, 0}),
diagnostic_(spvDiagnosticCreate(&position_, "")) {}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
~OpTypeArrayLengthTest() { spvDiagnosticDestroy(diagnostic_); }
// Runs spvValidate() on v, printing any errors via spvDiagnosticPrint().
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
spv_result_t Val(const SpirvVector& v, const std::string &expected_err = "") {
Fix validation of array length.
2016-04-04 19:55:05 +00:00
spv_const_binary_t cbinary{v.data(), v.size()};
First tests for SPIR-V v1.1. Add test for named-barrier instructions and capability. Add spv_target_env as an optional argument to CompileSuccessfully() and CompileFailure(). Currently defaults to UNIVERSAL_1_0, though that could change in the future. Make spv_context a local variable in test methods instead of a TextToBinaryTestBase member. Introduce ScopedContext to make temp contexts easier.
2016-04-19 02:25:35 +00:00
const auto status =
spvValidate(ScopedContext().context, &cbinary, &diagnostic_);
Fix validation of array length.
2016-04-04 19:55:05 +00:00
if (status != SPV_SUCCESS) {
spvDiagnosticPrint(diagnostic_);
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(std::string(diagnostic_->error), HasSubstr(expected_err));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
return status;
}
private:
spv_position_t position_; // For creating diagnostic_.
spv_diagnostic diagnostic_;
};
TEST_P(OpTypeArrayLengthTest, LengthPositive) {
const int width = GetParam();
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("1", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("1", kUnsigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("2", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("2", kUnsigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("55", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("55", kUnsigned, width))));
const string fpad(width / 4 - 1, 'F');
EXPECT_EQ(
SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("0x7" + fpad, kSigned, width))));
EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(
MakeArrayLength("0xF" + fpad, kUnsigned, width))));
}
TEST_P(OpTypeArrayLengthTest, LengthZero) {
const int width = GetParam();
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("0", kSigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("0", kUnsigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
TEST_P(OpTypeArrayLengthTest, LengthNegative) {
const int width = GetParam();
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-1", kSigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-2", kSigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-123", kSigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
const string neg_max = "0x8" + string(width / 4 - 1, '0');
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_EQ(
SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength(neg_max, kSigned, width)),
"OpTypeArray Length <id> '2' default value must be at least 1."));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
// The only valid widths for integers are 8, 16, 32, and 64.
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
// Since the Int8 capability requires the Kernel capability, and the Kernel
// capability prohibits usage of signed integers, we can skip 8-bit integers
// here since the purpose of these tests is to check the validity of
// OpTypeArray, not OpTypeInt.
Fix validation of array length.
2016-04-04 19:55:05 +00:00
INSTANTIATE_TEST_CASE_P(Widths, OpTypeArrayLengthTest,
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
ValuesIn(vector<int>{16, 32, 64}));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthNull) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%len = OpConstantNull %i32
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpTypeArray Length <id> '2' default value must be at least 1."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthSpecConst) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%len = OpSpecConstant %i32 2
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthSpecConstOp) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%c1 = OpConstant %i32 1
%c2 = OpConstant %i32 2
%len = OpSpecConstantOp %i32 IAdd %c1 %c2
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeRuntimeArrayGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeRuntimeArray %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeRuntimeArrayBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
%3 = OpTypeRuntimeArray %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpTypeRuntimeArray Element Type <id> '2' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: Object of this type can only be created with OpVariable using the
// Unifrom Storage Class
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeStructGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 64
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %1
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpTypeStruct %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeStructMemberTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 64
%3 = OpConstant %2 0.0
%4 = OpTypeStruct %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpTypeStruct Member Type <id> '3' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePointerGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePointerBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpTypePointer Type <id> '2' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionReturnTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
%3 = OpTypeFunction %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpTypeFunction Return Type <id> '2' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionParameterBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpConstant %2 0
%4 = OpTypeFunction %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpTypeFunction Parameter Type <id> '3' is not a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePipeGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 16
Update core instruction syntax to Rev32 Many instructions added and a few changed structure. Workarounds: - Some operands can be enabled by either one of two capabilities. The spv_operand_desc_t does not handle that now. For now just select the first one. Fixes to tests: - OpLoopMerge now takes a mandatory continue target. - OpTypePipe drops the type argument. Pipes are opaque. - OpLine no longer takes a target ID argument. The ID validator was fixed the OpLine and OpTypePipe changes. Those were the only ID validator tests affected. The patch to the spec doc generator was updated so it handles the two-capability case, even if in an hacky way.
2015-09-24 19:45:59 +00:00
%3 = OpTypePipe ReadOnly)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantTrueGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantTrueBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpConstantTrue Result Type <id> '1' is not a boolean type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantFalseGood) {
string spirv = kGLSL450MemoryModel + R"(
Add an API parameter to choose assembly syntax format for assembler. Added a new enum for supported assembly syntax formats: Canonical Assembly Format (CAF) and Assignment Assembly Format (AAF). Updated assembler interface functions to support choice of assembly syntax format.
2015-09-10 18:00:00 +00:00
%1 = OpTypeBool
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantFalseBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpConstantFalse Result Type <id> '1' is not a boolean type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
%2 = OpConstant !1 !0)";
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
// The expected failure code is implementation dependent (currently
// INVALID_BINARY because the binary parser catches these cases) and may
// change over time, but this must always fail.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%4 = OpConstantComposite %2 %3 %3 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorWithUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%9 = OpUndef %1
%4 = OpConstantComposite %2 %3 %3 %3 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%4 = OpConstantComposite %1 %3 %3 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantComposite Result Type <id> '1' is not a composite type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpConstant %1 3.14
%5 = OpConstant %4 42 ; bad type for constant value
%6 = OpConstantComposite %2 %3 %5 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5's type does not match "
"Result Type <id> '2's vector element type."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
OpConstantCompositeVectorConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpConstant %1 3.14
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%5 = OpUndef %4 ; bad type for undef value
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpConstantComposite %2 %3 %5 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5's type does not match "
"Result Type <id> '2's vector element type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
String literals must be quoted.
2015-08-24 20:27:02 +00:00
%5 = OpConstant %1 0.0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpConstantComposite %2 %5 %5 %5 %4
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %2
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%11 = OpTypeVector %1 3
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpConstantComposite %11 %5 %5 %5
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '10' vector "
"component count does not match Result Type <id> '4's "
"vector component count."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
OpConstantCompositeMatrixConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%11 = OpTypeVector %1 3
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %11
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '10' vector "
"component count does not match Result Type <id> '4's "
"vector component count."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixColumnTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 32
%3 = OpTypeVector %1 2
%4 = OpTypeVector %3 2
%5 = OpTypeMatrix %2 2
%6 = OpConstant %1 42
%7 = OpConstant %2 3.14
%8 = OpConstantComposite %3 %6 %6
%9 = OpConstantComposite %4 %7 %7
%10 = OpConstantComposite %5 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Columns in a matrix must be of type vector."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpConstantComposite %3 %2 %2 %2 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayWithUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%9 = OpUndef %1
%3 = OpTypeArray %1 %2
%4 = OpConstantComposite %3 %2 %2 %2 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstConstituentBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
Adding validation for vector data rule. Number of components in a vector can be 2 or 3 or 4. If Vector16 capability is used, 8 and 16 components are also allowed. Also added unit tests for vector data rule.
2016-11-04 22:31:21 +00:00
%4 = OpConstantComposite %3 %2 %2 %2 %1)"; // Uses a type as operand
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '1' is not a "
"constant or undef."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
%6 = OpConstant %5 3.14 ; bad type for const value
%4 = OpConstantComposite %3 %2 %2 %2 %6)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5's type does "
"not match Result Type <id> '3's array element type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%6 = OpUndef %5 ; bad type for undef
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstantComposite %3 %2 %2 %2 %6)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5's type does "
"not match Result Type <id> '3's array element type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpConstant %2 4300000000
%6 = OpConstantComposite %3 %4 %4 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpUndef %2
%6 = OpConstantComposite %3 %4 %4 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructMemberTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpConstant %2 4300000000
%6 = OpConstantComposite %3 %4 %5 %4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5' type does "
"not match the Result Type <id> '3's member type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructMemberUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpUndef %2
%6 = OpConstantComposite %3 %4 %5 %4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantComposite Constituent <id> '5' type does "
"not match the Result Type <id> '3's member type."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantSamplerGood) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%float = OpTypeFloat 32
%samplerType = OpTypeSampler
%3 = OpConstantSampler %samplerType ClampToEdge 0 Nearest)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantSamplerResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpConstantSampler %1 Clamp 0 Nearest)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantSampler Result Type <id> '1' is not a sampler type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpConstantNull %1
%3 = OpTypeInt 32 0
%4 = OpConstantNull %3
%5 = OpTypeFloat 32
%6 = OpConstantNull %5
%7 = OpTypePointer UniformConstant %3
%8 = OpConstantNull %7
%9 = OpTypeEvent
%10 = OpConstantNull %9
%11 = OpTypeDeviceEvent
%12 = OpConstantNull %11
%13 = OpTypeReserveId
%14 = OpConstantNull %13
%15 = OpTypeQueue
%16 = OpConstantNull %15
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
%17 = OpTypeVector %5 2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%18 = OpConstantNull %17
%19 = OpTypeMatrix %17 2
%20 = OpConstantNull %19
%25 = OpConstant %3 8
%21 = OpTypeArray %3 %25
%22 = OpConstantNull %21
%23 = OpTypeStruct %3 %5 %1
%24 = OpConstantNull %23
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
%26 = OpTypeArray %17 %25
%27 = OpConstantNull %26
%28 = OpTypeStruct %7 %26 %26 %1
%29 = OpConstantNull %28
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullBasicBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantNull %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantNull Result Type <id> '1' cannot have a null value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullArrayBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%3 = OpTypeSampler
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 4
%5 = OpTypeArray %3 %4
%6 = OpConstantNull %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantNull Result Type <id> '4' cannot have a null value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullStructBad) {
string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%2 = OpTypeSampler
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %2 %2
%4 = OpConstantNull %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantNull Result Type <id> '2' cannot have a null value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullRuntimeArrayBad) {
string spirv = kGLSL450MemoryModel + R"(
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
%bool = OpTypeBool
%array = OpTypeRuntimeArray %bool
%null = OpConstantNull %array)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpConstantNull Result Type <id> '2' cannot have a null value."));
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantTrueGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpSpecConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantTrueBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpSpecConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Specialization constant must be a boolean type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantFalseGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpSpecConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantFalseBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpSpecConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Specialization constant must be a boolean type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpSpecConstant %1 42)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
%2 = OpSpecConstant !1 !4)";
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
// The expected failure code is implementation dependent (currently
// INVALID_BINARY because the binary parser catches these cases) and may
// change over time, but this must always fail.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Type Id 1 is not a scalar numeric type"));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: SpecConstantComposite specializes to a vector.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%4 = OpConstant %1 3.14
%5 = OpSpecConstantComposite %2 %3 %3 %4 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Vector of floats and Undefs.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorWithUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%5 = OpConstant %1 3.14
%9 = OpUndef %1
%4 = OpSpecConstantComposite %2 %3 %5 %3 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: result type is float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%4 = OpSpecConstantComposite %1 %3 %3 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(), HasSubstr("is not a composite type"));
}
// Invalid: Vector contains a mix of Int and Float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpSpecConstant %1 3.14
%5 = OpConstant %4 42 ; bad type for constant value
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5's type "
"does not match Result Type <id> '2's vector element "
"type."));
}
// Invalid: Constituent is not a constant
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeVectorConstituentNotConstantBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeInt 32 0
%4 = OpSpecConstant %1 3.14
%6 = OpSpecConstantComposite %2 %3 %4 %4 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '3' is not a "
"constant or undef."));
}
// Invalid: Vector contains a mix of Undef-int and Float.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeVectorConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpSpecConstant %1 3.14
%5 = OpUndef %4 ; bad type for undef value
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5's type "
"does not match Result Type <id> '2's vector element "
"type."));
}
// Invalid: Vector expects 3 components, but 4 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorNumComponentsBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 3
%3 = OpConstant %1 3.14
%5 = OpSpecConstant %1 4.0
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> count does "
"not match Result Type <id> '2's vector component "
"count."));
}
// Valid: 4x4 matrix of floats
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpSpecConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%9 = OpSpecConstantComposite %2 %5 %5 %5 %4
%10 = OpSpecConstantComposite %3 %6 %7 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Matrix in which one column is Undef
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpSpecConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %2
%10 = OpSpecConstantComposite %3 %6 %7 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Matrix in which the sizes of column vectors are not equal.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeVector %1 3
%4 = OpTypeMatrix %2 4
%5 = OpSpecConstant %1 1.0
%6 = OpConstant %1 0.0
%7 = OpSpecConstantComposite %2 %5 %6 %6 %6
%8 = OpSpecConstantComposite %2 %6 %5 %6 %6
%9 = OpSpecConstantComposite %2 %6 %6 %5 %6
%10 = OpSpecConstantComposite %3 %6 %6 %6
%11 = OpSpecConstantComposite %4 %7 %8 %9 %10)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '10' vector "
"component count does not match Result Type <id> '4's "
"vector component count."));
}
// Invalid: Matrix type expects 4 columns but only 3 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixNumColsBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpSpecConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%10 = OpSpecConstantComposite %3 %6 %7 %8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> count does "
"not match Result Type <id> '3's matrix column count."));
}
// Invalid: Composite contains a non-const/undef component
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeMatrixConstituentNotConstBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpConstant %1 0.0
%3 = OpTypeVector %1 4
%4 = OpTypeMatrix %3 4
%5 = OpSpecConstantComposite %3 %2 %2 %2 %2
%6 = OpSpecConstantComposite %4 %5 %5 %5 %1)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '1' is not a "
"constant composite or undef."));
}
// Invalid: Composite contains a column that is *not* a vector (it's an array)
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeInt 32 0
%3 = OpSpecConstant %2 4
%4 = OpConstant %1 0.0
%5 = OpTypeVector %1 4
%6 = OpTypeArray %2 %3
%7 = OpTypeMatrix %5 4
%8 = OpSpecConstantComposite %6 %3 %3 %3 %3
%9 = OpSpecConstantComposite %5 %4 %4 %4 %4
%10 = OpSpecConstantComposite %7 %9 %9 %9 %8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '8' type "
"does not match Result Type <id> '7's matrix column "
"type."));
}
// Invalid: Matrix with an Undef column of the wrong size.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeMatrixConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeVector %1 3
%4 = OpTypeMatrix %2 4
%5 = OpSpecConstant %1 1.0
%6 = OpSpecConstant %1 0.0
%7 = OpSpecConstantComposite %2 %5 %6 %6 %6
%8 = OpSpecConstantComposite %2 %6 %5 %6 %6
%9 = OpSpecConstantComposite %2 %6 %6 %5 %6
%10 = OpUndef %3
%11 = OpSpecConstantComposite %4 %7 %8 %9 %10)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '10' vector "
"component count does not match Result Type <id> '4's "
"vector component count."));
}
// Invalid: Matrix in which some columns are Int and some are Float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColumnTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 32
%3 = OpTypeVector %1 2
%4 = OpTypeVector %2 2
%5 = OpTypeMatrix %4 2
%6 = OpSpecConstant %1 42
%7 = OpConstant %2 3.14
%8 = OpSpecConstantComposite %3 %6 %6
%9 = OpSpecConstantComposite %4 %7 %7
%10 = OpSpecConstantComposite %5 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '8' "
"component type does not match Result Type <id> '5's "
"matrix column component type."));
}
// Valid: Array of integers
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%5 = OpConstant %1 5
%3 = OpTypeArray %1 %2
%6 = OpTypeArray %1 %5
%4 = OpSpecConstantComposite %3 %2 %2 %2 %2
%7 = OpSpecConstantComposite %3 %5 %5 %5 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Expecting an array of 4 components, but 3 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayNumComponentsBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpSpecConstantComposite %3 %2 %2 %2)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent count does not "
"match Result Type <id> '3's array length."));
}
// Valid: Array of Integers and Undef-int
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayWithUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%9 = OpUndef %1
%3 = OpTypeArray %1 %2
%4 = OpSpecConstantComposite %3 %2 %2 %2 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Array uses a type as operand.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstConstituentBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpSpecConstantComposite %3 %2 %2 %2 %1)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '1' is not a "
"constant or undef."));
}
// Invalid: Array has a mix of Int and Float components.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstituentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpTypeFloat 32
%5 = OpSpecConstant %4 3.14 ; bad type for const value
%6 = OpSpecConstantComposite %3 %2 %2 %2 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5's type "
"does not match Result Type <id> '3's array element "
"type."));
}
// Invalid: Array has a mix of Int and Undef-float.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeArrayConstituentUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
%6 = OpUndef %5 ; bad type for undef
%4 = OpSpecConstantComposite %3 %2 %2 %2 %6)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5's type "
"does not match Result Type <id> '3's array element "
"type."));
}
// Valid: Struct of {Int32,Int32,Int64}.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpSpecConstant %2 4300000000
%6 = OpSpecConstantComposite %3 %4 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: missing one int32 struct member.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeStructMissingComponentBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%3 = OpTypeStruct %1 %1 %1
%4 = OpConstant %1 42
%5 = OpSpecConstant %1 430
%6 = OpSpecConstantComposite %3 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '2' count "
"does not match Result Type <id> '2's struct member "
"count."));
}
// Valid: Struct uses Undef-int64.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructUndefGood) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
%6 = OpSpecConstantComposite %3 %4 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Composite contains non-const/undef component.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructNonConstBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
%6 = OpSpecConstantComposite %3 %4 %1 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '1' is not a "
"constant or undef."));
}
// Invalid: Struct component type does not match expected specialization type.
// Second component was expected to be Int32, but got Int64.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpSpecConstant %2 4300000000
%6 = OpSpecConstantComposite %3 %4 %5 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5' type "
"does not match the Result Type <id> '3's member "
"type."));
}
// Invalid: Undef-int64 used when Int32 was expected.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberUndefTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
%6 = OpSpecConstantComposite %3 %4 %5 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> '5' type "
"does not match the Result Type <id> '3's member "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: OpSpecConstantOp
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpVariableGood) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
%3 = OpVariable %2 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerConstantGood) {
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpConstant %1 42
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%4 = OpVariable %2 Input %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerGlobalVariableGood) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%2 = OpTypePointer Uniform %1
%3 = OpVariable %2 Uniform
%4 = OpTypePointer Uniform %2 ; pointer to pointer
%5 = OpVariable %4 Uniform %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: Positive test OpVariable with OpConstantNull of OpTypePointer
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpVariableResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpVariable %1 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpVariable Result Type <id> '1' is not a pointer type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsTypeBad) {
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
%3 = OpVariable %2 Input %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpVariable Initializer <id> '2' is not a constant or "
"module-scope variable"));
}
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsFunctionVarBad) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%int = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%ptrint = OpTypePointer Function %int
%ptrptrint = OpTypePointer Function %ptrint
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%var = OpVariable %ptrint Function
%varinit = OpVariable %ptrptrint Function %var ; Can't initialize function variable.
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpVariable Initializer <id> '8' is not a constant or "
"module-scope variable"));
}
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsModuleVarGood) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%int = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%ptrint = OpTypePointer Uniform %int
%mvar = OpVariable %ptrint Uniform
%ptrptrint = OpTypePointer Function %ptrint
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%goodvar = OpVariable %ptrptrint Function %mvar ; This is ok
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpVariable %3 UniformConstant
%6 = OpFunction %1 None %4
%7 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
%8 = OpLoad %2 %5
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%9 = OpReturn
%10 = OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpVariable %3 UniformConstant
%6 = OpFunction %1 None %4
%7 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
%8 = OpLoad %3 %5
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpLoad Result Type <id> '3' does not match Pointer "
"<id> '5's type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadPointerBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%9 = OpTypeFloat 32
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%6 = OpFunction %1 None %4
%7 = OpLabel
%8 = OpLoad %9 %3
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpLoad Pointer <id> '4' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %5
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStorePointerBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %3 %5
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Pointer <id> '3' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreObjectGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %7
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Object <id> '7's type is void."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%9 = OpTypeFloat 32
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpConstant %9 3.14
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %5
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Pointer <id> '7's type does not match Object "
"<id> '3's type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreVoid) {
string spirv = kGLSL450MemoryModel + R"(
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
%9 = OpFunctionCall %1 %7
OpStore %6 %9
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Object <id> '8's type is void."));
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreLabel) {
string spirv = kGLSL450MemoryModel + R"(
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %8
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Object <id> '7' is not an object."));
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
// TODO: enable when this bug is fixed:
// https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, DISABLED_OpStoreFunction) {
string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %2
%5 = OpConstant %2 123
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %2 None %4
%8 = OpLabel
OpStore %6 %7
OpReturnValue %5
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpConstant %2 42
%5 = OpVariable %3 UniformConstant %4
%6 = OpTypePointer Function %2
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %6 Function
OpCopyMemory %10 %5 None
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpConstant %2 42
%5 = OpVariable %3 UniformConstant %4
%11 = OpTypeFloat 32
%6 = OpTypePointer Function %11
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %6 Function
OpCopyMemory %10 %5 None
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCopyMemory Target <id> '5's type does not match "
"Source <id> '2's type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: OpCopyMemorySized
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %5 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedTargetBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
OpCopyMemorySized %9 %6 %5 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCopyMemorySized Target <id> '9' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSourceBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpTypeFunction %1
%7 = OpFunction %1 None %6
%8 = OpLabel
%9 = OpVariable %4 Function
OpCopyMemorySized %9 %6 %5 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCopyMemorySized Source <id> '6' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %6 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCopyMemorySized Size <id> '6's variable type is not "
"an integer type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%11 = OpTypeFloat 32
%12 = OpConstant %11 1.0
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %12 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"OpCopyMemorySized Size <id> '9's type is not an integer type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
const char kDeeplyNestedStructureSetup[] = R"(
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%int = OpTypeInt 32 0
%float = OpTypeFloat 32
%v3float = OpTypeVector %float 3
%mat4x3 = OpTypeMatrix %v3float 4
%_ptr_Private_mat4x3 = OpTypePointer Private %mat4x3
%_ptr_Private_float = OpTypePointer Private %float
%my_matrix = OpVariable %_ptr_Private_mat4x3 Private
%my_float_var = OpVariable %_ptr_Private_float Private
%_ptr_Function_float = OpTypePointer Function %float
%int_0 = OpConstant %int 0
%int_1 = OpConstant %int 1
%int_2 = OpConstant %int 2
%int_3 = OpConstant %int 3
%int_5 = OpConstant %int 5
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
; Making the following nested structures.
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
;
; struct S {
; bool b;
; vec4 v[5];
; int i;
; mat4x3 m[5];
; }
; uniform blockName {
; S s;
; bool cond;
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
; RunTimeArray arr;
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
; }
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
%f32arr = OpTypeRuntimeArray %float
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%bool = OpTypeBool
%v4float = OpTypeVector %float 4
%array5_mat4x3 = OpTypeArray %mat4x3 %int_5
%array5_vec4 = OpTypeArray %v4float %int_5
%_ptr_Uniform_float = OpTypePointer Uniform %float
%_ptr_Function_vec4 = OpTypePointer Function %v4float
%_ptr_Uniform_vec4 = OpTypePointer Uniform %v4float
%struct_s = OpTypeStruct %bool %array5_vec4 %int %array5_mat4x3
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
%struct_blockName = OpTypeStruct %struct_s %bool %f32arr
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%_ptr_Uniform_blockName = OpTypePointer Uniform %struct_blockName
%_ptr_Uniform_struct_s = OpTypePointer Uniform %struct_s
%_ptr_Uniform_array5_mat4x3 = OpTypePointer Uniform %array5_mat4x3
%_ptr_Uniform_mat4x3 = OpTypePointer Uniform %mat4x3
%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
%blockName_var = OpVariable %_ptr_Uniform_blockName Uniform
%spec_int = OpSpecConstant %int 2
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// In what follows, Access Chain Instruction refers to one of the following:
// OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, and
// OpInBoundsPtrAccessChain
using AccessChainInstructionTest = spvtest::ValidateBase<std::string>;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
// Determines whether the access chain instruction requires the 'element id'
// argument.
bool AccessChainRequiresElemId(const std::string& instr) {
return (instr == "OpPtrAccessChain" || instr == "OpInBoundsPtrAccessChain");
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Valid: Access a float in a matrix using an access chain instruction.
TEST_P(AccessChainInstructionTest, AccessChainGood) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup +
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
"%float_entry = " + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %my_matrix )" + elem + R"(%int_0 %int_1
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
OpReturn
OpFunctionEnd
)";
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The result type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainResultTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%float_entry = )" +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
instr + R"( %float %my_matrix )" + elem + R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The Result Type of " + instr +
" <id> '36' must be "
"OpTypePointer. Found OpTypeFloat.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainBaseTypeVoidBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%float_entry = )" +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
instr + " %_ptr_Private_float %void " + elem + R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The Base <id> '1' in " + instr +
" instruction must "
"be a pointer.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainBaseTypeNonPtrVariableBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %_ptr_Private_float )" + elem +
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The Base <id> '8' in " + instr +
" instruction must "
"be a pointer.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: The storage class of Base and Result do not match.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainResultAndBaseStorageClassDoesntMatchBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Function_float %my_matrix )" + elem +
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"The result pointer storage class and base pointer storage class in " +
instr + " do not match.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must point to a
// composite object.
TEST_P(AccessChainInstructionTest,
AccessChainBasePtrNotPointingToCompositeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %my_float_var )" + elem + R"(%int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
// Valid. No Indexes were passed to the access chain instruction. The Result
// Type is the same as the Base type.
TEST_P(AccessChainInstructionTest, AccessChainNoIndexesGood) {
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %my_float_var )" + elem + R"(
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid. No Indexes were passed to the access chain instruction, but the
// Result Type is different from the Base type.
TEST_P(AccessChainInstructionTest, AccessChainNoIndexesBad) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
%entry = )" + instr +
R"( %_ptr_Private_mat4x3 %my_float_var )" + elem + R"(
OpReturn
OpFunctionEnd
)";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("result type (OpTypeMatrix) does not match the type that "
"results from indexing into the base <id> (OpTypeFloat)."));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Valid: 255 indexes passed to the access chain instruction. Limit is 255.
TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesGood) {
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
int depth = 255;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
std::string header = kGLSL450MemoryModel + kDeeplyNestedStructureSetup;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
header.erase(header.find("%func"));
std::ostringstream spirv;
spirv << header << "\n";
// Build nested structures. Struct 'i' contains struct 'i-1'
spirv << "%s_depth_1 = OpTypeStruct %float\n";
for (int i = 2; i <= depth; ++i) {
spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n";
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Define Pointer and Variable to use for the AccessChain instruction.
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_"
<< depth << "\n";
spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n";
// Function Start
spirv << R"(
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// AccessChain with 'n' indexes (n = depth)
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
for (int i = 0; i < depth; ++i) {
spirv << " %int_0";
}
// Function end
spirv << R"(
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: 256 indexes passed to the access chain instruction. Limit is 255.
TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
std::ostringstream spirv;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
for (int i = 0; i < 256; ++i) {
spirv << " %int_0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The number of indexes in " + instr +
" may not exceed 255. Found 256 indexes.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Add command line options struct for the validator The limit for the number of struct members is parameterized using command line options. Add --max-struct-depth command line option. Add --max-switch-branches command line option. Add --max-function-args command line option. Add --max-control-flow-nesting-depth option. Add --max-access-chain-indexes option.
2017-02-15 18:29:33 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
}
// Valid: 10 indexes passed to the access chain instruction. (Custom limit: 10)
TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesGood) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
int depth = 10;
std::string header = kGLSL450MemoryModel + kDeeplyNestedStructureSetup;
header.erase(header.find("%func"));
std::ostringstream spirv;
spirv << header << "\n";
// Build nested structures. Struct 'i' contains struct 'i-1'
spirv << "%s_depth_1 = OpTypeStruct %float\n";
for (int i = 2; i <= depth; ++i) {
spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n";
}
// Define Pointer and Variable to use for the AccessChain instruction.
spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_"
<< depth << "\n";
spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n";
// Function Start
spirv << R"(
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
// AccessChain with 'n' indexes (n = depth)
spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem;
for (int i = 0; i < depth; ++i) {
spirv << " %int_0";
}
// Function end
spirv << R"(
OpReturn
OpFunctionEnd
)";
spvValidatorOptionsSetUniversalLimit(
options_, spv_validator_limit_max_access_chain_indexes, 10u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: 11 indexes passed to the access chain instruction. Custom Limit:10
TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesBad) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
std::ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem;
for (int i = 0; i < 11; ++i) {
spirv << " %int_0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
const std::string expected_err = "The number of indexes in " + instr +
" may not exceed 10. Found 11 indexes.";
spvValidatorOptionsSetUniversalLimit(
options_, spv_validator_limit_max_access_chain_indexes, 10u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: Index passed to the access chain instruction is float (must be
// integer).
TEST_P(AccessChainInstructionTest, AccessChainUndefinedIndexBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %my_matrix )" + elem + R"(%float %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"Indexes passed to " + instr + " must be of type integer.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: The index argument that indexes into a struct must be of type
// OpConstant.
TEST_P(AccessChainInstructionTest, AccessChainStructIndexNotConstantBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
%f = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" +
elem + R"(%int_0 %spec_int %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"The <id> passed to " + instr +
" to index into a structure must be an OpConstant.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Indexing up to a vec4 granularity, but result type expected float.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainStructResultTypeDoesntMatchIndexedTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_0 %int_1 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" result type (OpTypeFloat) does not match "
"the type that results from indexing into "
"the base <id> (OpTypeVector).";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Reach non-composite type (bool) when unused indexes remain.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainStructTooManyIndexesBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_0 %int_2 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Trying to find index 3 of the struct that has only 3 members.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainStructIndexOutOfBoundBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_3 %int_2 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
const std::string expected_err = "Index is out of bounds: " + instr +
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
" can not find index 3 into the structure "
"<id> '26'. This structure has 3 members. "
"Largest valid index is 2.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Valid: Tests that we can index into Struct, Array, Matrix, and Vector!
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoAllTypesGood) {
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
ostringstream spirv;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%ss = " << instr << " %_ptr_Uniform_struct_s %blockName_var "
<< elem << "%int_0" << std::endl;
spirv << "%sa = " << instr << " %_ptr_Uniform_array5_mat4x3 %blockName_var "
<< elem << "%int_0 %int_3" << std::endl;
spirv << "%sm = " << instr << " %_ptr_Uniform_mat4x3 %blockName_var " << elem
<< "%int_0 %int_3 %int_1" << std::endl;
spirv << "%sc = " << instr << " %_ptr_Uniform_v3float %blockName_var " << elem
<< "%int_0 %int_3 %int_1 %int_2" << std::endl;
spirv << "%entry = " << instr << " %_ptr_Uniform_float %blockName_var "
<< elem << "%int_0 %int_3 %int_1 %int_2 %int_0" << std::endl;
spirv << R"(
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
CompileSuccessfully(spirv.str());
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Access an element of OpTypeRuntimeArray.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayGood) {
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%runtime_arr_entry = )" +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
instr +
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_2 %int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Unused index when accessing OpTypeRuntimeArray.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%runtime_arr_entry = )" +
instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_2 %int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
instr +
" reached non-composite type while indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: Reached scalar type before arguments to the access chain instruction
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
// finished.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainMatrixMoreArgsThanNeededBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_float %my_matrix )" + elem +
R"(%int_0 %int_1 %int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: The result type and the type indexed into do not match.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainResultTypeDoesntMatchIndexedTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%entry = )" + instr +
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
R"( %_ptr_Private_mat4x3 %my_matrix )" + elem +
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" result type (OpTypeMatrix) does not match "
"the type that results from indexing into "
"the base <id> (OpTypeFloat).";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Run tests for Access Chain Instructions.
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
INSTANTIATE_TEST_CASE_P(
CheckAccessChainInstructions, AccessChainInstructionTest,
::testing::Values("OpAccessChain", "OpInBoundsAccessChain",
"OpPtrAccessChain", "OpInBoundsPtrAccessChain"));
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpArrayLength
// TODO: OpImagePointer
// TODO: OpGenericPtrMemSemantics
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeFunction %1 %2 %2
%4 = OpFunction %1 None %3
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%5 = OpLabel
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%3 = OpConstant %2 42
%4 = OpTypeFunction %1 %2 %2
%5 = OpFunction %2 None %4
%6 = OpLabel
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpFunction Result Type <id> '2' does not match the "
"Function Type <id> '2's return type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionFunctionTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpFunction %1 None %2
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%5 = OpLabel
OpReturn
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpFunction Function Type <id> '2' is not a function type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %2
%6 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterMultipleGood) {
string spirv = kGLSL450MemoryModel + R"(
Basic SSA Validation Most uses of an ID must occur after the definition of the ID. Forward references are allowed for things like OpName, OpDecorate, and various cases of control-flow instructions such as OpBranch, OpPhi, and OpFunctionCall. TODO: Use CFG analysis for SSA checks. In particular, an ID defined inside a function body is only usable inside that function body. Also, use dominator info to catch some failing cases. Also: * Validator test cases use (standard) assignment form. * Update style to more closely follow the Google C++ style guide * Remove color-diagnostics flag. This is enabled by default on terminals with color. Prints hidden ASCII for terminals that can't handle color(Emacs) * Pass functors to SSAPass to check if the operand can be forward referenced based on its index value * Return SPV_ERROR_INVALID_ID for ID related errors spvBinaryParse returned SPV_ERROR_INVALID_BINARY for all types of errors. Since spvBinaryParse does some ID validation, this was returning inappropriate error codes for some tests. * Common fixture for validation tests. It only runs certian validation passes. * Add a SPV_VALIDATE_SSA_BIT for testing purposes * Fixtures now return error codes * Add OpName support in diag message and unit tests * Binary parsing can fail with invalid ID or invalid binary error code Tests include: * OpDecorate * OpName * OpMemberName * OpBranchConditional * OpSelectionMerge * OpMemberDecorate * OpGroupDecorate * OpDeviceEnqueue * Enable several tests failing in ID validation.
2015-11-18 20:43:43 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %2
%6 = OpFunctionParameter %2
%7 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Basic SSA Validation Most uses of an ID must occur after the definition of the ID. Forward references are allowed for things like OpName, OpDecorate, and various cases of control-flow instructions such as OpBranch, OpPhi, and OpFunctionCall. TODO: Use CFG analysis for SSA checks. In particular, an ID defined inside a function body is only usable inside that function body. Also, use dominator info to catch some failing cases. Also: * Validator test cases use (standard) assignment form. * Update style to more closely follow the Google C++ style guide * Remove color-diagnostics flag. This is enabled by default on terminals with color. Prints hidden ASCII for terminals that can't handle color(Emacs) * Pass functors to SSAPass to check if the operand can be forward referenced based on its index value * Return SPV_ERROR_INVALID_ID for ID related errors spvBinaryParse returned SPV_ERROR_INVALID_BINARY for all types of errors. Since spvBinaryParse does some ID validation, this was returning inappropriate error codes for some tests. * Common fixture for validation tests. It only runs certian validation passes. * Add a SPV_VALIDATE_SSA_BIT for testing purposes * Fixtures now return error codes * Add OpName support in diag message and unit tests * Binary parsing can fail with invalid ID or invalid binary error code Tests include: * OpDecorate * OpName * OpMemberName * OpBranchConditional * OpSelectionMerge * OpMemberDecorate * OpGroupDecorate * OpDeviceEnqueue * Enable several tests failing in ID validation.
2015-11-18 20:43:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %1
%6 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpFunctionParameter Result Type <id> '1' does not match the "
"OpTypeFunction parameter type of the same index."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
OpReturnValue %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %6 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallResultTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
%9 = OpIAdd %2 %7 %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %1 %6 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpFunctionCall Result Type <id> '1's type does not "
"match Function <id> '2's return type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallFunctionBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %5 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpFunctionCall Function <id> '5' is not a function."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallArgumentTypeBad) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%13 = OpTypeFloat 32
%14 = OpConstant %13 3.14
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
%9 = OpIAdd %2 %7 %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %6 %14
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpFunctionCall Argument <id> '7's type does not match "
"Function <id> '2's parameter type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
// Valid: OpSampledImage result <id> is used in the same block by
// OpImageSampleImplictLod
TEST_F(ValidateIdWithMessage, OpSampledImageGood) {
string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: OpSampledImage result <id> is defined in one block and used in a
// different block.
TEST_F(ValidateIdWithMessage, OpSampledImageUsedInDifferentBlockBad) {
string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
OpBranch %label_2
%label_2 = OpLabel
%si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("All OpSampledImage instructions must be in the same block in "
"which their Result <id> are consumed. OpSampledImage Result "
"Type <id> '23' has a consumer in a different basic block. The "
"consumer instruction <id> is '25'."));
}
// Invalid: OpSampledImage result <id> is used by OpSelect
// Note: According to the Spec, OpSelect parameters must be either a scalar or a
// vector. Therefore, OpTypeSampledImage is an illegal parameter for OpSelect.
// However, the OpSelect validation does not catch this today. Therefore, it is
// caught by the OpSampledImage validation. If the OpSelect validation code is
// updated, the error message for this test may change.
TEST_F(ValidateIdWithMessage, OpSampledImageUsedInOpSelectBad) {
string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%select_img = OpSelect %sampled_image_type %spec_true %smpld_img %smpld_img
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Result <id> from OpSampledImage instruction must not "
"appear as operands of OpSelect. Found result <id> "
"'23' as an operand of <id> '24'."));
}
// Invalid: OpSampledImage result <id> is used by OpPhi
TEST_F(ValidateIdWithMessage, OpSampledImageUsedInOpPhiBad) {
string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%phi_result = OpPhi %sampled_image_type %smpld_img %label_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Result <id> from OpSampledImage instruction must not "
"appear as operands of OpPhi. Found result <id> '23' "
"as an operand of <id> '24'."));
}
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
// Valid: Get a float in a matrix using CompositeExtract.
// Valid: Insert float into a matrix using CompositeInsert.
TEST_F(ValidateIdWithMessage, CompositeExtractInsertGood) {
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%float_entry = OpCompositeExtract %float %matrix 0 1" << std::endl;
// To test CompositeInsert, insert the object back in after extraction.
spirv << "%new_composite = OpCompositeInsert %mat4x3 %float_entry %matrix 0 1"
<< std::endl;
spirv << R"(OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid. Tests both CompositeExtract and CompositeInsert with 255 indexes.
TEST_F(ValidateIdWithMessage, CompositeExtractInsertLimitsGood) {
int depth = 255;
std::string header = kGLSL450MemoryModel + kDeeplyNestedStructureSetup;
header.erase(header.find("%func"));
std::ostringstream spirv;
spirv << header << std::endl;
// Build nested structures. Struct 'i' contains struct 'i-1'
spirv << "%s_depth_1 = OpTypeStruct %float\n";
for (int i = 2; i <= depth; ++i) {
spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n";
}
// Define Pointer and Variable to use for CompositeExtract/Insert.
spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_"
<< depth << "\n";
spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n";
// Function Start
spirv << R"(
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
// OpCompositeExtract/Insert with 'n' indexes (n = depth)
spirv << "%deep = OpLoad %s_depth_" << depth << " %deep_var" << std::endl;
spirv << "%entry = OpCompositeExtract %float %deep";
for (int i = 0; i < depth; ++i) {
spirv << " 0";
}
spirv << std::endl;
spirv << "%new_composite = OpCompositeInsert %s_depth_" << depth
<< " %entry %deep";
for (int i = 0; i < depth; ++i) {
spirv << " 0";
}
spirv << std::endl;
// Function end
spirv << R"(
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: 256 indexes passed to OpCompositeExtract. Limit is 255.
TEST_F(ValidateIdWithMessage, CompositeExtractArgCountExceededLimitBad) {
std::ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%entry = OpCompositeExtract %float %matrix";
for (int i = 0; i < 256; ++i) {
spirv << " 0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The number of indexes in OpCompositeExtract may not "
"exceed 255. Found 256 indexes."));
}
// Invalid: 256 indexes passed to OpCompositeInsert. Limit is 255.
TEST_F(ValidateIdWithMessage, CompositeInsertArgCountExceededLimitBad) {
std::ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%new_composite = OpCompositeInsert %mat4x3 %int_0 %matrix";
for (int i = 0; i < 256; ++i) {
spirv << " 0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The number of indexes in OpCompositeInsert may not "
"exceed 255. Found 256 indexes."));
}
// Invalid: In OpCompositeInsert, result type must be the same as composite type
TEST_F(ValidateIdWithMessage, CompositeInsertWrongResultTypeBad) {
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%float_entry = OpCompositeExtract %float %matrix 0 1" << std::endl;
spirv << "%new_composite = OpCompositeInsert %float %float_entry %matrix 0 1"
<< std::endl;
spirv << R"(OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The Result Type must be the same as Composite type"));
}
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
// Valid: No Indexes were passed to OpCompositeExtract, and the Result Type is
// the same as the Base Composite type.
TEST_F(ValidateIdWithMessage, CompositeExtractNoIndexesGood) {
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%float_entry = OpCompositeExtract %mat4x3 %matrix" << std::endl;
spirv << R"(OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: No Indexes were passed to OpCompositeExtract, but the Result Type is
// different from the Base Composite type.
TEST_F(ValidateIdWithMessage, CompositeExtractNoIndexesBad) {
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%float_entry = OpCompositeExtract %float %matrix" << std::endl;
spirv << R"(OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
HasSubstr("OpCompositeExtract result type (OpTypeFloat) does not "
"match the type that results from indexing into the "
"composite (OpTypeMatrix)."));
}
// Valid: No Indexes were passed to OpCompositeInsert, and the type of the
// Object<id> argument matches the Composite type.
TEST_F(ValidateIdWithMessage, CompositeInsertMissingIndexesGood) {
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%matrix_2 = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%new_composite = OpCompositeInsert %mat4x3 %matrix_2 %matrix";
spirv << R"(
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
}
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
// Invalid: No Indexes were passed to OpCompositeInsert, but the type of the
// Object<id> argument does not match the Composite type.
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
TEST_F(ValidateIdWithMessage, CompositeInsertMissingIndexesBad) {
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%new_composite = OpCompositeInsert %mat4x3 %int_0 %matrix";
spirv << R"(
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
HasSubstr("The Object type (OpTypeInt) in OpCompositeInsert does "
"not match the type that results from indexing into "
"the Composite (OpTypeMatrix)."));
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
}
// Valid: Tests that we can index into Struct, Array, Matrix, and Vector!
TEST_F(ValidateIdWithMessage, CompositeExtractInsertIndexIntoAllTypesGood) {
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%ss = OpCompositeExtract %struct_s %myblock 0
%sa = OpCompositeExtract %array5_mat4x3 %myblock 0 3
%sm = OpCompositeExtract %mat4x3 %myblock 0 3 1
%sc = OpCompositeExtract %v3float %myblock 0 3 1 2
%fl = OpCompositeExtract %float %myblock 0 3 1 2 0
;
; Now let's insert back at different levels...
;
%b1 = OpCompositeInsert %struct_blockName %ss %myblock 0
%b2 = OpCompositeInsert %struct_blockName %sa %myblock 0 3
%b3 = OpCompositeInsert %struct_blockName %sm %myblock 0 3 1
%b4 = OpCompositeInsert %struct_blockName %sc %myblock 0 3 1 2
%b5 = OpCompositeInsert %struct_blockName %fl %myblock 0 3 1 2 0
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid. More indexes are provided than needed for OpCompositeExtract.
TEST_F(ValidateIdWithMessage, CompositeExtractReachedScalarBad) {
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%fl = OpCompositeExtract %float %myblock 0 3 1 2 0 1
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCompositeExtract reached non-composite type while "
"indexes still remain to be traversed."));
}
// Invalid. More indexes are provided than needed for OpCompositeInsert.
TEST_F(ValidateIdWithMessage, CompositeInsertReachedScalarBad) {
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%fl = OpCompositeExtract %float %myblock 0 3 1 2 0
%b5 = OpCompositeInsert %struct_blockName %fl %myblock 0 3 1 2 0 1
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCompositeInsert reached non-composite type while "
"indexes still remain to be traversed."));
}
// Invalid. Result type doesn't match the type we get from indexing into
// the composite.
TEST_F(ValidateIdWithMessage,
CompositeExtractResultTypeDoesntMatchIndexedTypeBad) {
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%fl = OpCompositeExtract %int %myblock 0 3 1 2 0
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpCompositeExtract result type (OpTypeInt) does not "
"match the type that results from indexing into the "
"composite (OpTypeFloat)."));
}
// Invalid. Given object type doesn't match the type we get from indexing into
// the composite.
TEST_F(ValidateIdWithMessage,
CompositeInsertObjectTypeDoesntMatchIndexedTypeBad) {
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
// We are trying to insert an integer where we should be inserting a float.
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%b5 = OpCompositeInsert %struct_blockName %int_0 %myblock 0 3 1 2 0
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("he Object type (OpTypeInt) in OpCompositeInsert does "
"not match the type that results from indexing into "
"the Composite (OpTypeFloat)."));
}
// Invalid. Index into a struct is larger than the number of struct members.
TEST_F(ValidateIdWithMessage, CompositeExtractStructIndexOutOfBoundBad) {
// struct_blockName has 3 members (index 0,1,2). We'll try to access index 3.
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%ss = OpCompositeExtract %struct_s %myblock 3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
HasSubstr("Index is out of bounds: OpCompositeExtract can not "
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
"find index 3 into the structure <id> '26'. This "
"structure has 3 members. Largest valid index is 2."));
}
// Invalid. Index into a struct is larger than the number of struct members.
TEST_F(ValidateIdWithMessage, CompositeInsertStructIndexOutOfBoundBad) {
// struct_blockName has 3 members (index 0,1,2). We'll try to access index 3.
ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << R"(
%myblock = OpLoad %struct_blockName %blockName_var
%ss = OpCompositeExtract %struct_s %myblock 0
%new_composite = OpCompositeInsert %struct_blockName %ss %myblock 3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Index is out of bounds: OpCompositeInsert can not find "
"index 3 into the structure <id> '26'. This structure "
"has 3 members. Largest valid index is 2."));
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
#if 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallArgumentCountBar) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
const char *spirv = R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
%9 = OpLoad %2 %7
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
OpReturn
%12 = OpFunctionCall %2 %6 %5
OpFunctionEnd)";
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
CHECK(spirv, SPV_ERROR_INVALID_ID);
}
#endif
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
// TODO: The many things that changed with how images are used.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpTextureSample
// TODO: OpTextureSampleDref
// TODO: OpTextureSampleLod
// TODO: OpTextureSampleProj
// TODO: OpTextureSampleGrad
// TODO: OpTextureSampleOffset
// TODO: OpTextureSampleProjLod
// TODO: OpTextureSampleProjGrad
// TODO: OpTextureSampleLodOffset
// TODO: OpTextureSampleProjOffset
// TODO: OpTextureSampleGradOffset
// TODO: OpTextureSampleProjLodOffset
// TODO: OpTextureSampleProjGradOffset
// TODO: OpTextureFetchTexelLod
// TODO: OpTextureFetchTexelOffset
// TODO: OpTextureFetchSample
// TODO: OpTextureFetchTexel
// TODO: OpTextureGather
// TODO: OpTextureGatherOffset
// TODO: OpTextureGatherOffsets
// TODO: OpTextureQuerySizeLod
// TODO: OpTextureQuerySize
// TODO: OpTextureQueryLevels
// TODO: OpTextureQuerySamples
// TODO: OpConvertUToF
// TODO: OpConvertFToS
// TODO: OpConvertSToF
// TODO: OpConvertUToF
// TODO: OpUConvert
// TODO: OpSConvert
// TODO: OpFConvert
// TODO: OpConvertPtrToU
// TODO: OpConvertUToPtr
// TODO: OpPtrCastToGeneric
// TODO: OpGenericCastToPtr
// TODO: OpBitcast
// TODO: OpGenericCastToPtrExplicit
// TODO: OpSatConvertSToU
// TODO: OpSatConvertUToS
// TODO: OpVectorExtractDynamic
// TODO: OpVectorInsertDynamic
// TODO: OpVectorShuffle
// TODO: OpCompositeConstruct
// TODO: OpCompositeExtract
// TODO: OpCompositeInsert
// TODO: OpCopyObject
// TODO: OpTranspose
// TODO: OpSNegate
// TODO: OpFNegate
// TODO: OpNot
// TODO: OpIAdd
// TODO: OpFAdd
// TODO: OpISub
// TODO: OpFSub
// TODO: OpIMul
// TODO: OpFMul
// TODO: OpUDiv
// TODO: OpSDiv
// TODO: OpFDiv
// TODO: OpUMod
// TODO: OpSRem
// TODO: OpSMod
// TODO: OpFRem
// TODO: OpFMod
// TODO: OpVectorTimesScalar
// TODO: OpMatrixTimesScalar
// TODO: OpVectorTimesMatrix
// TODO: OpMatrixTimesVector
// TODO: OpMatrixTimesMatrix
// TODO: OpOuterProduct
// TODO: OpDot
// TODO: OpShiftRightLogical
// TODO: OpShiftRightArithmetic
// TODO: OpShiftLeftLogical
// TODO: OpBitwiseOr
// TODO: OpBitwiseXor
// TODO: OpBitwiseAnd
// TODO: OpAny
// TODO: OpAll
// TODO: OpIsNan
// TODO: OpIsInf
// TODO: OpIsFinite
// TODO: OpIsNormal
// TODO: OpSignBitSet
// TODO: OpLessOrGreater
// TODO: OpOrdered
// TODO: OpUnordered
// TODO: OpLogicalOr
// TODO: OpLogicalXor
// TODO: OpLogicalAnd
// TODO: OpSelect
// TODO: OpIEqual
// TODO: OpFOrdEqual
// TODO: OpFUnordEqual
// TODO: OpINotEqual
// TODO: OpFOrdNotEqual
// TODO: OpFUnordNotEqual
// TODO: OpULessThan
// TODO: OpSLessThan
// TODO: OpFOrdLessThan
// TODO: OpFUnordLessThan
// TODO: OpUGreaterThan
// TODO: OpSGreaterThan
// TODO: OpFOrdGreaterThan
// TODO: OpFUnordGreaterThan
// TODO: OpULessThanEqual
// TODO: OpSLessThanEqual
// TODO: OpFOrdLessThanEqual
// TODO: OpFUnordLessThanEqual
// TODO: OpUGreaterThanEqual
// TODO: OpSGreaterThanEqual
// TODO: OpFOrdGreaterThanEqual
// TODO: OpFUnordGreaterThanEqual
// TODO: OpDPdx
// TODO: OpDPdy
// TODO: OpFWidth
// TODO: OpDPdxFine
// TODO: OpDPdyFine
// TODO: OpFwidthFine
// TODO: OpDPdxCoarse
// TODO: OpDPdyCoarse
// TODO: OpFwidthCoarse
// TODO: OpPhi
// TODO: OpLoopMerge
// TODO: OpSelectionMerge
// TODO: OpBranch
// TODO: OpBranchConditional
// TODO: OpSwitch
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueConstantGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 42
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %4
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of return value.
2016-01-22 21:52:40 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueVariableGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0 ;10
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%8 = OpTypePointer Function %2 ;18
%4 = OpConstant %2 42 ;22
%5 = OpFunction %2 None %3 ;27
%6 = OpLabel ;29
%7 = OpVariable %8 Function %4 ;34
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%9 = OpLoad %2 %7
OpReturnValue %9 ;36
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of return value.
2016-01-22 21:52:40 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueExpressionGood) {
string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 42
%5 = OpFunction %2 None %3
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%6 = OpLabel
%7 = OpIAdd %2 %4 %4
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsType) {
string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpLabel
OpReturnValue %1
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpReturnValue Value <id> '1' does not represent a value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsLabel) {
string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %6
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpReturnValue Value <id> '5' does not represent a value."));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVoid) {
string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1
%5 = OpFunction %1 None %3
%6 = OpLabel
%7 = OpFunctionCall %1 %5
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpReturnValue value's type <id> '1' is missing or void."));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVariableInPhysical) {
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
// It's valid to return a pointer in a physical addressing model.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string spirv = kGLSL450MemoryModel + R"(
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
OpMemoryModel Physical32 OpenCL
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Private %2
%4 = OpTypeFunction %3
%5 = OpFunction %3 None %4
%6 = OpLabel
%7 = OpVariable %3 Function
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVariableInLogical) {
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
// It's invalid to return a pointer in a physical addressing model.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
string spirv = kGLSL450MemoryModel + R"(
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
OpMemoryModel Logical GLSL450
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Private %2
%4 = OpTypeFunction %3
%5 = OpFunction %3 None %4
%6 = OpLabel
%7 = OpVariable %3 Function
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpReturnValue value's type <id> '3' is a pointer, "
"which is invalid in the Logical addressing model."));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
// TODO: enable when this bug is fixed:
// https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, DISABLED_OpReturnValueIsFunction) {
string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %5
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedTypeId) {
string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%s = OpTypeStruct %i32
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Forward reference operands in an OpTypeStruct must "
"first be declared using OpTypeForwardPointer."));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedIdScope) {
string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%u32 = OpTypeInt 32 0
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
%memsem = OpConstant %u32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%f = OpFunction %void None %void_f
%l = OpLabel
OpMemoryBarrier %undef %memsem
OpReturn
OpFunctionEnd
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 7 has not been defined"));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedIdMemSem) {
string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%u32 = OpTypeInt 32 0
%scope = OpConstant %u32 0
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%f = OpFunction %void None %void_f
%l = OpLabel
OpMemoryBarrier %scope %undef
OpReturn
OpFunctionEnd
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 7 has not been defined"));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
KernelOpEntryPointAndOpInBoundsPtrAccessChainGood) {
string spirv = kOpenCLMemoryModel32 + R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpEntryPoint Kernel %2 "simple_kernel"
OpSource OpenCL_C 200000
OpDecorate %3 BuiltIn GlobalInvocationId
OpDecorate %3 Constant
OpDecorate %4 FuncParamAttr NoCapture
OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import
%5 = OpTypeInt 32 0
%6 = OpTypeVector %5 3
%7 = OpTypePointer UniformConstant %6
%3 = OpVariable %7 UniformConstant
%8 = OpTypeVoid
%9 = OpTypeStruct %5
%10 = OpTypePointer CrossWorkgroup %9
%11 = OpTypeFunction %8 %10
%12 = OpConstant %5 0
%13 = OpTypePointer CrossWorkgroup %5
%14 = OpConstant %5 42
%2 = OpFunction %8 None %11
%4 = OpFunctionParameter %10
%15 = OpLabel
%16 = OpLoad %6 %3 Aligned 0
%17 = OpCompositeExtract %5 %16 0
%18 = OpInBoundsPtrAccessChain %13 %4 %17 %12
OpStore %18 %14 Aligned 4
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpPtrAccessChainGood) {
string spirv = kOpenCLMemoryModel64 + R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpEntryPoint Kernel %2 "another_kernel"
OpSource OpenCL_C 200000
OpDecorate %3 BuiltIn GlobalInvocationId
OpDecorate %3 Constant
OpDecorate %4 FuncParamAttr NoCapture
OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import
%5 = OpTypeInt 64 0
%6 = OpTypeVector %5 3
%7 = OpTypePointer UniformConstant %6
%3 = OpVariable %7 UniformConstant
%8 = OpTypeVoid
%9 = OpTypeInt 32 0
%10 = OpTypeStruct %9
%11 = OpTypePointer CrossWorkgroup %10
%12 = OpTypeFunction %8 %11
%13 = OpConstant %5 4294967295
%14 = OpConstant %9 0
%15 = OpTypePointer CrossWorkgroup %9
%16 = OpConstant %9 42
%2 = OpFunction %8 None %12
%4 = OpFunctionParameter %11
%17 = OpLabel
%18 = OpLoad %6 %3 Aligned 0
%19 = OpCompositeExtract %5 %18 0
%20 = OpBitwiseAnd %5 %19 %13
%21 = OpPtrAccessChain %15 %4 %20 %14
OpStore %21 %16 Aligned 4
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadBitcastPointerGood) {
string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer UniformConstant %3
%6 = OpTypePointer UniformConstant %4
%7 = OpVariable %5 UniformConstant
%8 = OpTypeFunction %2
%9 = OpFunction %2 None %8
%10 = OpLabel
%11 = OpBitcast %6 %7
%12 = OpLoad %4 %11
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadBitcastNonPointerBad) {
string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer UniformConstant %3
%6 = OpTypeFunction %2
%7 = OpVariable %5 UniformConstant
%8 = OpFunction %2 None %6
%9 = OpLabel
%10 = OpLoad %3 %7
%11 = OpBitcast %4 %10
%12 = OpLoad %3 %11
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpLoad type for pointer <id> '11' is not a pointer type."));
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreBitcastPointerGood) {
string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer Function %3
%6 = OpTypePointer Function %4
%7 = OpTypeFunction %2
%8 = OpConstant %3 42
%9 = OpFunction %2 None %7
%10 = OpLabel
%11 = OpVariable %6 Function
%12 = OpBitcast %5 %11
OpStore %12 %8
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreBitcastNonPointerBad) {
string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer Function %4
%6 = OpTypeFunction %2
%7 = OpConstant %4 42
%8 = OpFunction %2 None %6
%9 = OpLabel
%10 = OpVariable %5 Function
%11 = OpBitcast %3 %7
OpStore %11 %7
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpStore type for pointer <id> '11' is not a pointer type."));
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Add a test that exercises wrong usage of result id Result <id> resulting from an instruction within a function may not be used outside that function.
2016-12-05 19:00:18 +00:00
// Result <id> resulting from an instruction within a function may not be used
// outside that function.
TEST_F(ValidateIdWithMessage, ResultIdUsedOutsideOfFunctionBad) {
string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeInt 32 0
%4 = OpTypePointer Function %3
%5 = OpFunction %1 None %2
%6 = OpLabel
%7 = OpVariable %4 Function
OpReturn
OpFunctionEnd
%8 = OpFunction %1 None %2
%9 = OpLabel
%10 = OpLoad %3 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"ID 7 defined in block 6 does not dominate its use in block 9"));
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpLifetimeStart
// TODO: OpLifetimeStop
// TODO: OpAtomicInit
// TODO: OpAtomicLoad
// TODO: OpAtomicStore
// TODO: OpAtomicExchange
// TODO: OpAtomicCompareExchange
// TODO: OpAtomicCompareExchangeWeak
// TODO: OpAtomicIIncrement
// TODO: OpAtomicIDecrement
// TODO: OpAtomicIAdd
// TODO: OpAtomicISub
// TODO: OpAtomicUMin
// TODO: OpAtomicUMax
// TODO: OpAtomicAnd
// TODO: OpAtomicOr
// TODO: OpAtomicXor
// TODO: OpAtomicIMin
// TODO: OpAtomicIMax
// TODO: OpEmitStreamVertex
// TODO: OpEndStreamPrimitive
// TODO: OpAsyncGroupCopy
// TODO: OpWaitGroupEvents
// TODO: OpGroupAll
// TODO: OpGroupAny
// TODO: OpGroupBroadcast
// TODO: OpGroupIAdd
// TODO: OpGroupFAdd
// TODO: OpGroupFMin
// TODO: OpGroupUMin
// TODO: OpGroupSMin
// TODO: OpGroupFMax
// TODO: OpGroupUMax
// TODO: OpGroupSMax
// TODO: OpEnqueueMarker
// TODO: OpEnqueueKernel
// TODO: OpGetKernelNDrangeSubGroupCount
// TODO: OpGetKernelNDrangeMaxSubGroupSize
// TODO: OpGetKernelWorkGroupSize
// TODO: OpGetKernelPreferredWorkGroupSizeMultiple
// TODO: OpRetainEvent
// TODO: OpReleaseEvent
// TODO: OpCreateUserEvent
// TODO: OpIsValidEvent
// TODO: OpSetUserEventStatus
// TODO: OpCaptureEventProfilingInfo
// TODO: OpGetDefaultQueue
// TODO: OpBuildNDRange
// TODO: OpReadPipe
// TODO: OpWritePipe
// TODO: OpReservedReadPipe
// TODO: OpReservedWritePipe
// TODO: OpReserveReadPipePackets
// TODO: OpReserveWritePipePackets
// TODO: OpCommitReadPipe
// TODO: OpCommitWritePipe
// TODO: OpIsValidReserveId
// TODO: OpGetNumPipePackets
// TODO: OpGetMaxPipePackets
// TODO: OpGroupReserveReadPipePackets
// TODO: OpGroupReserveWritePipePackets
// TODO: OpGroupCommitReadPipe
// TODO: OpGroupCommitWritePipe
Put test classes in anonymous namespace. Put TestFixture.h classes in a namespace. Remove unused #includes.
2015-08-31 19:24:32 +00:00
} // anonymous namespace
Reference in New Issue Copy Permalink