encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-05-17 04:41:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use TestNamer in HLSL tests.

Browse Source 
This CL updates the HLSL tests to use the test namer and fixes up places
where the incorrect name was output.

Change-Id: I8510d1ff5a57f3a0996dc9c7c8478775ef141105
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/36940
Reviewed-by: Ryan Harrison <rharrison@chromium.org>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
dan sinclair 2021-01-11 16:24:32 +00:00 committed by dan sinclair
parent f74b90b3dd
commit f4bc0e7337
28 changed files with 477 additions and 428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/writer/hlsl/generator.cc
View File

@ -22,14 +22,16 @@ namespace hlsl {
Generator::Generator(ast::Module module) Generator::Generator(ast::Module module)
: Text(std::move(module)), : Text(std::move(module)),
impl_(std::make_unique<GeneratorImpl>(&module_)) {} namer_(std::make_unique<UnsafeNamer>(&module)),
impl_(std::make_unique<GeneratorImpl>(&module_, namer_.get())) {}
Generator::~Generator() = default; Generator::~Generator() = default;
void Generator::Reset() { void Generator::Reset() {
set_error(""); set_error("");
out_ = std::ostringstream(); out_ = std::ostringstream();
impl_ = std::make_unique<GeneratorImpl>(&module_); namer_->Reset();
impl_ = std::make_unique<GeneratorImpl>(&module_, namer_.get());
} }
bool Generator::Generate() { bool Generator::Generate() {

2
src/writer/hlsl/generator.h
View File

@ -19,6 +19,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include "src/namer.h"
#include "src/writer/hlsl/generator_impl.h" #include "src/writer/hlsl/generator_impl.h"
#include "src/writer/text.h" #include "src/writer/text.h"
@ -56,6 +57,7 @@ class Generator : public Text {
private: private:
std::ostringstream out_; std::ostringstream out_;
std::unique_ptr<Namer> namer_;
std::unique_ptr<GeneratorImpl> impl_; std::unique_ptr<GeneratorImpl> impl_;
}; };

112
src/writer/hlsl/generator_impl.cc
View File

@ -126,8 +126,8 @@ const char* image_format_to_rwtexture_type(
} // namespace } // namespace
GeneratorImpl::GeneratorImpl(ast::Module* module) GeneratorImpl::GeneratorImpl(ast::Module* module, Namer* namer)
: module_(module), namer_(std::make_unique<UnsafeNamer>(module)) {} : module_(module), namer_(namer) {}
GeneratorImpl::~GeneratorImpl() = default; GeneratorImpl::~GeneratorImpl() = default;
@ -194,25 +194,25 @@ void GeneratorImpl::register_global(ast::Variable* global) {
global_variables_.set(global->symbol(), global); global_variables_.set(global->symbol(), global);
} }
std::string GeneratorImpl::current_ep_var_name(VarType type) { Symbol GeneratorImpl::current_ep_var_symbol(VarType type) {
std::string name = ""; Symbol sym;
switch (type) { switch (type) {
case VarType::kIn: { case VarType::kIn: {
auto in_it = ep_sym_to_in_data_.find(current_ep_sym_.value()); auto in_it = ep_sym_to_in_data_.find(current_ep_sym_.value());
if (in_it != ep_sym_to_in_data_.end()) { if (in_it != ep_sym_to_in_data_.end()) {
name = in_it->second.var_name; sym = in_it->second.var_symbol;
} }
break; break;
} }
case VarType::kOut: { case VarType::kOut: {
auto outit = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto outit = ep_sym_to_out_data_.find(current_ep_sym_.value());
if (outit != ep_sym_to_out_data_.end()) { if (outit != ep_sym_to_out_data_.end()) {
name = outit->second.var_name; sym = outit->second.var_symbol;
} }
break; break;
} }
} }
return name; return sym;
} }
bool GeneratorImpl::EmitConstructedType(std::ostream& out, bool GeneratorImpl::EmitConstructedType(std::ostream& out,
@ -223,7 +223,7 @@ bool GeneratorImpl::EmitConstructedType(std::ostream& out,
// HLSL typedef is for intrinsic types only. For an alias'd struct, // HLSL typedef is for intrinsic types only. For an alias'd struct,
// generate a secondary struct with the new name. // generate a secondary struct with the new name.
if (auto* str = alias->type()->As<ast::type::Struct>()) { if (auto* str = alias->type()->As<ast::type::Struct>()) {
if (!EmitStructType(out, str, namer_->NameFor(alias->symbol()))) { if (!EmitStructType(out, str, alias->symbol())) {
return false; return false;
} }
return true; return true;
@ -234,7 +234,7 @@ bool GeneratorImpl::EmitConstructedType(std::ostream& out,
} }
out << " " << namer_->NameFor(alias->symbol()) << ";" << std::endl; out << " " << namer_->NameFor(alias->symbol()) << ";" << std::endl;
} else if (auto* str = ty->As<ast::type::Struct>()) { } else if (auto* str = ty->As<ast::type::Struct>()) {
if (!EmitStructType(out, str, namer_->NameFor(str->symbol()))) { if (!EmitStructType(out, str, str->symbol())) {
return false; return false;
} }
} else { } else {
@ -669,12 +669,12 @@ bool GeneratorImpl::EmitCall(std::ostream& pre,
return true; return true;
} }
auto name = namer_->NameFor(ident->symbol()); auto func_name_sym = ident->symbol();
auto caller_sym = ident->symbol(); auto it =
auto it = ep_func_name_remapped_.find(current_ep_sym_.to_str() + "_" + ep_func_name_remapped_.find(module_->SymbolToName(current_ep_sym_) + "_" +
caller_sym.to_str()); module_->SymbolToName(func_name_sym));
if (it != ep_func_name_remapped_.end()) { if (it != ep_func_name_remapped_.end()) {
name = it->second; func_name_sym = it->second;
} }
auto* func = module_->FindFunctionBySymbol(ident->symbol()); auto* func = module_->FindFunctionBySymbol(ident->symbol());
@ -684,24 +684,24 @@ bool GeneratorImpl::EmitCall(std::ostream& pre,
return false; return false;
} }
out << name << "("; out << namer_->NameFor(func_name_sym) << "(";
bool first = true; bool first = true;
if (has_referenced_in_var_needing_struct(func)) { if (has_referenced_in_var_needing_struct(func)) {
auto var_name = current_ep_var_name(VarType::kIn); auto var_sym = current_ep_var_symbol(VarType::kIn);
if (!var_name.empty()) { if (var_sym.IsValid()) {
out << var_name; out << namer_->NameFor(var_sym);
first = false; first = false;
} }
} }
if (has_referenced_out_var_needing_struct(func)) { if (has_referenced_out_var_needing_struct(func)) {
auto var_name = current_ep_var_name(VarType::kOut); auto var_sym = current_ep_var_symbol(VarType::kOut);
if (!var_name.empty()) { if (var_sym.IsValid()) {
if (!first) { if (!first) {
out << ", "; out << ", ";
} }
first = false; first = false;
out << var_name; out << namer_->NameFor(var_sym);
} }
} }
@ -1059,15 +1059,21 @@ bool GeneratorImpl::EmitIdentifier(std::ostream&,
auto var_type = var->storage_class() == ast::StorageClass::kInput auto var_type = var->storage_class() == ast::StorageClass::kInput
? VarType::kIn ? VarType::kIn
: VarType::kOut; : VarType::kOut;
auto name = current_ep_var_name(var_type); auto sym = current_ep_var_symbol(var_type);
if (name.empty()) { if (!sym.IsValid()) {
error_ = "unable to find entry point data for variable"; error_ = "unable to find entry point data for variable";
return false; return false;
} }
out << name << "."; out << namer_->NameFor(sym) << ".";
} }
} }
// Swizzle outputs the name directly
if (ident->IsSwizzle()) {
out << module_->SymbolToName(ident->symbol());
} else {
out << namer_->NameFor(ident->symbol()); out << namer_->NameFor(ident->symbol());
}
return true; return true;
} }
@ -1216,25 +1222,22 @@ bool GeneratorImpl::EmitFunctionInternal(std::ostream& out,
ast::Function* func, ast::Function* func,
bool emit_duplicate_functions, bool emit_duplicate_functions,
Symbol ep_sym) { Symbol ep_sym) {
auto name = func->symbol().to_str();
if (!EmitType(out, func->return_type(), Symbol())) { if (!EmitType(out, func->return_type(), Symbol())) {
return false; return false;
} }
out << " "; out << " ";
auto func_name_sym = func->symbol();
if (emit_duplicate_functions) { if (emit_duplicate_functions) {
auto func_name = name; auto func_name = module_->SymbolToName(func_name_sym);
auto ep_name = ep_sym.to_str(); auto ep_name = module_->SymbolToName(ep_sym);
name = namer_->GenerateName(namer_->NameFor(func->symbol()) + "_" + func_name_sym = module_->RegisterSymbol(
namer_->NameFor(ep_sym)); namer_->GenerateName(func_name + "_" + ep_name));
ep_func_name_remapped_[ep_name + "_" + func_name] = name; ep_func_name_remapped_[ep_name + "_" + func_name] = func_name_sym;
} else {
name = namer_->NameFor(func->symbol());
} }
out << name << "("; out << namer_->NameFor(func_name_sym) << "(";
bool first = true; bool first = true;
@ -1245,8 +1248,8 @@ bool GeneratorImpl::EmitFunctionInternal(std::ostream& out,
if (emit_duplicate_functions) { if (emit_duplicate_functions) {
auto in_it = ep_sym_to_in_data_.find(ep_sym.value()); auto in_it = ep_sym_to_in_data_.find(ep_sym.value());
if (in_it != ep_sym_to_in_data_.end()) { if (in_it != ep_sym_to_in_data_.end()) {
out << "in " << in_it->second.struct_name << " " out << "in " << namer_->NameFor(in_it->second.struct_symbol) << " "
<< in_it->second.var_name; << namer_->NameFor(in_it->second.var_symbol);
first = false; first = false;
} }
@ -1255,8 +1258,8 @@ bool GeneratorImpl::EmitFunctionInternal(std::ostream& out,
if (!first) { if (!first) {
out << ", "; out << ", ";
} }
out << "out " << outit->second.struct_name << " " out << "out " << namer_->NameFor(outit->second.struct_symbol) << " "
<< outit->second.var_name; << namer_->NameFor(outit->second.var_symbol);
first = false; first = false;
} }
} }
@ -1400,13 +1403,14 @@ bool GeneratorImpl::EmitEntryPointData(
} }
if (!in_variables.empty()) { if (!in_variables.empty()) {
auto in_struct_name = namer_->GenerateName(namer_->NameFor(func->symbol()) + auto in_struct_sym = module_->RegisterSymbol(namer_->GenerateName(
"_" + kInStructNameSuffix); module_->SymbolToName(func->symbol()) + "_" + kInStructNameSuffix));
auto in_var_name = namer_->GenerateName(kTintStructInVarPrefix); auto in_var_name = namer_->GenerateName(kTintStructInVarPrefix);
ep_sym_to_in_data_[func->symbol().value()] = {in_struct_name, in_var_name}; ep_sym_to_in_data_[func->symbol().value()] = {
in_struct_sym, module_->RegisterSymbol(in_var_name)};
make_indent(out); make_indent(out);
out << "struct " << in_struct_name << " {" << std::endl; out << "struct " << namer_->NameFor(in_struct_sym) << " {" << std::endl;
increment_indent(); increment_indent();
@ -1446,13 +1450,14 @@ bool GeneratorImpl::EmitEntryPointData(
} }
if (!outvariables.empty()) { if (!outvariables.empty()) {
auto outstruct_name = namer_->GenerateName(namer_->NameFor(func->symbol()) + auto outstruct_sym = module_->RegisterSymbol(namer_->GenerateName(
"_" + kOutStructNameSuffix); module_->SymbolToName(func->symbol()) + "_" + kOutStructNameSuffix));
auto outvar_name = namer_->GenerateName(kTintStructOutVarPrefix); auto outvar_name = namer_->GenerateName(kTintStructOutVarPrefix);
ep_sym_to_out_data_[func->symbol().value()] = {outstruct_name, outvar_name}; ep_sym_to_out_data_[func->symbol().value()] = {
outstruct_sym, module_->RegisterSymbol(outvar_name)};
make_indent(out); make_indent(out);
out << "struct " << outstruct_name << " {" << std::endl; out << "struct " << namer_->NameFor(outstruct_sym) << " {" << std::endl;
increment_indent(); increment_indent();
for (auto& data : outvariables) { for (auto& data : outvariables) {
@ -1542,7 +1547,7 @@ bool GeneratorImpl::EmitEntryPointFunction(std::ostream& out,
auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value());
bool has_outdata = outdata != ep_sym_to_out_data_.end(); bool has_outdata = outdata != ep_sym_to_out_data_.end();
if (has_outdata) { if (has_outdata) {
out << outdata->second.struct_name; out << namer_->NameFor(outdata->second.struct_symbol);
} else { } else {
out << "void"; out << "void";
} }
@ -1550,7 +1555,8 @@ bool GeneratorImpl::EmitEntryPointFunction(std::ostream& out,
auto in_data = ep_sym_to_in_data_.find(current_ep_sym_.value()); auto in_data = ep_sym_to_in_data_.find(current_ep_sym_.value());
if (in_data != ep_sym_to_in_data_.end()) { if (in_data != ep_sym_to_in_data_.end()) {
out << in_data->second.struct_name << " " << in_data->second.var_name; out << namer_->NameFor(in_data->second.struct_symbol) << " "
<< namer_->NameFor(in_data->second.var_symbol);
} }
out << ") {" << std::endl; out << ") {" << std::endl;
@ -1558,8 +1564,8 @@ bool GeneratorImpl::EmitEntryPointFunction(std::ostream& out,
if (has_outdata) { if (has_outdata) {
make_indent(out); make_indent(out);
out << outdata->second.struct_name << " " << outdata->second.var_name << ";" out << namer_->NameFor(outdata->second.struct_symbol) << " "
<< std::endl; << namer_->NameFor(outdata->second.var_symbol) << ";" << std::endl;
} }
generating_entry_point_ = true; generating_entry_point_ = true;
@ -1986,7 +1992,7 @@ bool GeneratorImpl::EmitReturn(std::ostream& out, ast::ReturnStatement* stmt) {
out << "return"; out << "return";
auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value());
if (outdata != ep_sym_to_out_data_.end()) { if (outdata != ep_sym_to_out_data_.end()) {
out << " " << outdata->second.var_name; out << " " << namer_->NameFor(outdata->second.var_symbol);
} }
} else if (stmt->has_value()) { } else if (stmt->has_value()) {
std::ostringstream pre; std::ostringstream pre;
@ -2205,11 +2211,11 @@ bool GeneratorImpl::EmitType(std::ostream& out,
bool GeneratorImpl::EmitStructType(std::ostream& out, bool GeneratorImpl::EmitStructType(std::ostream& out,
const ast::type::Struct* str, const ast::type::Struct* str,
const std::string& name) { const Symbol& sym) {
// TODO(dsinclair): Block decoration? // TODO(dsinclair): Block decoration?
// if (str->impl()->decoration() != ast::StructDecoration::kNone) { // if (str->impl()->decoration() != ast::StructDecoration::kNone) {
// } // }
out << "struct " << name << " {" << std::endl; out << "struct " << namer_->NameFor(sym) << " {" << std::endl;
increment_indent(); increment_indent();
for (auto* mem : str->impl()->members()) { for (auto* mem : str->impl()->members()) {

17
src/writer/hlsl/generator_impl.h
View File

@ -54,7 +54,8 @@ class GeneratorImpl {
public: public:
/// Constructor /// Constructor
/// @param module the module to generate /// @param module the module to generate
explicit GeneratorImpl(ast::Module* module); /// @param namer the namer to use
GeneratorImpl(ast::Module* module, Namer* namer);
~GeneratorImpl(); ~GeneratorImpl();
/// Increment the emitter indent level /// Increment the emitter indent level
@ -295,11 +296,11 @@ class GeneratorImpl {
/// Handles generating a structure declaration /// Handles generating a structure declaration
/// @param out the output stream /// @param out the output stream
/// @param ty the struct to generate /// @param ty the struct to generate
/// @param name the struct name /// @param sym the struct symbol
/// @returns true if the struct is emitted /// @returns true if the struct is emitted
bool EmitStructType(std::ostream& out, bool EmitStructType(std::ostream& out,
const ast::type::Struct* ty, const ast::type::Struct* ty,
const std::string& name); const Symbol& sym);
/// Handles a unary op expression /// Handles a unary op expression
/// @param pre the preamble for the expression stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream /// @param out the output of the expression stream
@ -382,18 +383,18 @@ class GeneratorImpl {
enum class VarType { kIn, kOut }; enum class VarType { kIn, kOut };
struct EntryPointData { struct EntryPointData {
std::string struct_name; Symbol struct_symbol;
std::string var_name; Symbol var_symbol;
}; };
std::string current_ep_var_name(VarType type); Symbol current_ep_var_symbol(VarType type);
std::string get_buffer_name(ast::Expression* expr); std::string get_buffer_name(ast::Expression* expr);
std::string error_; std::string error_;
size_t indent_ = 0; size_t indent_ = 0;
ast::Module* module_ = nullptr; ast::Module* module_ = nullptr;
std::unique_ptr<Namer> namer_; Namer* namer_;
Symbol current_ep_sym_; Symbol current_ep_sym_;
bool generating_entry_point_ = false; bool generating_entry_point_ = false;
uint32_t loop_emission_counter_ = 0; uint32_t loop_emission_counter_ = 0;
@ -404,7 +405,7 @@ class GeneratorImpl {
// This maps an input of "<entry_point_name>_<function_name>" to a remapped // This maps an input of "<entry_point_name>_<function_name>" to a remapped
// function name. If there is no entry for a given key then function did // function name. If there is no entry for a given key then function did
// not need to be remapped for the entry point and can be emitted directly. // not need to be remapped for the entry point and can be emitted directly.
std::unordered_map<std::string, std::string> ep_func_name_remapped_; std::unordered_map<std::string, Symbol> ep_func_name_remapped_;
}; };
} // namespace hlsl } // namespace hlsl

8
src/writer/hlsl/generator_impl_alias_type_test.cc
View File

@ -30,7 +30,7 @@ TEST_F(HlslGeneratorImplTest_Alias, EmitAlias_F32) {
auto* alias = ty.alias("a", ty.f32); auto* alias = ty.alias("a", ty.f32);
ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error();
EXPECT_EQ(result(), R"(typedef float a; EXPECT_EQ(result(), R"(typedef float test_a;
)"); )");
} }
@ -44,9 +44,9 @@ TEST_F(HlslGeneratorImplTest_Alias, EmitAlias_Struct) {
auto* alias = ty.alias("B", s); auto* alias = ty.alias("B", s);
ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error();
EXPECT_EQ(result(), R"(struct B { EXPECT_EQ(result(), R"(struct test_B {
float a; float test_a;
int b; int test_b;
}; };
)"); )");
} }

4
src/writer/hlsl/generator_impl_array_accessor_test.cc
View File

@ -33,14 +33,14 @@ TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) {
auto* expr = IndexAccessor("ary", 5); auto* expr = IndexAccessor("ary", 5);
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "ary[5]"); EXPECT_EQ(result(), "test_ary[5]");
} }
TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) { TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) {
auto* expr = IndexAccessor("ary", "idx"); auto* expr = IndexAccessor("ary", "idx");
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "ary[idx]"); EXPECT_EQ(result(), "test_ary[test_idx]");
} }
} // namespace } // namespace

2
src/writer/hlsl/generator_impl_assign_test.cc
View File

@ -35,7 +35,7 @@ TEST_F(HlslGeneratorImplTest_Assign, Emit_Assign) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), " lhs = rhs;\n"); EXPECT_EQ(result(), " test_lhs = test_rhs;\n");
} }
} // namespace } // namespace

