1 // Copyright (c) 2015-2016 The Khronos Group Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #ifndef LIBSPIRV_TEST_TEST_FIXTURE_H_ 16 #define LIBSPIRV_TEST_TEST_FIXTURE_H_ 17 18 #include "unit_spirv.h" 19 20 namespace spvtest { 21 22 // RAII for spv_context. 23 struct ScopedContext { 24 ScopedContext(spv_target_env env = SPV_ENV_UNIVERSAL_1_0) contextScopedContext25 : context(spvContextCreate(env)) {} ~ScopedContextScopedContext26 ~ScopedContext() { spvContextDestroy(context); } 27 spv_context context; 28 }; 29 30 // Common setup for TextToBinary tests. SetText() should be called to populate 31 // the actual test text. 32 template <typename T> 33 class TextToBinaryTestBase : public T { 34 public: 35 // Shorthand for SPIR-V compilation result. 36 using SpirvVector = std::vector<uint32_t>; 37 38 // Offset into a SpirvVector at which the first instruction starts. 39 static const SpirvVector::size_type kFirstInstruction = 5; 40 TextToBinaryTestBase()41 TextToBinaryTestBase() : diagnostic(nullptr), text(), binary(nullptr) { 42 char textStr[] = "substitute the text member variable with your test"; 43 text = {textStr, strlen(textStr)}; 44 } 45 ~TextToBinaryTestBase()46 virtual ~TextToBinaryTestBase() { 47 DestroyBinary(); 48 if (diagnostic) spvDiagnosticDestroy(diagnostic); 49 } 50 51 // Returns subvector v[from:end). Subvector(const SpirvVector & v,SpirvVector::size_type from)52 SpirvVector Subvector(const SpirvVector& v, SpirvVector::size_type from) { 53 assert(from <= v.size()); 54 return SpirvVector(v.begin() + from, v.end()); 55 } 56 57 // Compiles SPIR-V text in the given assembly syntax format, asserting 58 // compilation success. Returns the compiled code. 59 SpirvVector CompileSuccessfully(const std::string& txt, 60 spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { 61 spv_result_t status = 62 spvTextToBinary(ScopedContext(env).context, txt.c_str(), txt.size(), 63 &binary, &diagnostic); 64 EXPECT_EQ(SPV_SUCCESS, status) << txt; 65 SpirvVector code_copy; 66 if (status == SPV_SUCCESS) { 67 code_copy = SpirvVector(binary->code, binary->code + binary->wordCount); 68 DestroyBinary(); 69 } else { 70 spvDiagnosticPrint(diagnostic); 71 } 72 return code_copy; 73 } 74 75 // Compiles SPIR-V text with the given format, asserting compilation failure. 76 // Returns the error message(s). 77 std::string CompileFailure(const std::string& txt, 78 spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { 79 EXPECT_NE(SPV_SUCCESS, 80 spvTextToBinary(ScopedContext(env).context, txt.c_str(), 81 txt.size(), &binary, &diagnostic)) 82 << txt; 83 DestroyBinary(); 84 return diagnostic->error; 85 } 86 87 // Encodes SPIR-V text into binary and then decodes the binary using 88 // given options. Returns the decoded text. 89 std::string EncodeAndDecodeSuccessfully( 90 const std::string& txt, 91 uint32_t disassemble_options = SPV_BINARY_TO_TEXT_OPTION_NONE, 92 spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { 93 DestroyBinary(); 94 ScopedContext context(env); 95 disassemble_options |= SPV_BINARY_TO_TEXT_OPTION_NO_HEADER; 96 spv_result_t error = spvTextToBinary(context.context, txt.c_str(), 97 txt.size(), &binary, &diagnostic); 98 if (error) { 99 spvDiagnosticPrint(diagnostic); 100 spvDiagnosticDestroy(diagnostic); 101 } 102 EXPECT_EQ(SPV_SUCCESS, error); 103 if (!binary) return ""; 104 105 spv_text decoded_text; 106 error = spvBinaryToText(context.context, binary->code, binary->wordCount, 107 disassemble_options, &decoded_text, &diagnostic); 108 if (error) { 109 spvDiagnosticPrint(diagnostic); 110 spvDiagnosticDestroy(diagnostic); 111 } 112 EXPECT_EQ(SPV_SUCCESS, error) << txt; 113 114 const std::string decoded_string = decoded_text->str; 115 spvTextDestroy(decoded_text); 116 117 return decoded_string; 118 } 119 120 // Encodes SPIR-V text into binary. This is expected to succeed. 121 // The given words are then appended to the binary, and the result 122 // is then decoded. This is expected to fail. 123 // Returns the error message. EncodeSuccessfullyDecodeFailed(const std::string & txt,const SpirvVector & words_to_append)124 std::string EncodeSuccessfullyDecodeFailed( 125 const std::string& txt, const SpirvVector& words_to_append) { 126 SpirvVector code = 127 spvtest::Concatenate({CompileSuccessfully(txt), words_to_append}); 128 129 spv_text decoded_text; 130 EXPECT_NE(SPV_SUCCESS, 131 spvBinaryToText(ScopedContext().context, code.data(), code.size(), 132 SPV_BINARY_TO_TEXT_OPTION_NONE, &decoded_text, 133 &diagnostic)); 134 if (diagnostic) { 135 std::string error_message = diagnostic->error; 136 spvDiagnosticDestroy(diagnostic); 137 diagnostic = nullptr; 138 return error_message; 139 } 140 return ""; 141 } 142 143 // Compiles SPIR-V text, asserts success, and returns the words representing 144 // the instructions. In particular, skip the words in the SPIR-V header. 145 SpirvVector CompiledInstructions(const std::string& txt, 146 spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { 147 const SpirvVector code = CompileSuccessfully(txt, env); 148 SpirvVector result; 149 // Extract just the instructions. 150 // If the code fails to compile, then return the empty vector. 151 // In any case, don't crash or invoke undefined behaviour. 152 if (code.size() >= kFirstInstruction) 153 result = Subvector(code, kFirstInstruction); 154 return result; 155 } 156 SetText(const std::string & code)157 void SetText(const std::string& code) { 158 textString = code; 159 text.str = textString.c_str(); 160 text.length = textString.size(); 161 } 162 163 // Destroys the binary, if it exists. DestroyBinary()164 void DestroyBinary() { 165 spvBinaryDestroy(binary); 166 binary = nullptr; 167 } 168 169 spv_diagnostic diagnostic; 170 171 std::string textString; 172 spv_text_t text; 173 spv_binary binary; 174 }; 175 176 using TextToBinaryTest = TextToBinaryTestBase<::testing::Test>; 177 } // namespace spvtest 178 179 using RoundTripTest = 180 spvtest::TextToBinaryTestBase<::testing::TestWithParam<std::string>>; 181 182 #endif // LIBSPIRV_TEST_TEST_FIXTURE_H_ 183