encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-05-16 12:21:35 +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)
: 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;
void Generator::Reset() {
set_error("");
out_ = std::ostringstream();
impl_ = std::make_unique<GeneratorImpl>(&module_);
namer_->Reset();
impl_ = std::make_unique<GeneratorImpl>(&module_, namer_.get());
}
bool Generator::Generate() {

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

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

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

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

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

@ -54,7 +54,8 @@ class GeneratorImpl {
public:
/// Constructor
/// @param module the module to generate
explicit GeneratorImpl(ast::Module* module);
/// @param namer the namer to use
GeneratorImpl(ast::Module* module, Namer* namer);
~GeneratorImpl();
/// Increment the emitter indent level
@ -295,11 +296,11 @@ class GeneratorImpl {
/// Handles generating a structure declaration
/// @param out the output stream
/// @param ty the struct to generate
/// @param name the struct name
/// @param sym the struct symbol
/// @returns true if the struct is emitted
bool EmitStructType(std::ostream& out,
const ast::type::Struct* ty,
const std::string& name);
const Symbol& sym);
/// Handles a unary op expression
/// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
@ -382,18 +383,18 @@ class GeneratorImpl {
enum class VarType { kIn, kOut };
struct EntryPointData {
std::string struct_name;
std::string var_name;
Symbol struct_symbol;
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 error_;
size_t indent_ = 0;
ast::Module* module_ = nullptr;
std::unique_ptr<Namer> namer_;
Namer* namer_;
Symbol current_ep_sym_;
bool generating_entry_point_ = false;
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
// 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.
std::unordered_map<std::string, std::string> ep_func_name_remapped_;
std::unordered_map<std::string, Symbol> ep_func_name_remapped_;
};
} // 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);
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);
ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error();
EXPECT_EQ(result(), R"(struct B {
float a;
int b;
EXPECT_EQ(result(), R"(struct test_B {
float test_a;
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);
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) {
auto* expr = IndexAccessor("ary", "idx");
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "ary[idx]");
EXPECT_EQ(result(), "test_ary[test_idx]");
}
} // 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();
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), " lhs = rhs;\n");
EXPECT_EQ(result(), " test_lhs = test_rhs;\n");
}
} // namespace

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