113
src/writer/hlsl/generator_impl_binary_test.cc
View File

@ -115,22 +115,23 @@ INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest, HlslGeneratorImplTest,
HlslBinaryTest, HlslBinaryTest,
testing::Values( testing::Values(
BinaryData{"(left & right)", ast::BinaryOp::kAnd}, BinaryData{"(test_left & test_right)", ast::BinaryOp::kAnd},
BinaryData{"(left | right)", ast::BinaryOp::kOr}, BinaryData{"(test_left | test_right)", ast::BinaryOp::kOr},
BinaryData{"(left ^ right)", ast::BinaryOp::kXor}, BinaryData{"(test_left ^ test_right)", ast::BinaryOp::kXor},
BinaryData{"(left == right)", ast::BinaryOp::kEqual}, BinaryData{"(test_left == test_right)", ast::BinaryOp::kEqual},
BinaryData{"(left != right)", ast::BinaryOp::kNotEqual}, BinaryData{"(test_left != test_right)", ast::BinaryOp::kNotEqual},
BinaryData{"(left < right)", ast::BinaryOp::kLessThan}, BinaryData{"(test_left < test_right)", ast::BinaryOp::kLessThan},
BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan}, BinaryData{"(test_left > test_right)", ast::BinaryOp::kGreaterThan},
BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual}, BinaryData{"(test_left <= test_right)", ast::BinaryOp::kLessThanEqual},
BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual}, BinaryData{"(test_left >= test_right)",
BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft}, ast::BinaryOp::kGreaterThanEqual},
BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight}, BinaryData{"(test_left << test_right)", ast::BinaryOp::kShiftLeft},
BinaryData{"(left + right)", ast::BinaryOp::kAdd}, BinaryData{"(test_left >> test_right)", ast::BinaryOp::kShiftRight},
BinaryData{"(left - right)", ast::BinaryOp::kSubtract}, BinaryData{"(test_left + test_right)", ast::BinaryOp::kAdd},
BinaryData{"(left * right)", ast::BinaryOp::kMultiply}, BinaryData{"(test_left - test_right)", ast::BinaryOp::kSubtract},
BinaryData{"(left / right)", ast::BinaryOp::kDivide}, BinaryData{"(test_left * test_right)", ast::BinaryOp::kMultiply},
BinaryData{"(left % right)", ast::BinaryOp::kModulo})); BinaryData{"(test_left / test_right)", ast::BinaryOp::kDivide},
BinaryData{"(test_left % test_right)", ast::BinaryOp::kModulo}));
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
auto* lhs = vec3<f32>(1.f, 1.f, 1.f); auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
@ -172,7 +173,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "(mat * 1.0f)"); EXPECT_EQ(result(), "(test_mat * 1.0f)");
} }
TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
@ -187,7 +188,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "(1.0f * mat)"); EXPECT_EQ(result(), "(1.0f * test_mat)");
} }
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
@ -202,7 +203,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "mul(mat, float3(1.0f, 1.0f, 1.0f))"); EXPECT_EQ(result(), "mul(test_mat, float3(1.0f, 1.0f, 1.0f))");
} }
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
@ -217,7 +218,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "mul(float3(1.0f, 1.0f, 1.0f), mat)"); EXPECT_EQ(result(), "mul(float3(1.0f, 1.0f, 1.0f), test_mat)");
} }
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
@ -232,7 +233,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "mul(mat, mat)"); EXPECT_EQ(result(), "mul(test_mat, test_mat)");
} }
TEST_F(HlslGeneratorImplTest_Binary, Logical_And) { TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
@ -244,9 +245,9 @@ TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "(_tint_tmp)"); EXPECT_EQ(result(), "(_tint_tmp)");
EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left; EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_left;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = right; _tint_tmp = test_right;
} }
)"); )");
} }
@ -265,15 +266,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) {
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "(_tint_tmp_0)"); EXPECT_EQ(result(), "(_tint_tmp_0)");
EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a; EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = b; _tint_tmp = test_b;
} }
bool _tint_tmp_0 = (_tint_tmp); bool _tint_tmp_0 = (_tint_tmp);
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
bool _tint_tmp_1 = c; bool _tint_tmp_1 = test_c;
if (!_tint_tmp_1) { if (!_tint_tmp_1) {
_tint_tmp_1 = d; _tint_tmp_1 = test_d;
} }
_tint_tmp_0 = (_tint_tmp_1); _tint_tmp_0 = (_tint_tmp_1);
} }
@ -289,9 +290,9 @@ TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) {
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "(_tint_tmp)"); EXPECT_EQ(result(), "(_tint_tmp)");
EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left; EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_left;
if (!_tint_tmp) { if (!_tint_tmp) {
_tint_tmp = right; _tint_tmp = test_right;
} }
)"); )");
} }
@ -332,16 +333,16 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
}); });
ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = a; EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = b; _tint_tmp = test_b;
} }
if ((_tint_tmp)) { if ((_tint_tmp)) {
return 1; return 1;
} else { } else {
bool _tint_tmp_0 = b; bool _tint_tmp_0 = test_b;
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
_tint_tmp_0 = c; _tint_tmp_0 = test_c;
} }
if ((_tint_tmp_0)) { if ((_tint_tmp_0)) {
return 2; return 2;
@ -363,13 +364,13 @@ TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, a, b), c)); create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, a, b), c));
ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = a; EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = b; _tint_tmp = test_b;
} }
bool _tint_tmp_0 = (_tint_tmp); bool _tint_tmp_0 = (_tint_tmp);
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
_tint_tmp_0 = c; _tint_tmp_0 = test_c;
} }
return (_tint_tmp_0); return (_tint_tmp_0);
)"); )");
@ -389,15 +390,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c), d)); create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c), d));
ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = b; EXPECT_EQ(result(), R"(bool _tint_tmp = test_b;
if (!_tint_tmp) { if (!_tint_tmp) {
_tint_tmp = c; _tint_tmp = test_c;
} }
bool _tint_tmp_0 = (_tint_tmp); bool _tint_tmp_0 = (_tint_tmp);
if (_tint_tmp_0) { if (_tint_tmp_0) {
_tint_tmp_0 = d; _tint_tmp_0 = test_d;
} }
a = (_tint_tmp_0); test_a = (_tint_tmp_0);
)"); )");
} }
@ -418,15 +419,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Decl_WithLogical) {
auto* expr = create<ast::VariableDeclStatement>(var); auto* expr = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = b; EXPECT_EQ(result(), R"(bool _tint_tmp = test_b;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = c; _tint_tmp = test_c;
} }
bool _tint_tmp_0 = (_tint_tmp); bool _tint_tmp_0 = (_tint_tmp);
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
_tint_tmp_0 = d; _tint_tmp_0 = test_d;
} }
bool a = (_tint_tmp_0); bool test_a = (_tint_tmp_0);
)"); )");
} }
@ -444,11 +445,11 @@ TEST_F(HlslGeneratorImplTest_Binary, Bitcast_WithLogical) {
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c))); create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c)));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a; EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) { if (_tint_tmp) {
bool _tint_tmp_0 = b; bool _tint_tmp_0 = test_b;
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
_tint_tmp_0 = c; _tint_tmp_0 = test_c;
} }
_tint_tmp = (_tint_tmp_0); _tint_tmp = (_tint_tmp_0);
} }
@ -478,27 +479,27 @@ TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) {
auto* expr = create<ast::CallStatement>(Call("foo", params)); auto* expr = create<ast::CallStatement>(Call("foo", params));
ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = a; EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) { if (_tint_tmp) {
_tint_tmp = b; _tint_tmp = test_b;
} }
bool _tint_tmp_0 = c; bool _tint_tmp_0 = test_c;
if (!_tint_tmp_0) { if (!_tint_tmp_0) {
_tint_tmp_0 = d; _tint_tmp_0 = test_d;
} }
bool _tint_tmp_1 = a; bool _tint_tmp_1 = test_a;
if (!_tint_tmp_1) { if (!_tint_tmp_1) {
_tint_tmp_1 = c; _tint_tmp_1 = test_c;
} }
bool _tint_tmp_2 = (_tint_tmp_1); bool _tint_tmp_2 = (_tint_tmp_1);
if (_tint_tmp_2) { if (_tint_tmp_2) {
bool _tint_tmp_3 = b; bool _tint_tmp_3 = test_b;
if (!_tint_tmp_3) { if (!_tint_tmp_3) {
_tint_tmp_3 = d; _tint_tmp_3 = test_d;
} }
_tint_tmp_2 = (_tint_tmp_3); _tint_tmp_2 = (_tint_tmp_3);
} }
foo((_tint_tmp), (_tint_tmp_0), (_tint_tmp_2)); test_foo((_tint_tmp), (_tint_tmp_0), (_tint_tmp_2));
)"); )");
} }

6
src/writer/hlsl/generator_impl_bitcast_test.cc
View File

@ -34,7 +34,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Float) {
auto* bitcast = create<ast::BitcastExpression>(ty.f32, id); auto* bitcast = create<ast::BitcastExpression>(ty.f32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
EXPECT_EQ(result(), "asfloat(id)"); EXPECT_EQ(result(), "asfloat(test_id)");
} }
TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) { TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
@ -42,7 +42,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
auto* bitcast = create<ast::BitcastExpression>(ty.i32, id); auto* bitcast = create<ast::BitcastExpression>(ty.i32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
EXPECT_EQ(result(), "asint(id)"); EXPECT_EQ(result(), "asint(test_id)");
} }
TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) { TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
@ -50,7 +50,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
auto* bitcast = create<ast::BitcastExpression>(ty.u32, id); auto* bitcast = create<ast::BitcastExpression>(ty.u32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
EXPECT_EQ(result(), "asuint(id)"); EXPECT_EQ(result(), "asuint(test_id)");
} }
} // namespace } // namespace

6
src/writer/hlsl/generator_impl_call_test.cc
View File

@ -37,7 +37,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
mod->AddFunction(func); mod->AddFunction(func);
ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
EXPECT_EQ(result(), "my_func()"); EXPECT_EQ(result(), "test_my_func()");
} }
TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) { TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
@ -48,7 +48,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
mod->AddFunction(func); mod->AddFunction(func);
ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
EXPECT_EQ(result(), "my_func(param1, param2)"); EXPECT_EQ(result(), "test_my_func(test_param1, test_param2)");
} }
TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) { TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
@ -59,7 +59,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
mod->AddFunction(func); mod->AddFunction(func);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, call)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, call)) << gen.error();
EXPECT_EQ(result(), " my_func(param1, param2);\n"); EXPECT_EQ(result(), " test_my_func(test_param1, test_param2);\n");
} }
} // namespace } // namespace