@ -115,22 +115,23 @@ INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest,
HlslBinaryTest,
testing::Values(
BinaryData{"(left & right)", ast::BinaryOp::kAnd},
BinaryData{"(left | right)", ast::BinaryOp::kOr},
BinaryData{"(left ^ right)", ast::BinaryOp::kXor},
BinaryData{"(left == right)", ast::BinaryOp::kEqual},
BinaryData{"(left != right)", ast::BinaryOp::kNotEqual},
BinaryData{"(left < right)", ast::BinaryOp::kLessThan},
BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan},
BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual},
BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual},
BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft},
BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight},
BinaryData{"(left + right)", ast::BinaryOp::kAdd},
BinaryData{"(left - right)", ast::BinaryOp::kSubtract},
BinaryData{"(left * right)", ast::BinaryOp::kMultiply},
BinaryData{"(left / right)", ast::BinaryOp::kDivide},
BinaryData{"(left % right)", ast::BinaryOp::kModulo}));
BinaryData{"(test_left & test_right)", ast::BinaryOp::kAnd},
BinaryData{"(test_left | test_right)", ast::BinaryOp::kOr},
BinaryData{"(test_left ^ test_right)", ast::BinaryOp::kXor},
BinaryData{"(test_left == test_right)", ast::BinaryOp::kEqual},
BinaryData{"(test_left != test_right)", ast::BinaryOp::kNotEqual},
BinaryData{"(test_left < test_right)", ast::BinaryOp::kLessThan},
BinaryData{"(test_left > test_right)", ast::BinaryOp::kGreaterThan},
BinaryData{"(test_left <= test_right)", ast::BinaryOp::kLessThanEqual},
BinaryData{"(test_left >= test_right)",
ast::BinaryOp::kGreaterThanEqual},
BinaryData{"(test_left << test_right)", ast::BinaryOp::kShiftLeft},
BinaryData{"(test_left >> test_right)", ast::BinaryOp::kShiftRight},
BinaryData{"(test_left + test_right)", ast::BinaryOp::kAdd},
BinaryData{"(test_left - test_right)", ast::BinaryOp::kSubtract},
BinaryData{"(test_left * test_right)", ast::BinaryOp::kMultiply},
BinaryData{"(test_left / test_right)", ast::BinaryOp::kDivide},
BinaryData{"(test_left % test_right)", ast::BinaryOp::kModulo}));
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
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();
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) {
@ -187,7 +188,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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) {
@ -202,7 +203,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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) {
@ -217,7 +218,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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) {
@ -232,7 +233,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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) {
@ -244,9 +245,9 @@ TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
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) {
_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();
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) {
_tint_tmp = b;
_tint_tmp = test_b;
}
bool _tint_tmp_0 = (_tint_tmp);
if (!_tint_tmp_0) {
bool _tint_tmp_1 = c;
bool _tint_tmp_1 = test_c;
if (!_tint_tmp_1) {
_tint_tmp_1 = d;
_tint_tmp_1 = test_d;
}
_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();
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) {
_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();
EXPECT_EQ(result(), R"(bool _tint_tmp = a;
EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
if (_tint_tmp) {
_tint_tmp = b;
_tint_tmp = test_b;
}
if ((_tint_tmp)) {
return 1;
} else {
bool _tint_tmp_0 = b;
bool _tint_tmp_0 = test_b;
if (!_tint_tmp_0) {
_tint_tmp_0 = c;
_tint_tmp_0 = test_c;
}
if ((_tint_tmp_0)) {
return 2;
@ -363,13 +364,13 @@ TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, a, b), c));
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) {
_tint_tmp = b;
_tint_tmp = test_b;
}
bool _tint_tmp_0 = (_tint_tmp);
if (!_tint_tmp_0) {
_tint_tmp_0 = c;
_tint_tmp_0 = test_c;
}
return (_tint_tmp_0);
)");
@ -389,15 +390,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c), d));
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) {
_tint_tmp = c;
_tint_tmp = test_c;
}
bool _tint_tmp_0 = (_tint_tmp);
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);
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) {
_tint_tmp = c;
_tint_tmp = test_c;
}
bool _tint_tmp_0 = (_tint_tmp);
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)));
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) {
bool _tint_tmp_0 = b;
bool _tint_tmp_0 = test_b;
if (!_tint_tmp_0) {
_tint_tmp_0 = c;
_tint_tmp_0 = test_c;
}
_tint_tmp = (_tint_tmp_0);
}
@ -478,27 +479,27 @@ TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) {
auto* expr = create<ast::CallStatement>(Call("foo", params));
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) {
_tint_tmp = b;
_tint_tmp = test_b;
}
bool _tint_tmp_0 = c;
bool _tint_tmp_0 = test_c;
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) {
_tint_tmp_1 = c;
_tint_tmp_1 = test_c;
}
bool _tint_tmp_2 = (_tint_tmp_1);
if (_tint_tmp_2) {
bool _tint_tmp_3 = b;
bool _tint_tmp_3 = test_b;
if (!_tint_tmp_3) {
_tint_tmp_3 = d;
_tint_tmp_3 = test_d;
}
_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);
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) {
@ -42,7 +42,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
auto* bitcast = create<ast::BitcastExpression>(ty.i32, id);
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) {
@ -50,7 +50,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
auto* bitcast = create<ast::BitcastExpression>(ty.u32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
EXPECT_EQ(result(), "asuint(id)");
EXPECT_EQ(result(), "asuint(test_id)");
}
} // 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);
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) {
@ -48,7 +48,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
mod->AddFunction(func);
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) {
@ -59,7 +59,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
mod->AddFunction(func);
gen.increment_indent();
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

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) {
auto* cast = Construct<f32>("id");
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) {
auto* cast = vec3<f32>("id");
ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error();
EXPECT_EQ(result(), "float3(id)");
EXPECT_EQ(result(), "float3(test_id)");
}
} // 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(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct vtx_main_in {
float foo : TEXCOORD0;
int bar : TEXCOORD1;
EXPECT_EQ(result(), R"(struct test_vtx_main_in {
float test_foo : TEXCOORD0;
int test_bar : TEXCOORD1;
};
)");
@ -126,9 +126,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct vtx_main_out {
float foo : TEXCOORD0;
int bar : TEXCOORD1;
EXPECT_EQ(result(), R"(struct test_vtx_main_out {
float test_foo : TEXCOORD0;
int test_bar : TEXCOORD1;
};
)");
@ -176,9 +176,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_in {
float foo : TEXCOORD0;
int bar : TEXCOORD1;
EXPECT_EQ(result(), R"(struct test_main_in {
float test_foo : TEXCOORD0;
int test_bar : TEXCOORD1;
};
)");
@ -226,9 +226,9 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_out {
float foo : SV_Target0;
int bar : SV_Target1;
EXPECT_EQ(result(), R"(struct test_main_out {
float test_foo : SV_Target0;
int test_bar : SV_Target1;
};
)");
@ -365,12 +365,12 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
EXPECT_EQ(result(), R"(struct main_in {
float4 coord : SV_Position;
EXPECT_EQ(result(), R"(struct test_main_in {
float4 test_coord : SV_Position;
};
struct main_out {
float depth : SV_Depth;
struct test_main_out {
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();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"( void my_func() {
EXPECT_EQ(result(), R"( void test_my_func() {
return;
}
@ -85,7 +85,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithParams) {
gen.increment_indent();
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;
}
@ -124,18 +124,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct frag_main_in {
float foo : TEXCOORD0;
EXPECT_EQ(result(), R"(struct test_frag_main_in {
float test_foo : TEXCOORD0;
};
struct frag_main_out {
float bar : SV_Target1;
struct test_frag_main_out {
float test_bar : SV_Target1;
};
frag_main_out frag_main(frag_main_in tint_in) {
frag_main_out tint_out;
tint_out.bar = tint_in.foo;
return tint_out;
test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
test_frag_main_out test_tint_out;
test_tint_out.test_bar = test_tint_in.test_foo;
return test_tint_out;
}
)");
@ -176,18 +176,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct frag_main_in {
float4 coord : SV_Position;
EXPECT_EQ(result(), R"(struct test_frag_main_in {
float4 test_coord : SV_Position;
};
struct frag_main_out {
float depth : SV_Depth;
struct test_frag_main_out {
float test_depth : SV_Depth;
};
frag_main_out frag_main(frag_main_in tint_in) {
frag_main_out tint_out;
tint_out.depth = tint_in.coord.x;
return tint_out;
test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
test_frag_main_out test_tint_out;
test_tint_out.test_depth = test_tint_in.test_coord.x;
return test_tint_out;
}
)");
@ -222,12 +222,12 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) {
float4 coord;
EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
float4 test_coord;
};
void frag_main() {
float v = coord.x;
void test_frag_main() {
float test_v = test_coord.x;
return;
}
@ -272,14 +272,14 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct Uniforms {
float4 coord;
EXPECT_EQ(result(), R"(struct test_Uniforms {
float4 test_coord;
};
ConstantBuffer<Uniforms> uniforms : register(b0);
ConstantBuffer<test_Uniforms> test_uniforms : register(b0);
void frag_main() {
float v = uniforms.coord.x;
void test_frag_main() {
float test_v = test_uniforms.test_coord.x;
return;
}
@ -323,10 +323,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.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() {
float v = asfloat(coord.Load(4));
void test_frag_main() {
float test_v = asfloat(test_coord.Load(4));
return;
}
@ -371,10 +371,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.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() {
float v = asfloat(coord.Load(4));
void test_frag_main() {
float test_v = asfloat(test_coord.Load(4));
return;
}
@ -416,10 +416,10 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.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() {
coord.Store(4, asuint(2.0f));
void test_frag_main() {
test_coord.Store(4, asuint(2.0f));
return;
}
@ -480,25 +480,25 @@ TEST_F(
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_in {
float foo : TEXCOORD0;
EXPECT_EQ(result(), R"(struct test_ep_1_in {
float test_foo : TEXCOORD0;
};
struct ep_1_out {
float bar : SV_Target1;
float val : SV_Target0;
struct test_ep_1_out {
float test_bar : SV_Target1;
float test_val : SV_Target0;
};
float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) {
tint_out.bar = tint_in.foo;
tint_out.val = param;
return tint_in.foo;
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) {
test_tint_out.test_bar = test_tint_in.test_foo;
test_tint_out.test_val = test_param;
return test_tint_in.test_foo;
}
ep_1_out ep_1(ep_1_in tint_in) {
ep_1_out tint_out;
tint_out.bar = sub_func_ep_1(tint_in, tint_out, 1.0f);
return tint_out;
test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
test_ep_1_out test_tint_out;
test_tint_out.test_bar = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
return test_tint_out;
}
)");
@ -542,18 +542,18 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_out {
float depth : SV_Depth;
EXPECT_EQ(result(), R"(struct test_ep_1_out {
float test_depth : SV_Depth;
};
float sub_func(float param) {
return param;
float test_sub_func(float test_param) {
return test_param;
}
ep_1_out ep_1() {
ep_1_out tint_out;
tint_out.depth = sub_func(1.0f);
return tint_out;
test_ep_1_out test_ep_1() {
test_ep_1_out test_tint_out;
test_tint_out.test_depth = test_sub_func(1.0f);
return test_tint_out;
}
)");
@ -609,23 +609,23 @@ TEST_F(
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_in {
float4 coord : SV_Position;
EXPECT_EQ(result(), R"(struct test_ep_1_in {
float4 test_coord : SV_Position;
};
struct ep_1_out {
float depth : SV_Depth;
struct test_ep_1_out {
float test_depth : SV_Depth;
};
float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) {
tint_out.depth = tint_in.coord.x;
return 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) {
test_tint_out.test_depth = test_tint_in.test_coord.x;
return test_param;
}
ep_1_out ep_1(ep_1_in tint_in) {
ep_1_out tint_out;
tint_out.depth = sub_func_ep_1(tint_in, tint_out, 1.0f);
return tint_out;
test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
test_ep_1_out test_tint_out;
test_tint_out.test_depth = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
return test_tint_out;
}
)");
@ -672,16 +672,16 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) {
float4 coord;
EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
float4 test_coord;
};
float sub_func(float param) {
return coord.x;
float test_sub_func(float test_param) {
return test_coord.x;
}
void frag_main() {
float v = sub_func(1.0f);
void test_frag_main() {
float test_v = test_sub_func(1.0f);
return;
}
@ -730,14 +730,14 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.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) {
return asfloat(coord.Load((4 * 0)));
float test_sub_func(float test_param) {
return asfloat(test_coord.Load((4 * 0)));
}
void frag_main() {
float v = sub_func(1.0f);
void test_frag_main() {
float test_v = test_sub_func(1.0f);
return;
}
@ -775,17 +775,17 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct ep_1_out {
float bar : SV_Target1;
EXPECT_EQ(result(), R"(struct test_ep_1_out {
float test_bar : SV_Target1;
};
ep_1_out ep_1() {
ep_1_out tint_out;
tint_out.bar = 1.0f;
test_ep_1_out test_ep_1() {
test_ep_1_out test_tint_out;
test_tint_out.test_bar = 1.0f;
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(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"([numthreads(1, 1, 1)]
void main() {
void test_main() {
return;
}
@ -831,7 +831,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"([numthreads(2, 4, 6)]
void main() {
void test_main() {
return;
}
@ -852,7 +852,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithArrayParams) {
gen.increment_indent();
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;
}
@ -930,21 +930,21 @@ TEST_F(HlslGeneratorImplTest_Function,
ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(struct Data {
float d;
EXPECT_EQ(result(), R"(struct test_Data {
float test_d;
};
RWByteAddressBuffer data : register(u0);
RWByteAddressBuffer test_data : register(u0);
[numthreads(1, 1, 1)]
void a() {
float v = asfloat(data.Load(0));
void test_a() {
float test_v = asfloat(test_data.Load(0));
return;
}
[numthreads(1, 1, 1)]
void b() {
float v = asfloat(data.Load(0));
void test_b() {
float test_v = asfloat(test_data.Load(0));
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) {
auto* i = Expr("foo");
ASSERT_TRUE(gen.EmitExpression(pre, out, i)) << gen.error();
EXPECT_EQ(result(), "foo");
EXPECT_EQ(result(), "test_foo");
}
} // 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();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) {
EXPECT_EQ(result(), R"( if (test_cond) {
return;
}
)");
@ -58,10 +58,10 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) {
gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) {
EXPECT_EQ(result(), R"( if (test_cond) {
return;
} else {
if (else_cond) {
if (test_else_cond) {
return;
}
}
@ -84,7 +84,7 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) {
gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) {
EXPECT_EQ(result(), R"( if (test_cond) {
return;
} else {
return;
@ -117,10 +117,10 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
EXPECT_EQ(result(), R"( if (cond) {
EXPECT_EQ(result(), R"( if (test_cond) {
return;
} else {
if (else_cond) {
if (test_else_cond) {
return;
} else {
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.DetermineResultType(expr)) << td.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

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();
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) {
@ -107,7 +109,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
gen.increment_indent();
ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
EXPECT_EQ(result(), " dot(param1, param2)");
EXPECT_EQ(result(), " dot(test_param1, test_param2)");
}
} // 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/type_determiner.h"
#include "src/writer/hlsl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint {
namespace writer {
@ -33,181 +34,181 @@ std::string expected_texture_overload(
using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload;
switch (overload) {
case ValidTextureOverload::kSample1dF32:
return R"(texture.Sample(sampler, 1.0f))";
return R"(test_texture.Sample(test_sampler, 1.0f))";
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
return R"(texture.Load(int2(1, 0)))";
return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dU32:
return R"(texture.Load(int2(1, 0)))";
return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dI32:
return R"(texture.Load(int2(1, 0)))";
return R"(test_texture.Load(int2(1, 0)))";
case ValidTextureOverload::kLoad1dArrayF32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad1dArrayU32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad1dArrayI32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dF32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dU32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoad2dI32:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
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:
return R"(texture.Load(int3(1, 2, 0), 3))";
return R"(test_texture.Load(int3(1, 2, 0), 3))";
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:
return R"(texture.Load(int4(1, 2, 3, 0)))";
return R"(test_texture.Load(int4(1, 2, 3, 0)))";
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:
return R"(texture.Load(int4(1, 2, 3, 0)))";
return R"(test_texture.Load(int4(1, 2, 3, 0)))";
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:
return R"(texture.Load(int4(1, 2, 3, 0), 4))";
return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
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:
return R"(texture.Load(int4(1, 2, 3, 0)))";
return R"(test_texture.Load(int4(1, 2, 3, 0)))";
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:
return R"(texture.Load(int4(1, 2, 3, 0)))";
return R"(test_texture.Load(int4(1, 2, 3, 0)))";
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:
return R"(texture.Load(int4(1, 2, 3, 0), 4))";
return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
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:
return R"(texture.Load(int3(1, 2, 0), 3))";
return R"(test_texture.Load(int3(1, 2, 0), 3))";
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:
return R"(texture.Load(int3(1, 2, 0), 3))";
return R"(test_texture.Load(int3(1, 2, 0), 3))";
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:
return R"(texture.Load(int4(1, 2, 3, 0), 4))";
return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
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:
return R"(texture.Load(int3(1, 2, 0)))";
return R"(test_texture.Load(int3(1, 2, 0)))";
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:
return R"(texture.Load(int4(1, 2, 3, 0)))";
return R"(test_texture.Load(int4(1, 2, 3, 0)))";
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:
return R"(texture.Load(1))";
return R"(test_texture.Load(1))";
case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float:
return R"(texture.Load(int2(1, 2)))";
return R"(test_texture.Load(int2(1, 2)))";
case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
@ -224,21 +225,21 @@ std::string expected_texture_overload(
case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
case ValidTextureOverload::kLoadStorageRO2dRgba32float:
return R"(texture.Load(int2(1, 2)))";
return R"(test_texture.Load(int2(1, 2)))";
case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
return R"(texture.Load(int3(1, 2, 3)))";
return R"(test_texture.Load(int3(1, 2, 3)))";
case ValidTextureOverload::kLoadStorageRO3dRgba32float:
return R"(texture.Load(int3(1, 2, 3)))";
return R"(test_texture.Load(int3(1, 2, 3)))";
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:
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:
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:
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:
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>";
} // NOLINT - Ignore the length of this function
@ -258,8 +259,10 @@ class HlslGeneratorIntrinsicTextureTest
/// The type determiner
TypeDeterminer td{mod};
/// The namer
TestNamer namer{mod};
/// The generator
GeneratorImpl gen{mod};
GeneratorImpl gen{mod, &namer};
/// The output stream
std::ostringstream out;
/// 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;
for(;;) {
if (!tint_hlsl_is_first_1) {
lhs = rhs;
test_lhs = test_rhs;
}
tint_hlsl_is_first_1 = false;
@ -163,16 +163,16 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) {
ASSERT_TRUE(gen.EmitStatement(out, outer)) << gen.error();
EXPECT_EQ(result(), R"( {
bool tint_hlsl_is_first_1 = true;
float lhs;
float other;
float test_lhs;
float test_other;
for(;;) {
if (!tint_hlsl_is_first_1) {
lhs = rhs;
test_lhs = test_rhs;
}
tint_hlsl_is_first_1 = false;
lhs = 2.400000095f;
other = 0.0f;
test_lhs = 2.400000095f;
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(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(), "str.mem");
EXPECT_EQ(result(), "test_str.test_mem");
}
TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -85,7 +85,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
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,
@ -115,7 +115,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
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,
EmitExpression_MemberAccessor_StorageBuffer_Store_Matrix) {
@ -156,9 +156,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(), R"(float3x2 _tint_tmp = b;
data.Store3(4 + 0, asuint(_tint_tmp[0]));
data.Store3(4 + 16, asuint(_tint_tmp[1]));
EXPECT_EQ(result(), R"(float3x2 _tint_tmp = test_b;
test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
test_data.Store3(4 + 16, asuint(_tint_tmp[1]));
)");
}
@ -200,8 +200,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
EXPECT_EQ(
result(),
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]));
data.Store3(4 + 16, asuint(_tint_tmp[1]));
test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
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();
EXPECT_EQ(result(),
"asfloat(uint2x3(data.Load2(4 + 0), data.Load2(4 + 8), "
"data.Load2(4 + 16)))");
"asfloat(uint2x3(test_data.Load2(4 + 0), test_data.Load2(4 + 8), "
"test_data.Load2(4 + 16)))");
}
TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -274,8 +274,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(),
"asfloat(uint3x2(data.Load3(4 + 0), data.Load3(4 + 16)))");
EXPECT_EQ(
result(),
"asfloat(uint3x2(test_data.Load3(4 + 0), test_data.Load3(4 + 16)))");
}
TEST_F(
@ -307,8 +308,8 @@ TEST_F(
ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
EXPECT_EQ(result(),
"asfloat(uint3x3(data.Load3(0 + 0), data.Load3(0 + 16), "
"data.Load3(0 + 32)))");
"asfloat(uint3x3(test_data.Load3(0 + 0), test_data.Load3(0 + 16), "
"test_data.Load3(0 + 32)))");
}
TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -340,7 +341,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
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,
@ -372,7 +373,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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,
@ -405,7 +406,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr)) << td.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,
@ -439,7 +440,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign));
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(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(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(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,
@ -581,7 +582,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
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(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,
@ -679,7 +680,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
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(
@ -730,7 +731,7 @@ TEST_F(
ASSERT_TRUE(td.DetermineResultType(expr));
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,
@ -780,7 +781,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(expr));
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,
@ -832,8 +833,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.DetermineResultType(assign));
ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
EXPECT_EQ(result(),
R"(data.Store3(16 + (32 * 2) + 0, asuint(float3(1.0f, 2.0f, 3.0f)));
EXPECT_EQ(
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(gen.EmitStatement(out, assign)) << gen.error();
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 hlsl
} // 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{});
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) {
@ -51,7 +51,7 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
#define WGSL_SPEC_CONSTANT_23 3.0f
#endif
static const float pos = WGSL_SPEC_CONSTANT_23;
static const float test_pos = 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
#error spec constant required for constant id 23
#endif
static const float pos = WGSL_SPEC_CONSTANT_23;
static const float test_pos = 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();
ASSERT_TRUE(gen.EmitStatement(out, r)) << gen.error();
EXPECT_EQ(result(), " return expr;\n");
EXPECT_EQ(result(), " return test_expr;\n");
}
} // 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();
ASSERT_TRUE(gen.EmitStatement(out, s)) << gen.error();
EXPECT_EQ(result(), R"( switch(cond) {
EXPECT_EQ(result(), R"( switch(test_cond) {
case 5: {
break;
}

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

@ -33,7 +33,7 @@ TEST_F(HlslGeneratorImplTest, Generate) {
mod->AddFunction(func);
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);
ASSERT_TRUE(gen.EmitType(out, alias, Symbol())) << gen.error();
EXPECT_EQ(result(), "alias");
EXPECT_EQ(result(), "test_alias");
}
TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) {
auto sym = mod->RegisterSymbol("ary");
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) {
auto* arr = ty.array(ty.array<bool, 4>(), 5);
auto sym = mod->RegisterSymbol("ary");
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?
@ -69,14 +69,14 @@ TEST_F(HlslGeneratorImplTest_Type,
auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 0);
auto sym = mod->RegisterSymbol("ary");
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) {
auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 6);
auto sym = mod->RegisterSymbol("ary");
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) {
@ -125,10 +125,11 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_StructDecl) {
ast::StructDecorationList{});
auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error();
EXPECT_EQ(result(), R"(struct S {
int a;
float b;
ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
<< gen.error();
EXPECT_EQ(result(), R"(struct test_S {
int test_a;
float test_b;
};
)");
}
@ -140,8 +141,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct) {
ast::StructDecorationList{});
auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error();
EXPECT_EQ(result(), "S");
ASSERT_TRUE(gen.EmitType(out, s, mod->RegisterSymbol("S"))) << gen.error();
EXPECT_EQ(result(), "test_S");
}
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);
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];
int a;
int test_a;
int8_t pad_1[24];
float b;
float test_b;
int8_t pad_2[92];
float c;
float test_c;
})");
}
@ -169,10 +170,11 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) {
ast::StructDecorationList{});
auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error();
EXPECT_EQ(result(), R"(struct S {
int double;
float float;
ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
<< gen.error();
EXPECT_EQ(result(), R"(struct test_S {
int test_double;
float test_float;
};
)");
}
@ -188,10 +190,11 @@ TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_WithDecoration) {
decos);
auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(out, s, "B")) << gen.error();
EXPECT_EQ(result(), R"(struct B {
int a;
float b;
ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("B")))
<< gen.error();
EXPECT_EQ(result(), R"(struct test_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);
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,
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();
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) {
@ -49,7 +49,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) {
gen.increment_indent();
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) {
@ -59,7 +59,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) {
gen.increment_indent();
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,
@ -70,7 +70,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
gen.increment_indent();
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) {
@ -80,7 +80,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
gen.increment_indent();
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,
@ -90,7 +90,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl,
auto* stmt = create<ast::VariableDeclStatement>(var);
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);
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);
ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
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/type_determiner.h"
#include "src/writer/hlsl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint {
namespace writer {
@ -33,7 +34,7 @@ namespace hlsl {
template <typename BODY>
class TestHelperBase : public BODY, public ast::BuilderWithModule {
public:
TestHelperBase() : td(mod), gen(mod) {}
TestHelperBase() : td(mod), namer(mod), gen(mod, &namer) {}
~TestHelperBase() = default;
/// @returns the result string
@ -44,6 +45,8 @@ class TestHelperBase : public BODY, public ast::BuilderWithModule {
/// The type determiner
TypeDeterminer td;
/// The test namer
TestNamer namer;
/// The generator
GeneratorImpl gen;