4
src/writer/hlsl/generator_impl_cast_test.cc
View File

@ -31,13 +31,13 @@ using HlslGeneratorImplTest_Cast = TestHelper;
TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) { TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) {
auto* cast = Construct<f32>("id"); auto* cast = Construct<f32>("id");
ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error();
EXPECT_EQ(result(), "float(id)"); EXPECT_EQ(result(), "float(test_id)");
} }
TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) { TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) {
auto* cast = vec3<f32>("id"); auto* cast = vec3<f32>("id");
ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error();
EXPECT_EQ(result(), "float3(id)"); EXPECT_EQ(result(), "float3(test_id)");
} }
} // namespace } // namespace

32
src/writer/hlsl/generator_impl_function_entry_point_data_test.cc
View File

@ -76,9 +76,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct vtx_main_in { EXPECT_EQ(result(), R"(struct test_vtx_main_in {
float foo : TEXCOORD0; float test_foo : TEXCOORD0;
int bar : TEXCOORD1; int test_bar : TEXCOORD1;
}; };
)"); )");
@ -126,9 +126,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct vtx_main_out { EXPECT_EQ(result(), R"(struct test_vtx_main_out {
float foo : TEXCOORD0; float test_foo : TEXCOORD0;
int bar : TEXCOORD1; int test_bar : TEXCOORD1;
}; };
)"); )");
@ -176,9 +176,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_in { EXPECT_EQ(result(), R"(struct test_main_in {
float foo : TEXCOORD0; float test_foo : TEXCOORD0;
int bar : TEXCOORD1; int test_bar : TEXCOORD1;
}; };
)"); )");
@ -226,9 +226,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_out { EXPECT_EQ(result(), R"(struct test_main_out {
float foo : SV_Target0; float test_foo : SV_Target0;
int bar : SV_Target1; int test_bar : SV_Target1;
}; };
)"); )");
@ -365,12 +365,12 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_in { EXPECT_EQ(result(), R"(struct test_main_in {
float4 coord : SV_Position; float4 test_coord : SV_Position;
}; };
struct main_out { struct test_main_out {
float depth : SV_Depth; float test_depth : SV_Depth;
}; };
)"); )");

192
src/writer/hlsl/generator_impl_function_test.cc
View File

@ -63,7 +63,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"( void my_func() { EXPECT_EQ(result(), R"( void test_my_func() {
return; return;
} }
@ -85,7 +85,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithParams) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"( void my_func(float a, int b) { EXPECT_EQ(result(), R"( void test_my_func(float test_a, int test_b) {
return; return;
} }
@ -124,18 +124,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct frag_main_in { EXPECT_EQ(result(), R"(struct test_frag_main_in {
float foo : TEXCOORD0; float test_foo : TEXCOORD0;
}; };
struct frag_main_out { struct test_frag_main_out {
float bar : SV_Target1; float test_bar : SV_Target1;
}; };
frag_main_out frag_main(frag_main_in tint_in) { test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
frag_main_out tint_out; test_frag_main_out test_tint_out;
tint_out.bar = tint_in.foo; test_tint_out.test_bar = test_tint_in.test_foo;
return tint_out; return test_tint_out;
} }
)"); )");
@ -176,18 +176,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct frag_main_in { EXPECT_EQ(result(), R"(struct test_frag_main_in {
float4 coord : SV_Position; float4 test_coord : SV_Position;
}; };
struct frag_main_out { struct test_frag_main_out {
float depth : SV_Depth; float test_depth : SV_Depth;
}; };
frag_main_out frag_main(frag_main_in tint_in) { test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
frag_main_out tint_out; test_frag_main_out test_tint_out;
tint_out.depth = tint_in.coord.x; test_tint_out.test_depth = test_tint_in.test_coord.x;
return tint_out; return test_tint_out;
} }
)"); )");
@ -222,12 +222,12 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) { EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
float4 coord; float4 test_coord;
}; };
void frag_main() { void test_frag_main() {
float v = coord.x; float test_v = test_coord.x;
return; return;
} }
@ -272,14 +272,14 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct Uniforms { EXPECT_EQ(result(), R"(struct test_Uniforms {
float4 coord; float4 test_coord;
}; };
ConstantBuffer<Uniforms> uniforms : register(b0); ConstantBuffer<test_Uniforms> test_uniforms : register(b0);
void frag_main() { void test_frag_main() {
float v = uniforms.coord.x; float test_v = test_uniforms.test_coord.x;
return; return;
} }
@ -323,10 +323,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0); EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
void frag_main() { void test_frag_main() {
float v = asfloat(coord.Load(4)); float test_v = asfloat(test_coord.Load(4));
return; return;
} }
@ -371,10 +371,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(ByteAddressBuffer coord : register(u0); EXPECT_EQ(result(), R"(ByteAddressBuffer test_coord : register(u0);
void frag_main() { void test_frag_main() {
float v = asfloat(coord.Load(4)); float test_v = asfloat(test_coord.Load(4));
return; return;
} }
@ -416,10 +416,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0); EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
void frag_main() { void test_frag_main() {
coord.Store(4, asuint(2.0f)); test_coord.Store(4, asuint(2.0f));
return; return;
} }
@ -480,25 +480,25 @@ TEST_F(
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_in { EXPECT_EQ(result(), R"(struct test_ep_1_in {
float foo : TEXCOORD0; float test_foo : TEXCOORD0;
}; };
struct ep_1_out { struct test_ep_1_out {
float bar : SV_Target1; float test_bar : SV_Target1;
float val : SV_Target0; float test_val : SV_Target0;
}; };
float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) { float test_sub_func_ep_1(in test_ep_1_in test_tint_in, out test_ep_1_out test_tint_out, float test_param) {
tint_out.bar = tint_in.foo; test_tint_out.test_bar = test_tint_in.test_foo;
tint_out.val = param; test_tint_out.test_val = test_param;
return tint_in.foo; return test_tint_in.test_foo;
} }
ep_1_out ep_1(ep_1_in tint_in) { test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
ep_1_out tint_out; test_ep_1_out test_tint_out;
tint_out.bar = sub_func_ep_1(tint_in, tint_out, 1.0f); test_tint_out.test_bar = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -542,18 +542,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_out { EXPECT_EQ(result(), R"(struct test_ep_1_out {
float depth : SV_Depth; float test_depth : SV_Depth;
}; };
float sub_func(float param) { float test_sub_func(float test_param) {
return param; return test_param;
} }
ep_1_out ep_1() { test_ep_1_out test_ep_1() {
ep_1_out tint_out; test_ep_1_out test_tint_out;
tint_out.depth = sub_func(1.0f); test_tint_out.test_depth = test_sub_func(1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -609,23 +609,23 @@ TEST_F(
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_in { EXPECT_EQ(result(), R"(struct test_ep_1_in {
float4 coord : SV_Position; float4 test_coord : SV_Position;
}; };
struct ep_1_out { struct test_ep_1_out {
float depth : SV_Depth; float test_depth : SV_Depth;
}; };
float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) { float test_sub_func_ep_1(in test_ep_1_in test_tint_in, out test_ep_1_out test_tint_out, float test_param) {
tint_out.depth = tint_in.coord.x; test_tint_out.test_depth = test_tint_in.test_coord.x;
return param; return test_param;
} }
ep_1_out ep_1(ep_1_in tint_in) { test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
ep_1_out tint_out; test_ep_1_out test_tint_out;
tint_out.depth = sub_func_ep_1(tint_in, tint_out, 1.0f); test_tint_out.test_depth = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -672,16 +672,16 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) { EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
float4 coord; float4 test_coord;
}; };
float sub_func(float param) { float test_sub_func(float test_param) {
return coord.x; return test_coord.x;
} }
void frag_main() { void test_frag_main() {
float v = sub_func(1.0f); float test_v = test_sub_func(1.0f);
return; return;
} }
@ -730,14 +730,14 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0); EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
float sub_func(float param) { float test_sub_func(float test_param) {
return asfloat(coord.Load((4 * 0))); return asfloat(test_coord.Load((4 * 0)));
} }
void frag_main() { void test_frag_main() {
float v = sub_func(1.0f); float test_v = test_sub_func(1.0f);
return; return;
} }
@ -775,17 +775,17 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_out { EXPECT_EQ(result(), R"(struct test_ep_1_out {
float bar : SV_Target1; float test_bar : SV_Target1;
}; };
ep_1_out ep_1() { test_ep_1_out test_ep_1() {
ep_1_out tint_out; test_ep_1_out test_tint_out;
tint_out.bar = 1.0f; test_tint_out.test_bar = 1.0f;
if ((1 == 1)) { if ((1 == 1)) {
return tint_out; return test_tint_out;
} }
return tint_out; return test_tint_out;
} }
)"); )");
@ -807,7 +807,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"([numthreads(1, 1, 1)] EXPECT_EQ(result(), R"([numthreads(1, 1, 1)]
void main() { void test_main() {
return; return;
} }
@ -831,7 +831,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"([numthreads(2, 4, 6)] EXPECT_EQ(result(), R"([numthreads(2, 4, 6)]
void main() { void test_main() {
return; return;
} }
@ -852,7 +852,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithArrayParams) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"( void my_func(float a[5]) { EXPECT_EQ(result(), R"( void test_my_func(float test_a[5]) {
return; return;
} }
@ -930,21 +930,21 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct Data { EXPECT_EQ(result(), R"(struct test_Data {
float d; float test_d;
}; };
RWByteAddressBuffer data : register(u0); RWByteAddressBuffer test_data : register(u0);
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void a() { void test_a() {
float v = asfloat(data.Load(0)); float test_v = asfloat(test_data.Load(0));
return; return;
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void b() { void test_b() {
float v = asfloat(data.Load(0)); float test_v = asfloat(test_data.Load(0));
return; return;
} }

2
src/writer/hlsl/generator_impl_identifier_test.cc
View File

@ -26,7 +26,7 @@ using HlslGeneratorImplTest_Identifier = TestHelper;
TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) { TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
auto* i = Expr("foo"); auto* i = Expr("foo");
ASSERT_TRUE(gen.EmitExpression(pre, out, i)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, i)) << gen.error();
EXPECT_EQ(result(), "foo"); EXPECT_EQ(result(), "test_foo");
} }
} // namespace } // namespace

12
src/writer/hlsl/generator_impl_if_test.cc
View File

@ -35,7 +35,7 @@ TEST_F(HlslGeneratorImplTest_If, Emit_If) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) { EXPECT_EQ(result(), R"( if (test_cond) {
return; return;
} }
)"); )");
@ -58,10 +58,10 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) { EXPECT_EQ(result(), R"( if (test_cond) {
return; return;
} else { } else {
if (else_cond) { if (test_else_cond) {
return; return;
} }
} }
@ -84,7 +84,7 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) { EXPECT_EQ(result(), R"( if (test_cond) {
return; return;
} else { } else {
return; return;
@ -117,10 +117,10 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) { EXPECT_EQ(result(), R"( if (test_cond) {
return; return;
} else { } else {
if (else_cond) { if (test_else_cond) {
return; return;
} else { } else {
return; return;

2
src/writer/hlsl/generator_impl_import_test.cc
View File

@ -198,7 +198,7 @@ TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitCall(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitCall(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), std::string("determinant(var)")); EXPECT_EQ(result(), std::string("determinant(test_var)"));
} }
} // namespace } // namespace

6
src/writer/hlsl/generator_impl_intrinsic_test.cc
View File

@ -87,7 +87,9 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, DISABLED_Intrinsic_OuterProduct) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
EXPECT_EQ(result(), " float3x2(a * b[0], a * b[1], a * b[2])"); EXPECT_EQ(
result(),
" float3x2(test_a * test_b[0], test_a * test_b[1], test_a * test_b[2])");
} }
TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Bad_Name) { TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Bad_Name) {
@ -107,7 +109,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
EXPECT_EQ(result(), " dot(param1, param2)"); EXPECT_EQ(result(), " dot(test_param1, test_param2)");
} }
} // namespace } // namespace

197
src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
View File

@ -22,6 +22,7 @@
#include "src/ast/type/sampled_texture_type.h" #include "src/ast/type/sampled_texture_type.h"
#include "src/type_determiner.h" #include "src/type_determiner.h"
#include "src/writer/hlsl/generator_impl.h" #include "src/writer/hlsl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint { namespace tint {
namespace writer { namespace writer {
@ -33,181 +34,181 @@ std::string expected_texture_overload(
using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload; using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload;
switch (overload) { switch (overload) {
case ValidTextureOverload::kSample1dF32: case ValidTextureOverload::kSample1dF32:
return R"(texture.Sample(sampler, 1.0f))"; return R"(test_texture.Sample(test_sampler, 1.0f))";
case ValidTextureOverload::kSample1dArrayF32: case ValidTextureOverload::kSample1dArrayF32:
return R"(texture.Sample(sampler, float2(1.0f, float(2))))"; return R"(test_texture.Sample(test_sampler, float2(1.0f, float(2))))";
case ValidTextureOverload::kSample2dF32: case ValidTextureOverload::kSample2dF32:
return R"(texture.Sample(sampler, float2(1.0f, 2.0f)))"; return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSample2dOffsetF32: case ValidTextureOverload::kSample2dOffsetF32:
return R"(texture.Sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSample2dArrayF32: case ValidTextureOverload::kSample2dArrayF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3))))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3))))";
case ValidTextureOverload::kSample2dArrayOffsetF32: case ValidTextureOverload::kSample2dArrayOffsetF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
case ValidTextureOverload::kSample3dF32: case ValidTextureOverload::kSample3dF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSample3dOffsetF32: case ValidTextureOverload::kSample3dOffsetF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))";
case ValidTextureOverload::kSampleCubeF32: case ValidTextureOverload::kSampleCubeF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleCubeArrayF32: case ValidTextureOverload::kSampleCubeArrayF32:
return R"(texture.Sample(sampler, float4(1.0f, 2.0f, 3.0f, float(4))))"; return R"(test_texture.Sample(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
case ValidTextureOverload::kSampleDepth2dF32: case ValidTextureOverload::kSampleDepth2dF32:
return R"(texture.Sample(sampler, float2(1.0f, 2.0f)))"; return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSampleDepth2dOffsetF32: case ValidTextureOverload::kSampleDepth2dOffsetF32:
return R"(texture.Sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSampleDepth2dArrayF32: case ValidTextureOverload::kSampleDepth2dArrayF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3))))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3))))";
case ValidTextureOverload::kSampleDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
case ValidTextureOverload::kSampleDepthCubeF32: case ValidTextureOverload::kSampleDepthCubeF32:
return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleDepthCubeArrayF32: case ValidTextureOverload::kSampleDepthCubeArrayF32:
return R"(texture.Sample(sampler, float4(1.0f, 2.0f, 3.0f, float(4))))"; return R"(test_texture.Sample(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
case ValidTextureOverload::kSampleBias2dF32: case ValidTextureOverload::kSampleBias2dF32:
return R"(texture.SampleBias(sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(test_texture.SampleBias(test_sampler, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleBias2dOffsetF32: case ValidTextureOverload::kSampleBias2dOffsetF32:
return R"(texture.SampleBias(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(test_texture.SampleBias(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleBias2dArrayF32: case ValidTextureOverload::kSampleBias2dArrayF32:
return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, float(4)), 3.0f))"; return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
case ValidTextureOverload::kSampleBias2dArrayOffsetF32: case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))"; return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleBias3dF32: case ValidTextureOverload::kSampleBias3dF32:
return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleBias3dOffsetF32: case ValidTextureOverload::kSampleBias3dOffsetF32:
return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))"; return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
case ValidTextureOverload::kSampleBiasCubeF32: case ValidTextureOverload::kSampleBiasCubeF32:
return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleBiasCubeArrayF32: case ValidTextureOverload::kSampleBiasCubeArrayF32:
return R"(texture.SampleBias(sampler, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))"; return R"(test_texture.SampleBias(test_sampler, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))";
case ValidTextureOverload::kSampleLevel2dF32: case ValidTextureOverload::kSampleLevel2dF32:
return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleLevel2dOffsetF32: case ValidTextureOverload::kSampleLevel2dOffsetF32:
return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleLevel2dArrayF32: case ValidTextureOverload::kSampleLevel2dArrayF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4.0f))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f))";
case ValidTextureOverload::kSampleLevel2dArrayOffsetF32: case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleLevel3dF32: case ValidTextureOverload::kSampleLevel3dF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleLevel3dOffsetF32: case ValidTextureOverload::kSampleLevel3dOffsetF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
case ValidTextureOverload::kSampleLevelCubeF32: case ValidTextureOverload::kSampleLevelCubeF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleLevelCubeArrayF32: case ValidTextureOverload::kSampleLevelCubeArrayF32:
return R"(texture.SampleLevel(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))"; return R"(test_texture.SampleLevel(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
case ValidTextureOverload::kSampleLevelDepth2dF32: case ValidTextureOverload::kSampleLevelDepth2dF32:
return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3))"; return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3))";
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))"; return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
case ValidTextureOverload::kSampleLevelDepth2dArrayF32: case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4))";
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))";
case ValidTextureOverload::kSampleLevelDepthCubeF32: case ValidTextureOverload::kSampleLevelDepthCubeF32:
return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4))"; return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4))";
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32: case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
return R"(texture.SampleLevel(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5))"; return R"(test_texture.SampleLevel(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5))";
case ValidTextureOverload::kSampleGrad2dF32: case ValidTextureOverload::kSampleGrad2dF32:
return R"(texture.SampleGrad(sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))"; return R"(test_texture.SampleGrad(test_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))";
case ValidTextureOverload::kSampleGrad2dOffsetF32: case ValidTextureOverload::kSampleGrad2dOffsetF32:
return R"(texture.SampleGrad(sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))"; return R"(test_texture.SampleGrad(test_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))";
case ValidTextureOverload::kSampleGrad2dArrayF32: case ValidTextureOverload::kSampleGrad2dArrayF32:
return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))"; return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))";
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32: case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))"; return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))";
case ValidTextureOverload::kSampleGrad3dF32: case ValidTextureOverload::kSampleGrad3dF32:
return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))"; return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
case ValidTextureOverload::kSampleGrad3dOffsetF32: case ValidTextureOverload::kSampleGrad3dOffsetF32:
return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))"; return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))";
case ValidTextureOverload::kSampleGradCubeF32: case ValidTextureOverload::kSampleGradCubeF32:
return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))"; return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
case ValidTextureOverload::kSampleGradCubeArrayF32: case ValidTextureOverload::kSampleGradCubeArrayF32:
return R"(texture.SampleGrad(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))"; return R"(test_texture.SampleGrad(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))";
case ValidTextureOverload::kSampleGradDepth2dF32: case ValidTextureOverload::kSampleGradDepth2dF32:
return R"(texture.SampleCmp(sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(test_texture.SampleCmp(test_sampler, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleGradDepth2dOffsetF32: case ValidTextureOverload::kSampleGradDepth2dOffsetF32:
return R"(texture.SampleCmp(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(test_texture.SampleCmp(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleGradDepth2dArrayF32: case ValidTextureOverload::kSampleGradDepth2dArrayF32:
return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, float(4)), 3.0f))"; return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
case ValidTextureOverload::kSampleGradDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleGradDepth2dArrayOffsetF32:
return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))"; return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleGradDepthCubeF32: case ValidTextureOverload::kSampleGradDepthCubeF32:
return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleGradDepthCubeArrayF32: case ValidTextureOverload::kSampleGradDepthCubeArrayF32:
return R"(texture.SampleCmp(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))"; return R"(test_texture.SampleCmp(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
case ValidTextureOverload::kLoad1dF32: case ValidTextureOverload::kLoad1dF32:
return R"(texture.Load(int2(1, 0)))"; return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dU32: case ValidTextureOverload::kLoad1dU32:
return R"(texture.Load(int2(1, 0)))"; return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dI32: case ValidTextureOverload::kLoad1dI32:
return R"(texture.Load(int2(1, 0)))"; return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dArrayF32: case ValidTextureOverload::kLoad1dArrayF32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad1dArrayU32: case ValidTextureOverload::kLoad1dArrayU32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad1dArrayI32: case ValidTextureOverload::kLoad1dArrayI32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dF32: case ValidTextureOverload::kLoad2dF32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dU32: case ValidTextureOverload::kLoad2dU32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dI32: case ValidTextureOverload::kLoad2dI32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dLevelF32: case ValidTextureOverload::kLoad2dLevelF32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dLevelU32: case ValidTextureOverload::kLoad2dLevelU32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dLevelI32: case ValidTextureOverload::kLoad2dLevelI32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dArrayF32: case ValidTextureOverload::kLoad2dArrayF32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad2dArrayU32: case ValidTextureOverload::kLoad2dArrayU32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad2dArrayI32: case ValidTextureOverload::kLoad2dArrayI32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad2dArrayLevelF32: case ValidTextureOverload::kLoad2dArrayLevelF32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad2dArrayLevelU32: case ValidTextureOverload::kLoad2dArrayLevelU32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad2dArrayLevelI32: case ValidTextureOverload::kLoad2dArrayLevelI32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dF32: case ValidTextureOverload::kLoad3dF32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad3dU32: case ValidTextureOverload::kLoad3dU32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad3dI32: case ValidTextureOverload::kLoad3dI32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoad3dLevelF32: case ValidTextureOverload::kLoad3dLevelF32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dLevelU32: case ValidTextureOverload::kLoad3dLevelU32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dLevelI32: case ValidTextureOverload::kLoad3dLevelI32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dF32: case ValidTextureOverload::kLoadMultisampled2dF32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dU32: case ValidTextureOverload::kLoadMultisampled2dU32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dI32: case ValidTextureOverload::kLoadMultisampled2dI32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dArrayF32: case ValidTextureOverload::kLoadMultisampled2dArrayF32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayU32: case ValidTextureOverload::kLoadMultisampled2dArrayU32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayI32: case ValidTextureOverload::kLoadMultisampled2dArrayI32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadDepth2dF32: case ValidTextureOverload::kLoadDepth2dF32:
return R"(texture.Load(int3(1, 2, 0)))"; return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoadDepth2dLevelF32: case ValidTextureOverload::kLoadDepth2dLevelF32:
return R"(texture.Load(int3(1, 2, 0), 3))"; return R"(test_texture.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadDepth2dArrayF32: case ValidTextureOverload::kLoadDepth2dArrayF32:
return R"(texture.Load(int4(1, 2, 3, 0)))"; return R"(test_texture.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoadDepth2dArrayLevelF32: case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
return R"(texture.Load(int4(1, 2, 3, 0), 4))"; return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadStorageRO1dRgba32float: case ValidTextureOverload::kLoadStorageRO1dRgba32float:
return R"(texture.Load(1))"; return R"(test_texture.Load(1))";
case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float: case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float:
return R"(texture.Load(int2(1, 2)))"; return R"(test_texture.Load(int2(1, 2)))";
case ValidTextureOverload::kLoadStorageRO2dRgba8unorm: case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8snorm: case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8uint: case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
@ -224,21 +225,21 @@ std::string expected_texture_overload(
case ValidTextureOverload::kLoadStorageRO2dRgba32uint: case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
case ValidTextureOverload::kLoadStorageRO2dRgba32sint: case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
case ValidTextureOverload::kLoadStorageRO2dRgba32float: case ValidTextureOverload::kLoadStorageRO2dRgba32float:
return R"(texture.Load(int2(1, 2)))"; return R"(test_texture.Load(int2(1, 2)))";
case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float: case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
return R"(texture.Load(int3(1, 2, 3)))"; return R"(test_texture.Load(int3(1, 2, 3)))";
case ValidTextureOverload::kLoadStorageRO3dRgba32float: case ValidTextureOverload::kLoadStorageRO3dRgba32float:
return R"(texture.Load(int3(1, 2, 3)))"; return R"(test_texture.Load(int3(1, 2, 3)))";
case ValidTextureOverload::kStoreWO1dRgba32float: case ValidTextureOverload::kStoreWO1dRgba32float:
return R"(texture[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))"; return R"(test_texture[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))";
case ValidTextureOverload::kStoreWO1dArrayRgba32float: case ValidTextureOverload::kStoreWO1dArrayRgba32float:
return R"(texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))"; return R"(test_texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
case ValidTextureOverload::kStoreWO2dRgba32float: case ValidTextureOverload::kStoreWO2dRgba32float:
return R"(texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))"; return R"(test_texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
case ValidTextureOverload::kStoreWO2dArrayRgba32float: case ValidTextureOverload::kStoreWO2dArrayRgba32float:
return R"(texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))"; return R"(test_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
case ValidTextureOverload::kStoreWO3dRgba32float: case ValidTextureOverload::kStoreWO3dRgba32float:
return R"(texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))"; return R"(test_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
} }
return "<unmatched texture overload>"; return "<unmatched texture overload>";
} // NOLINT - Ignore the length of this function } // NOLINT - Ignore the length of this function
@ -258,8 +259,10 @@ class HlslGeneratorIntrinsicTextureTest
/// The type determiner /// The type determiner
TypeDeterminer td{mod}; TypeDeterminer td{mod};
/// The namer
TestNamer namer{mod};
/// The generator /// The generator
GeneratorImpl gen{mod}; GeneratorImpl gen{mod, &namer};
/// The output stream /// The output stream
std::ostringstream out; std::ostringstream out;
/// The pre-output stream /// The pre-output stream

12
src/writer/hlsl/generator_impl_loop_test.cc
View File

@ -100,7 +100,7 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopNestedWithContinuing) {
bool tint_hlsl_is_first_1 = true; bool tint_hlsl_is_first_1 = true;
for(;;) { for(;;) {
if (!tint_hlsl_is_first_1) { if (!tint_hlsl_is_first_1) {
lhs = rhs; test_lhs = test_rhs;
} }
tint_hlsl_is_first_1 = false; tint_hlsl_is_first_1 = false;
@ -163,16 +163,16 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) {
ASSERT_TRUE(gen.EmitStatement(out, outer)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, outer)) << gen.error();
EXPECT_EQ(result(), R"( { EXPECT_EQ(result(), R"( {
bool tint_hlsl_is_first_1 = true; bool tint_hlsl_is_first_1 = true;
float lhs; float test_lhs;
float other; float test_other;
for(;;) { for(;;) {
if (!tint_hlsl_is_first_1) { if (!tint_hlsl_is_first_1) {
lhs = rhs; test_lhs = test_rhs;
} }
tint_hlsl_is_first_1 = false; tint_hlsl_is_first_1 = false;
lhs = 2.400000095f; test_lhs = 2.400000095f;
other = 0.0f; test_other = 0.0f;
} }
} }
)"); )");

84
src/writer/hlsl/generator_impl_member_accessor_test.cc
View File

@ -54,7 +54,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "str.mem"); EXPECT_EQ(result(), "test_str.test_mem");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -85,7 +85,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load(4))"); EXPECT_EQ(result(), "asfloat(test_data.Load(4))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -115,7 +115,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asint(data.Load(0))"); EXPECT_EQ(result(), "asint(test_data.Load(0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
EmitExpression_MemberAccessor_StorageBuffer_Store_Matrix) { EmitExpression_MemberAccessor_StorageBuffer_Store_Matrix) {
@ -156,9 +156,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), R"(float3x2 _tint_tmp = b; EXPECT_EQ(result(), R"(float3x2 _tint_tmp = test_b;
data.Store3(4 + 0, asuint(_tint_tmp[0])); test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
data.Store3(4 + 16, asuint(_tint_tmp[1])); test_data.Store3(4 + 16, asuint(_tint_tmp[1]));
)"); )");
} }
@ -200,8 +200,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
EXPECT_EQ( EXPECT_EQ(
result(), result(),
R"(float3x2 _tint_tmp = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); R"(float3x2 _tint_tmp = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
data.Store3(4 + 0, asuint(_tint_tmp[0])); test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
data.Store3(4 + 16, asuint(_tint_tmp[1])); test_data.Store3(4 + 16, asuint(_tint_tmp[1]));
)"); )");
} }
@ -236,8 +236,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
"asfloat(uint2x3(data.Load2(4 + 0), data.Load2(4 + 8), " "asfloat(uint2x3(test_data.Load2(4 + 0), test_data.Load2(4 + 8), "
"data.Load2(4 + 16)))"); "test_data.Load2(4 + 16)))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -274,8 +274,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(
"asfloat(uint3x2(data.Load3(4 + 0), data.Load3(4 + 16)))"); result(),
"asfloat(uint3x2(test_data.Load3(4 + 0), test_data.Load3(4 + 16)))");
} }
TEST_F( TEST_F(
@ -307,8 +308,8 @@ TEST_F(
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
"asfloat(uint3x3(data.Load3(0 + 0), data.Load3(0 + 16), " "asfloat(uint3x3(test_data.Load3(0 + 0), test_data.Load3(0 + 16), "
"data.Load3(0 + 32)))"); "test_data.Load3(0 + 32)))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -340,7 +341,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + (16 * 2) + 16))"); EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + (16 * 2) + 16))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -372,7 +373,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asint(data.Load((4 * 2) + 0))"); EXPECT_EQ(result(), "asint(test_data.Load((4 * 2) + 0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -405,7 +406,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asint(data.Load((4 * ((2 + 4) - 3)) + 0))"); EXPECT_EQ(result(), "asint(test_data.Load((4 * ((2 + 4) - 3)) + 0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -439,7 +440,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), R"(data.Store(4, asuint(2.0f)); EXPECT_EQ(result(), R"(test_data.Store(4, asuint(2.0f));
)"); )");
} }
@ -477,7 +478,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)) << td.error(); ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), R"(data.Store((4 * 2) + 0, asuint(2)); EXPECT_EQ(result(), R"(test_data.Store((4 * 2) + 0, asuint(2));
)"); )");
} }
@ -512,7 +513,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), R"(data.Store(0, asuint(2)); EXPECT_EQ(result(), R"(test_data.Store(0, asuint(2));
)"); )");
} }
@ -545,7 +546,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load3(16))"); EXPECT_EQ(result(), "asfloat(test_data.Load3(16))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -581,7 +582,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
R"(data.Store3(16, asuint(float3(1.0f, 2.0f, 3.0f))); R"(test_data.Store3(16, asuint(float3(1.0f, 2.0f, 3.0f)));
)"); )");
} }
@ -631,7 +632,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(test_data.Load3(16 + (32 * 2) + 0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -679,7 +680,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0)).xy"); EXPECT_EQ(result(), "asfloat(test_data.Load3(16 + (32 * 2) + 0)).xy");
} }
TEST_F( TEST_F(
@ -730,7 +731,7 @@ TEST_F(
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + 16 + (32 * 2) + 0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -780,7 +781,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)); ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + 16 + (32 * 2) + 0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -832,8 +833,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(
R"(data.Store3(16 + (32 * 2) + 0, asuint(float3(1.0f, 2.0f, 3.0f))); result(),
R"(test_data.Store3(16 + (32 * 2) + 0, asuint(float3(1.0f, 2.0f, 3.0f)));
)"); )");
} }
@ -888,10 +890,34 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign)); ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
R"(data.Store((4 * 1) + 16 + (32 * 2) + 0, asuint(1.0f)); R"(test_data.Store((4 * 1) + 16 + (32 * 2) + 0, asuint(1.0f));
)"); )");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor,
EmitExpression_MemberAccessor_Swizzle_xyz) {
auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
td.RegisterVariableForTesting(vec);
mod->AddGlobalVariable(vec);
auto* expr = MemberAccessor("my_vec", "xyz");
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "test_my_vec.xyz");
}
TEST_F(HlslGeneratorImplTest_MemberAccessor,
EmitExpression_MemberAccessor_Swizzle_gbr) {
auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
td.RegisterVariableForTesting(vec);
mod->AddGlobalVariable(vec);
auto* expr = MemberAccessor("my_vec", "gbr");
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "test_my_vec.gbr");
}
} // namespace } // namespace
} // namespace hlsl } // namespace hlsl
} // namespace writer } // namespace writer

6
src/writer/hlsl/generator_impl_module_constant_test.cc
View File

@ -38,7 +38,7 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_ModuleConstant) {
array<f32, 3>(1.f, 2.f, 3.f), ast::VariableDecorationList{}); array<f32, 3>(1.f, 2.f, 3.f), ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitProgramConstVariable(out, var)) << gen.error(); ASSERT_TRUE(gen.EmitProgramConstVariable(out, var)) << gen.error();
EXPECT_EQ(result(), "static const float pos[3] = {1.0f, 2.0f, 3.0f};\n"); EXPECT_EQ(result(), "static const float test_pos[3] = {1.0f, 2.0f, 3.0f};\n");
} }
TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) { TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
@ -51,7 +51,7 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23 EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
#define WGSL_SPEC_CONSTANT_23 3.0f #define WGSL_SPEC_CONSTANT_23 3.0f
#endif #endif
static const float pos = WGSL_SPEC_CONSTANT_23; static const float test_pos = WGSL_SPEC_CONSTANT_23;
#undef WGSL_SPEC_CONSTANT_23 #undef WGSL_SPEC_CONSTANT_23
)"); )");
} }
@ -66,7 +66,7 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant_NoConstructor) {
EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23 EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
#error spec constant required for constant id 23 #error spec constant required for constant id 23
#endif #endif
static const float pos = WGSL_SPEC_CONSTANT_23; static const float test_pos = WGSL_SPEC_CONSTANT_23;
#undef WGSL_SPEC_CONSTANT_23 #undef WGSL_SPEC_CONSTANT_23
)"); )");
} }

2
src/writer/hlsl/generator_impl_return_test.cc
View File

@ -40,7 +40,7 @@ TEST_F(HlslGeneratorImplTest_Return, Emit_ReturnWithValue) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, r)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, r)) << gen.error();
EXPECT_EQ(result(), " return expr;\n"); EXPECT_EQ(result(), " return test_expr;\n");
} }
} // namespace } // namespace

2
src/writer/hlsl/generator_impl_switch_test.cc
View File

@ -54,7 +54,7 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, s)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, s)) << gen.error();
EXPECT_EQ(result(), R"( switch(cond) { EXPECT_EQ(result(), R"( switch(test_cond) {
case 5: { case 5: {
break; break;
} }

2
src/writer/hlsl/generator_impl_test.cc
View File

@ -33,7 +33,7 @@ TEST_F(HlslGeneratorImplTest, Generate) {
mod->AddFunction(func); mod->AddFunction(func);
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(void my_func() { EXPECT_EQ(result(), R"(void test_my_func() {
} }
)"); )");

49
src/writer/hlsl/generator_impl_type_test.cc
View File

@ -47,20 +47,20 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Alias) {
auto* alias = ty.alias("alias", ty.f32); auto* alias = ty.alias("alias", ty.f32);
ASSERT_TRUE(gen.EmitType(out, alias, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(out, alias, Symbol())) << gen.error();
EXPECT_EQ(result(), "alias"); EXPECT_EQ(result(), "test_alias");
} }
TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) { TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) {
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(out, ty.array<bool, 4>(), sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(out, ty.array<bool, 4>(), sym)) << gen.error();
EXPECT_EQ(result(), "bool ary[4]"); EXPECT_EQ(result(), "bool test_ary[4]");
} }
TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) { TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) {
auto* arr = ty.array(ty.array<bool, 4>(), 5); auto* arr = ty.array(ty.array<bool, 4>(), 5);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
EXPECT_EQ(result(), "bool ary[5][4]"); EXPECT_EQ(result(), "bool test_ary[5][4]");
} }
// TODO(dsinclair): Is this possible? What order should it output in? // TODO(dsinclair): Is this possible? What order should it output in?
@ -69,14 +69,14 @@ TEST_F(HlslGeneratorImplTest_Type,
auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 0); auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 0);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
EXPECT_EQ(result(), "bool ary[5][4][1]"); EXPECT_EQ(result(), "bool test_ary[5][4][1]");
} }
TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) { TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) {
auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 6); auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 6);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
EXPECT_EQ(result(), "bool ary[6][5][4]"); EXPECT_EQ(result(), "bool test_ary[6][5][4]");
} }
TEST_F(HlslGeneratorImplTest_Type, EmitType_Array_WithoutName) { TEST_F(HlslGeneratorImplTest_Type, EmitType_Array_WithoutName) {
@ -125,10 +125,11 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_StructDecl) {
ast::StructDecorationList{}); ast::StructDecorationList{});
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error(); ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
EXPECT_EQ(result(), R"(struct S { << gen.error();
int a; EXPECT_EQ(result(), R"(struct test_S {
float b; int test_a;
float test_b;
}; };
)"); )");
} }
@ -140,8 +141,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct) {
ast::StructDecorationList{}); ast::StructDecorationList{});
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(out, s, mod->RegisterSymbol("S"))) << gen.error();
EXPECT_EQ(result(), "S"); EXPECT_EQ(result(), "test_S");
} }
TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_InjectPadding) { TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_InjectPadding) {
@ -153,13 +154,13 @@ TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_InjectPadding) {
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error();
EXPECT_EQ(result(), R"(struct { EXPECT_EQ(result(), R"(struct test_S {
int8_t pad_0[4]; int8_t pad_0[4];
int a; int test_a;
int8_t pad_1[24]; int8_t pad_1[24];
float b; float test_b;
int8_t pad_2[92]; int8_t pad_2[92];
float c; float test_c;
})"); })");
} }
@ -169,10 +170,11 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) {
ast::StructDecorationList{}); ast::StructDecorationList{});
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error(); ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
EXPECT_EQ(result(), R"(struct S { << gen.error();
int double; EXPECT_EQ(result(), R"(struct test_S {
float float; int test_double;
float test_float;
}; };
)"); )");
} }
@ -188,10 +190,11 @@ TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_WithDecoration) {
decos); decos);
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "B")) << gen.error(); ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("B")))
EXPECT_EQ(result(), R"(struct B { << gen.error();
int a; EXPECT_EQ(result(), R"(struct test_B {
float b; int test_a;
float test_b;
})"); })");
} }

2
src/writer/hlsl/generator_impl_unary_op_test.cc
View File

@ -41,7 +41,7 @@ TEST_P(HlslUnaryOpTest, Emit) {
auto* op = create<ast::UnaryOpExpression>(params.op, expr); auto* op = create<ast::UnaryOpExpression>(params.op, expr);
ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
EXPECT_EQ(result(), std::string(params.name) + "(expr)"); EXPECT_EQ(result(), std::string(params.name) + "(test_expr)");
} }
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp, INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp,
HlslUnaryOpTest, HlslUnaryOpTest,

16
src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
View File

@ -39,7 +39,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), " float a;\n"); EXPECT_EQ(result(), " float test_a;\n");
} }
TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) { TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) {
@ -49,7 +49,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), " const float a;\n"); EXPECT_EQ(result(), " const float test_a;\n");
} }
TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) { TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) {
@ -59,7 +59,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), " float a[5];\n"); EXPECT_EQ(result(), " float test_a[5];\n");
} }
TEST_F(HlslGeneratorImplTest_VariableDecl, TEST_F(HlslGeneratorImplTest_VariableDecl,
@ -70,7 +70,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), " float a;\n"); EXPECT_EQ(result(), " float test_a;\n");
} }
TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) { TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
@ -80,7 +80,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), " float a;\n"); EXPECT_EQ(result(), " float test_a;\n");
} }
TEST_F(HlslGeneratorImplTest_VariableDecl, TEST_F(HlslGeneratorImplTest_VariableDecl,
@ -90,7 +90,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
auto* stmt = create<ast::VariableDeclStatement>(var); auto* stmt = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), R"(float a = initializer; EXPECT_EQ(result(), R"(float test_a = test_initializer;
)"); )");
} }
@ -101,7 +101,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
auto* stmt = create<ast::VariableDeclStatement>(var); auto* stmt = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), R"(float3 a = float3(0.0f); EXPECT_EQ(result(), R"(float3 test_a = float3(0.0f);
)"); )");
} }
@ -113,7 +113,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
auto* stmt = create<ast::VariableDeclStatement>(var); auto* stmt = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
R"(float3x2 a = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); R"(float3x2 test_a = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
)"); )");
} }

5
src/writer/hlsl/test_helper.h
View File

@ -24,6 +24,7 @@
#include "src/ast/builder.h" #include "src/ast/builder.h"
#include "src/type_determiner.h" #include "src/type_determiner.h"
#include "src/writer/hlsl/generator_impl.h" #include "src/writer/hlsl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint { namespace tint {
namespace writer { namespace writer {
@ -33,7 +34,7 @@ namespace hlsl {
template <typename BODY> template <typename BODY>
class TestHelperBase : public BODY, public ast::BuilderWithModule { class TestHelperBase : public BODY, public ast::BuilderWithModule {
public: public:
TestHelperBase() : td(mod), gen(mod) {} TestHelperBase() : td(mod), namer(mod), gen(mod, &namer) {}
~TestHelperBase() = default; ~TestHelperBase() = default;
/// @returns the result string /// @returns the result string
@ -44,6 +45,8 @@ class TestHelperBase : public BODY, public ast::BuilderWithModule {
/// The type determiner /// The type determiner
TypeDeterminer td; TypeDeterminer td;
/// The test namer
TestNamer namer;
/// The generator /// The generator
GeneratorImpl gen; GeneratorImpl gen;