Move intrinsic overload tests from Validator -> TypeDeterminer
TypeDeterminer now does overload resolution. Move these tests to the right place.
Change-Id: I27a4fccac34ded00f9828a77cc25ccfe1cb5c0ea
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/41383
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Auto-Submit: Ben Clayton <bclayton@google.com>
diff --git a/src/type_determiner_test.cc b/src/type_determiner_test.cc
index 4b3d698..8dc1575 100644
--- a/src/type_determiner_test.cc
+++ b/src/type_determiner_test.cc
@@ -19,6 +19,7 @@
#include <utility>
#include <vector>
+#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
@@ -73,6 +74,8 @@
#include "src/type/u32_type.h"
#include "src/type/vector_type.h"
+using ::testing::HasSubstr;
+
namespace tint {
namespace {
@@ -1576,7 +1579,19 @@
TextureTestParams{type::TextureDimension::k2dArray},
TextureTestParams{type::TextureDimension::k3d}));
-TEST_F(TypeDeterminerTest, Intrinsic_Dot) {
+TEST_F(TypeDeterminerTest, Intrinsic_Dot_Vec2) {
+ Global("my_var", ast::StorageClass::kNone, ty.vec2<f32>());
+
+ auto* expr = Call("dot", "my_var", "my_var");
+ WrapInFunction(expr);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(expr), nullptr);
+ EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Dot_Vec3) {
Global("my_var", ast::StorageClass::kNone, ty.vec3<f32>());
auto* expr = Call("dot", "my_var", "my_var");
@@ -1588,6 +1603,48 @@
EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
}
+TEST_F(TypeDeterminerTest, Intrinsic_Dot_Vec4) {
+ Global("my_var", ast::StorageClass::kNone, ty.vec4<f32>());
+
+ auto* expr = Call("dot", "my_var", "my_var");
+ WrapInFunction(expr);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(expr), nullptr);
+ EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Dot_Error_Scalar) {
+ auto* expr = Call("dot", 1.0f, 1.0f);
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to dot(f32, f32)
+
+1 candidate function:
+ dot(vecN<f32>, vecN<f32>) -> f32
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Dot_Error_VectorInt) {
+ Global("my_var", ast::StorageClass::kNone, ty.vec4<i32>());
+
+ auto* expr = Call("dot", "my_var", "my_var");
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to dot(ptr<vec4<i32>>, ptr<vec4<i32>>)
+
+1 candidate function:
+ dot(vecN<f32>, vecN<f32>) -> f32
+)");
+}
+
TEST_F(TypeDeterminerTest, Intrinsic_Select) {
Global("my_var", ast::StorageClass::kNone, ty.vec3<f32>());
@@ -1604,7 +1661,7 @@
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
}
-TEST_F(TypeDeterminerTest, Intrinsic_Select_NoParams) {
+TEST_F(TypeDeterminerTest, Intrinsic_Select_Error_NoParams) {
auto* expr = Call("select");
WrapInFunction(expr);
@@ -1619,6 +1676,68 @@
)");
}
+TEST_F(TypeDeterminerTest, Intrinsic_Select_Error_SelectorInt) {
+ auto* expr = Call("select", Expr(1), Expr(1), Expr(1));
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to select(i32, i32, i32)
+
+2 candidate functions:
+ select(T, T, bool) -> T where: T is scalar
+ select(vecN<T>, vecN<T>, vecN<bool>) -> vecN<T> where: T is scalar
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Select_Error_Matrix) {
+ auto* mat = mat2x2<float>(vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f));
+ auto* expr = Call("select", mat, mat, Expr(true));
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to select(mat2x2<f32>, mat2x2<f32>, bool)
+
+2 candidate functions:
+ select(T, T, bool) -> T where: T is scalar
+ select(vecN<T>, vecN<T>, vecN<bool>) -> vecN<T> where: T is scalar
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Select_Error_MismatchTypes) {
+ auto* expr = Call("select", 1.0f, vec2<float>(2.0f, 3.0f), Expr(true));
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to select(f32, vec2<f32>, bool)
+
+2 candidate functions:
+ select(T, T, bool) -> T where: T is scalar
+ select(vecN<T>, vecN<T>, vecN<bool>) -> vecN<T> where: T is scalar
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Select_Error_MismatchVectorSize) {
+ auto* expr = Call("select", vec2<float>(1.0f, 2.0f),
+ vec3<float>(3.0f, 4.0f, 5.0f), Expr(true));
+ WrapInFunction(expr);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to select(vec2<f32>, vec3<f32>, bool)
+
+2 candidate functions:
+ select(T, T, bool) -> T where: T is scalar
+ select(vecN<T>, vecN<T>, vecN<bool>) -> vecN<T> where: T is scalar
+)");
+}
+
using UnaryOpExpressionTest = TypeDeterminerTestWithParam<ast::UnaryOp>;
TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) {
auto op = GetParam();
@@ -1787,6 +1906,50 @@
EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
}
+TEST_P(Intrinsic_DataPackingTest, Error_IncorrectParamType) {
+ auto param = GetParam();
+
+ bool pack4 = param.intrinsic == IntrinsicType::kPack4x8Snorm ||
+ param.intrinsic == IntrinsicType::kPack4x8Unorm;
+
+ auto* call = pack4 ? Call(param.name, vec4<i32>(1, 2, 3, 4))
+ : Call(param.name, vec2<i32>(1, 2));
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_THAT(td()->error(),
+ HasSubstr("no matching call to " + std::string(param.name)));
+}
+
+TEST_P(Intrinsic_DataPackingTest, Error_NoParams) {
+ auto param = GetParam();
+
+ auto* call = Call(param.name);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_THAT(td()->error(),
+ HasSubstr("no matching call to " + std::string(param.name)));
+}
+
+TEST_P(Intrinsic_DataPackingTest, Error_TooManyParams) {
+ auto param = GetParam();
+
+ bool pack4 = param.intrinsic == IntrinsicType::kPack4x8Snorm ||
+ param.intrinsic == IntrinsicType::kPack4x8Unorm;
+
+ auto* call = pack4 ? Call(param.name, vec4<f32>(1.f, 2.f, 3.f, 4.f), 1.0f)
+ : Call(param.name, vec2<f32>(1.f, 2.f), 1.0f);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_THAT(td()->error(),
+ HasSubstr("no matching call to " + std::string(param.name)));
+}
+
INSTANTIATE_TEST_SUITE_P(
TypeDeterminerTest,
Intrinsic_DataPackingTest,
@@ -1869,6 +2032,22 @@
"(vecN<f32>) -> vecN<f32>\n");
}
+TEST_P(Intrinsic_SingleParamTest, Error_TooManyParams) {
+ auto param = GetParam();
+
+ auto* call = Call(param.name, 1, 2, 3);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(), "no matching call to " + std::string(param.name) +
+ "(i32, i32, i32)\n\n"
+ "2 candidate functions:\n " +
+ std::string(param.name) + "(f32) -> f32\n " +
+ std::string(param.name) +
+ "(vecN<f32>) -> vecN<f32>\n");
+}
+
INSTANTIATE_TEST_SUITE_P(
TypeDeterminerTest,
Intrinsic_SingleParamTest,
@@ -1894,6 +2073,30 @@
IntrinsicData{"tanh", IntrinsicType::kTanh},
IntrinsicData{"trunc", IntrinsicType::kTrunc}));
+TEST_F(IntrinsicDataTest, ArrayLength_Vector) {
+ Global("arr", ast::StorageClass::kNone, ty.array<int>());
+ auto* call = Call("arrayLength", "arr");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+}
+
+TEST_F(IntrinsicDataTest, ArrayLength_Error_ArraySized) {
+ Global("arr", ast::StorageClass::kNone, ty.array<int, 4>());
+ auto* call = Call("arrayLength", "arr");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to arrayLength(ptr<array<i32, 4>>)\n\n"
+ "1 candidate function:\n"
+ " arrayLength(array<T>) -> u32\n");
+}
+
TEST_F(IntrinsicDataTest, Normalize_Vector) {
auto* call = Call("normalize", vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
@@ -1913,8 +2116,169 @@
EXPECT_EQ(td()->error(),
"no matching call to normalize()\n\n"
- "1 candidate function:\n "
- "normalize(vecN<f32>) -> vecN<f32>\n");
+ "1 candidate function:\n"
+ " normalize(vecN<f32>) -> vecN<f32>\n");
+}
+
+TEST_F(IntrinsicDataTest, FrexpScalar) {
+ Global("exp", ast::StorageClass::kWorkgroup, ty.i32());
+ auto* call = Call("frexp", 1.0f, "exp");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+}
+
+TEST_F(IntrinsicDataTest, FrexpVector) {
+ Global("exp", ast::StorageClass::kWorkgroup, ty.vec3<i32>());
+ auto* call = Call("frexp", vec3<f32>(1.0f, 2.0f, 3.0f), "exp");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::Vector>());
+ EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+}
+
+TEST_F(IntrinsicDataTest, Frexp_Error_FirstParamInt) {
+ Global("exp", ast::StorageClass::kWorkgroup, ty.i32());
+ auto* call = Call("frexp", 1, "exp");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to frexp(i32, ptr<workgroup, i32>)\n\n"
+ "2 candidate functions:\n"
+ " frexp(f32, ptr<T>) -> f32 where: T is i32 or u32\n"
+ " frexp(vecN<f32>, ptr<vecN<T>>) -> vecN<f32> "
+ "where: T is i32 or u32\n");
+}
+
+TEST_F(IntrinsicDataTest, Frexp_Error_SecondParamFloatPtr) {
+ Global("exp", ast::StorageClass::kWorkgroup, ty.f32());
+ auto* call = Call("frexp", 1.0f, "exp");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to frexp(f32, ptr<workgroup, f32>)\n\n"
+ "2 candidate functions:\n"
+ " frexp(f32, ptr<T>) -> f32 where: T is i32 or u32\n"
+ " frexp(vecN<f32>, ptr<vecN<T>>) -> vecN<f32> "
+ "where: T is i32 or u32\n");
+}
+
+TEST_F(IntrinsicDataTest, Frexp_Error_SecondParamNotAPointer) {
+ auto* call = Call("frexp", 1.0f, 1);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to frexp(f32, i32)\n\n"
+ "2 candidate functions:\n"
+ " frexp(f32, ptr<T>) -> f32 where: T is i32 or u32\n"
+ " frexp(vecN<f32>, ptr<vecN<T>>) -> vecN<f32> "
+ "where: T is i32 or u32\n");
+}
+
+TEST_F(IntrinsicDataTest, Frexp_Error_VectorSizesDontMatch) {
+ Global("exp", ast::StorageClass::kWorkgroup, ty.vec4<i32>());
+ auto* call = Call("frexp", vec2<f32>(1.0f, 2.0f), "exp");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(
+ td()->error(),
+ "no matching call to frexp(vec2<f32>, ptr<workgroup, vec4<i32>>)\n\n"
+ "2 candidate functions:\n"
+ " frexp(f32, ptr<T>) -> f32 where: T is i32 or u32\n"
+ " frexp(vecN<f32>, ptr<vecN<T>>) -> vecN<f32> "
+ "where: T is i32 or u32\n");
+}
+
+TEST_F(IntrinsicDataTest, ModfScalar) {
+ Global("whole", ast::StorageClass::kWorkgroup, ty.f32());
+ auto* call = Call("modf", 1.0f, "whole");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+}
+
+TEST_F(IntrinsicDataTest, ModfVector) {
+ Global("whole", ast::StorageClass::kWorkgroup, ty.vec3<f32>());
+ auto* call = Call("modf", vec3<f32>(1.0f, 2.0f, 3.0f), "whole");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::Vector>());
+ EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+}
+
+TEST_F(IntrinsicDataTest, Modf_Error_FirstParamInt) {
+ Global("whole", ast::StorageClass::kWorkgroup, ty.f32());
+ auto* call = Call("modf", 1, "whole");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to modf(i32, ptr<workgroup, f32>)\n\n"
+ "2 candidate functions:\n"
+ " modf(f32, ptr<f32>) -> f32\n"
+ " modf(vecN<f32>, ptr<vecN<f32>>) -> vecN<f32>\n");
+}
+
+TEST_F(IntrinsicDataTest, Modf_Error_SecondParamIntPtr) {
+ Global("whole", ast::StorageClass::kWorkgroup, ty.i32());
+ auto* call = Call("modf", 1.0f, "whole");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to modf(f32, ptr<workgroup, i32>)\n\n"
+ "2 candidate functions:\n"
+ " modf(f32, ptr<f32>) -> f32\n"
+ " modf(vecN<f32>, ptr<vecN<f32>>) -> vecN<f32>\n");
+}
+
+TEST_F(IntrinsicDataTest, Modf_Error_SecondParamNotAPointer) {
+ auto* call = Call("modf", 1.0f, 1.0f);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to modf(f32, f32)\n\n"
+ "2 candidate functions:\n"
+ " modf(f32, ptr<f32>) -> f32\n"
+ " modf(vecN<f32>, ptr<vecN<f32>>) -> vecN<f32>\n");
+}
+
+TEST_F(IntrinsicDataTest, Modf_Error_VectorSizesDontMatch) {
+ Global("whole", ast::StorageClass::kWorkgroup, ty.vec4<f32>());
+ auto* call = Call("modf", vec2<f32>(1.0f, 2.0f), "whole");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to modf(vec2<f32>, ptr<workgroup, vec4<f32>>)\n\n"
+ "2 candidate functions:\n"
+ " modf(vecN<f32>, ptr<vecN<f32>>) -> vecN<f32>\n"
+ " modf(f32, ptr<f32>) -> f32\n");
}
using Intrinsic_SingleParam_FloatOrInt_Test =
@@ -2077,6 +2441,24 @@
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->size(), 3u);
}
+
+TEST_P(Intrinsic_TwoParamTest, Error_NoTooManyParams) {
+ auto param = GetParam();
+
+ auto* call = Call(param.name, 1, 2, 3);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(), "no matching call to " + std::string(param.name) +
+ "(i32, i32, i32)\n\n"
+ "2 candidate functions:\n " +
+ std::string(param.name) +
+ "(f32, f32) -> f32\n " +
+ std::string(param.name) +
+ "(vecN<f32>, vecN<f32>) -> vecN<f32>\n");
+}
+
TEST_P(Intrinsic_TwoParamTest, Error_NoParams) {
auto param = GetParam();
@@ -2093,6 +2475,7 @@
std::string(param.name) +
"(vecN<f32>, vecN<f32>) -> vecN<f32>\n");
}
+
INSTANTIATE_TEST_SUITE_P(
TypeDeterminerTest,
Intrinsic_TwoParamTest,
@@ -2124,7 +2507,7 @@
TEST_F(TypeDeterminerTest, Intrinsic_Cross) {
auto* call =
- Call("cross", vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
+ Call("cross", vec3<f32>(1.0f, 2.0f, 3.0f), vec3<f32>(1.0f, 2.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -2134,7 +2517,7 @@
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->size(), 3u);
}
-TEST_F(TypeDeterminerTest, Intrinsic_Cross_NoArgs) {
+TEST_F(TypeDeterminerTest, Intrinsic_Cross_Error_NoArgs) {
auto* call = Call("cross");
WrapInFunction(call);
@@ -2147,6 +2530,62 @@
)");
}
+TEST_F(TypeDeterminerTest, Intrinsic_Cross_Error_Scalar) {
+ auto* call = Call("cross", 1.0f, 1.0f);
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(), R"(no matching call to cross(f32, f32)
+
+1 candidate function:
+ cross(vec3<f32>, vec3<f32>) -> vec3<f32>
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Cross_Error_Vec3Int) {
+ auto* call = Call("cross", vec3<i32>(1, 2, 3), vec3<i32>(1, 2, 3));
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(), R"(no matching call to cross(vec3<i32>, vec3<i32>)
+
+1 candidate function:
+ cross(vec3<f32>, vec3<f32>) -> vec3<f32>
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Cross_Error_Vec4) {
+ auto* call = Call("cross", vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f),
+ vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f));
+
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(), R"(no matching call to cross(vec4<f32>, vec4<f32>)
+
+1 candidate function:
+ cross(vec3<f32>, vec3<f32>) -> vec3<f32>
+)");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Cross_Error_TooManyParams) {
+ auto* call = Call("cross", vec3<f32>(1.0f, 2.0f, 3.0f),
+ vec3<f32>(1.0f, 2.0f, 3.0f), vec3<f32>(1.0f, 2.0f, 3.0f));
+
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ R"(no matching call to cross(vec3<f32>, vec3<f32>, vec3<f32>)
+
+1 candidate function:
+ cross(vec3<f32>, vec3<f32>) -> vec3<f32>
+)");
+}
TEST_F(TypeDeterminerTest, Intrinsic_Normalize) {
auto* call = Call("normalize", vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
@@ -2479,7 +2918,19 @@
testing::Values(IntrinsicData{"min", IntrinsicType::kMin},
IntrinsicData{"max", IntrinsicType::kMax}));
-TEST_F(TypeDeterminerTest, Intrinsic_GLSL_Determinant) {
+TEST_F(TypeDeterminerTest, Intrinsic_Determinant_2x2) {
+ Global("var", ast::StorageClass::kFunction, ty.mat2x2<f32>());
+
+ auto* call = Call("determinant", "var");
+ WrapInFunction(call);
+
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Determinant_3x3) {
Global("var", ast::StorageClass::kFunction, ty.mat3x3<f32>());
auto* call = Call("determinant", "var");
@@ -2491,30 +2942,45 @@
EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
}
-using Intrinsic_Matrix_OneParam_Test =
- TypeDeterminerTestWithParam<IntrinsicData>;
+TEST_F(TypeDeterminerTest, Intrinsic_Determinant_4x4) {
+ Global("var", ast::StorageClass::kFunction, ty.mat4x4<f32>());
-TEST_P(Intrinsic_Matrix_OneParam_Test, NoParams) {
- auto param = GetParam();
+ auto* call = Call("determinant", "var");
+ WrapInFunction(call);
- auto* call = Call(param.name);
+ EXPECT_TRUE(td()->Determine()) << td()->error();
+
+ ASSERT_NE(TypeOf(call), nullptr);
+ EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_Determinant_NotSquare) {
+ Global("var", ast::StorageClass::kFunction, ty.mat2x3<f32>());
+
+ auto* call = Call("determinant", "var");
WrapInFunction(call);
EXPECT_FALSE(td()->Determine());
- EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
EXPECT_EQ(td()->error(),
- "no matching call to " + std::string(param.name) + R"(()
-
-1 candidate function:
- determinant(matNxN<f32>) -> f32
-)");
+ "no matching call to determinant(ptr<function, mat2x3<f32>>)\n\n"
+ "1 candidate function:\n"
+ " determinant(matNxN<f32>) -> f32\n");
}
-INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
- Intrinsic_Matrix_OneParam_Test,
- testing::Values(IntrinsicData{
- "determinant", IntrinsicType::kDeterminant}));
+TEST_F(TypeDeterminerTest, Intrinsic_Determinant_NotMatrix) {
+ Global("var", ast::StorageClass::kFunction, ty.f32());
+
+ auto* call = Call("determinant", "var");
+ WrapInFunction(call);
+
+ EXPECT_FALSE(td()->Determine());
+
+ EXPECT_EQ(td()->error(),
+ "no matching call to determinant(ptr<function, f32>)\n\n"
+ "1 candidate function:\n"
+ " determinant(matNxN<f32>) -> f32\n");
+}
TEST_F(TypeDeterminerTest, Function_EntryPoints_StageDecoration) {
// fn b() {}
diff --git a/src/validator/validator_builtins_test.cc b/src/validator/validator_builtins_test.cc
index f960554..f0b7924 100644
--- a/src/validator/validator_builtins_test.cc
+++ b/src/validator/validator_builtins_test.cc
@@ -69,50 +69,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Length_Integer_Scalar) {
- auto* builtin = Call("length", 1);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for length. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Length_Integer_Vec2) {
- auto* builtin = Call("length", vec2<uint32_t>(1, 1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for length. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Length_TooManyParams) {
- auto* builtin = Call("length", 1.0f, 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for length expected 1 got 2");
-}
-
-TEST_F(ValidatorBuiltinsTest, Length_TooFewParams) {
- auto* builtin = Call("length");
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for length expected 1 got 0");
-}
-
TEST_F(ValidatorBuiltinsTest, Distance_Float_Scalar) {
auto* builtin = Call("distance", 1.0f, 1.0f);
WrapInFunction(builtin);
@@ -152,52 +108,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Distance_Integer_Scalar) {
- auto* builtin = Call("distance", 1, 1);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "incorrect type for distance. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Distance_Integer_Vec2) {
- auto* builtin = Call("distance", vec2<uint32_t>(1, 1), vec2<uint32_t>(1, 1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "incorrect type for distance. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Distance_TooManyParams) {
- auto* builtin = Call("distance", 1.0f, 1.0f, 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for distance expected 2 got 3");
-}
-
-TEST_F(ValidatorBuiltinsTest, Distance_TooFewParams) {
- auto* builtin = Call("distance", 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for distance expected 2 got 1");
-}
-
TEST_F(ValidatorBuiltinsTest, Determinant_Mat2x2) {
auto* builtin = Call("determinant", mat2x2<float>(vec2<float>(1.0f, 1.0f),
vec2<float>(1.0f, 1.0f)));
@@ -233,74 +143,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Determinant_Mat3x2) {
- auto* builtin = Call("determinant", mat3x2<float>(vec2<float>(1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f)));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for determinant. Requires a square matrix");
-}
-
-TEST_F(ValidatorBuiltinsTest, Determinant_Float_Vec2) {
- auto* builtin = Call("determinant", vec2<float>(1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for determinant. Requires matrix value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Determinant_Float_Scalar) {
- auto* builtin = Call("determinant", 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for determinant. Requires matrix value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Determinant_Integer_Scalar) {
- auto* builtin = Call("determinant", 1);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for determinant. Requires matrix value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Determinant_TooManyParams) {
- auto* builtin =
- Call("determinant",
- mat2x2<float>(vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f)),
- mat2x2<float>(vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f)));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for determinant expected 1 got 2");
-}
-
-TEST_F(ValidatorBuiltinsTest, Determinant_TooFewParams) {
- auto* builtin = Call("determinant");
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for determinant expected 1 got 0");
-}
-
TEST_F(ValidatorBuiltinsTest, Frexp_Scalar) {
auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.i32());
RegisterVariable(a);
@@ -369,75 +211,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Frexp_Integer_FirstParam) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.i32());
- auto* b =
- Const("b", ast::StorageClass::kWorkgroup,
- ty.pointer<int>(ast::StorageClass::kWorkgroup), Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("frexp", 1, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for frexp. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Frexp_Float_SecondParam) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.f32());
- auto* b =
- Const("b", ast::StorageClass::kWorkgroup,
- ty.pointer<float>(ast::StorageClass::kWorkgroup), Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("frexp", 1.0f, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for frexp. Requires int scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Frexp_NotAPointer) {
- auto* builtin = Call("frexp", 1.0f, 1);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for frexp. Requires pointer value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Frexp_Scalar_Vector) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.vec2<int>());
- auto* b = Const("b", ast::StorageClass::kWorkgroup,
- create<type::Pointer>(create<type::Vector>(ty.i32(), 2),
- ast::StorageClass::kWorkgroup),
- Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("frexp", 1.0f, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect types for frexp. Parameters must be matched scalars or "
- "vectors");
-}
-
TEST_F(ValidatorBuiltinsTest, Modf_Scalar) {
auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.f32());
auto* b =
@@ -509,116 +282,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Modf_Integer_FirstParam) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.f32());
- auto* b =
- Const("b", ast::StorageClass::kWorkgroup,
- ty.pointer<float>(ast::StorageClass::kWorkgroup), Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("modf", 1, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for modf. Requires float scalar or vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Modf_Integer_SecondParam) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.i32());
- auto* b =
- Const("b", ast::StorageClass::kWorkgroup,
- ty.pointer<int>(ast::StorageClass::kWorkgroup), Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("modf", 1.0f, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 1's unwrapped type to match result type for modf");
-}
-
-TEST_F(ValidatorBuiltinsTest, Modf_NotAPointer) {
- auto* builtin = Call("modf", 1.0f, 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for modf. Requires pointer value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Modf_Scalar_Vector) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.vec2<float>());
- auto* b = Const("b", ast::StorageClass::kWorkgroup,
- create<type::Pointer>(create<type::Vector>(ty.f32(), 2),
- ast::StorageClass::kWorkgroup),
- Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("modf", 1.0f, Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 1's unwrapped type to match result type for modf");
-}
-
-TEST_F(ValidatorBuiltinsTest, Modf_Vector_Scalar) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.f32());
- auto* b =
- Const("b", ast::StorageClass::kWorkgroup,
- ty.pointer<int>(ast::StorageClass::kWorkgroup), Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("modf", vec2<float>(1.0f, 1.0f), Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 1's unwrapped type to match result type for modf");
-}
-
-TEST_F(ValidatorBuiltinsTest, Modf_Vector_Vector_MismatchedSize) {
- auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.vec2<float>());
- auto* b = Const("b", ast::StorageClass::kWorkgroup,
- create<type::Pointer>(create<type::Vector>(ty.f32(), 2),
- ast::StorageClass::kWorkgroup),
- Expr("a"), {});
- RegisterVariable(a);
- RegisterVariable(b);
- auto* builtin = Call("modf", vec3<float>(1.0f, 1.0f, 1.0f), Expr("b"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
- EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<type::Pointer>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 1's unwrapped type to match result type for modf");
-}
-
TEST_F(ValidatorBuiltinsTest, Cross_Float_Vec3) {
auto* builtin = Call("cross", vec3<float>(1.0f, 1.0f, 1.0f),
vec3<float>(1.0f, 1.0f, 1.0f));
@@ -629,100 +292,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Cross_Integer_Vec3) {
- auto* builtin = Call("cross", vec3<int>(1, 1, 1), vec3<int>(1, 1, 1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 0's unwrapped type to match result type for cross");
-}
-
-TEST_F(ValidatorBuiltinsTest, Cross_Float_Vec4) {
- auto* builtin = Call("cross", vec4<float>(1.0f, 1.0f, 1.0f, 1.0f),
- vec4<float>(1.0f, 1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 0's unwrapped type to match result type for cross");
-}
-
-TEST_F(ValidatorBuiltinsTest, Cross_Float_Vec2) {
- auto* builtin =
- Call("cross", vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 0's unwrapped type to match result type for cross");
-}
-
-TEST_F(ValidatorBuiltinsTest, Cross_Float_Scalar) {
- auto* builtin = Call("cross", 1.0f, 1.0f);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(
- v.error(),
- "expected parameter 0's unwrapped type to match result type for cross");
-}
-
-TEST_F(ValidatorBuiltinsTest, Cross_TooManyParams) {
- auto* builtin =
- Call("cross", vec3<float>(1.0f, 1.0f, 1.0f),
- vec3<float>(1.0f, 1.0f, 1.0f), vec3<float>(1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for cross expected 2 got 3");
-}
-
-TEST_F(ValidatorBuiltinsTest, Cross_TooFewParams) {
- auto* builtin = Call("cross", vec3<float>(1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for cross expected 2 got 1");
-}
-
-TEST_F(ValidatorBuiltinsTest, Dot_Float_Scalar) {
- auto* builtin = Call("dot", Expr(1.0f), Expr(1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for dot. Requires float vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Dot_Integer_Scalar) {
- auto* builtin = Call("dot", Expr(1), Expr(1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for dot. Requires float vector value");
-}
-
TEST_F(ValidatorBuiltinsTest, Dot_Float_Vec2) {
auto* builtin = Call("dot", vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f));
WrapInFunction(builtin);
@@ -752,39 +321,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Dot_Integer_Vector) {
- auto* builtin = Call("dot", vec2<int>(1, 1), vec2<int>(1, 1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for dot. Requires float vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Dot_TooFewParams) {
- auto* builtin = Call("dot", vec2<float>(1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for dot expected 2 got 1");
-}
-
-TEST_F(ValidatorBuiltinsTest, Dot_TooManyParams) {
- auto* builtin = Call("dot", vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for dot expected 2 got 3");
-}
-
TEST_F(ValidatorBuiltinsTest, Select_Float_Scalar) {
auto* builtin = Call("select", Expr(1.0f), Expr(1.0f), Expr(true));
WrapInFunction(builtin);
@@ -842,121 +378,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_F(ValidatorBuiltinsTest, Select_BadSelector) {
- auto* builtin = Call("select", Expr(1), Expr(1), Expr(1));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Selector must be a bool scalar or "
- "vector value");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Matrix) {
- auto* mat = mat2x2<float>(vec2<float>(1.0f, 1.0f), vec2<float>(1.0f, 1.0f));
- auto* builtin = Call("select", mat, mat, Expr(true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Requires bool, int or float scalar or "
- "vector");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatch_Scalar) {
- auto* builtin = Call("select", Expr(1.0f), Expr(1), Expr(true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Value parameter types must match "
- "result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatched_Vector) {
- auto* builtin =
- Call("select", Expr(1.0f), vec2<float>(1.0f, 1.0f), Expr(true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Value parameter types must match "
- "result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatched_VectorSize) {
- auto* builtin = Call("select", vec3<float>(1.0f, 1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f), vec3<bool>(true, true, true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Value parameter types must match "
- "result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatch_Selector_Vector) {
- auto* builtin =
- Call("select", Expr(1.0f), Expr(1.0f), vec2<bool>(true, true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Selector must be a bool scalar to "
- "match scalar result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatch_Selector_Scalar) {
- auto* builtin = Call("select", vec2<float>(1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f), Expr(true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Selector must be a vector with the "
- "same number of elements as the result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, Select_Mismatch_Selector_VectorSize) {
- auto* builtin = Call("select", vec2<float>(1.0f, 1.0f),
- vec2<float>(1.0f, 1.0f), vec3<bool>(true, true, true));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for select. Selector must be a vector with the "
- "same number of elements as the result type");
-}
-
-TEST_F(ValidatorBuiltinsTest, ArrayLength_Sized) {
- auto* var = Var("a", ast::StorageClass::kWorkgroup, ty.array<int, 4>());
- RegisterVariable(var);
- auto* builtin = Call("arrayLength", Expr("a"));
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for arrayLength. Input must be a runtime array");
-}
-
template <typename T>
class ValidatorBuiltinsTestWithParams : public ValidatorTestHelper,
public testing::TestWithParam<T> {};
@@ -1032,123 +453,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_P(FloatAllMatching, Param_TooManyParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params + 1; ++i) {
- params.push_back(Expr(1.0f));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) + " got " +
- std::to_string(num_params + 1));
-}
-
-TEST_P(FloatAllMatching, Param_TooFewParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Expr(1.0f));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- // Most intrinsics require a parameter to determine the type so expect type
- // determination to fail at zero parameters.
- if (num_params > 1) {
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) +
- " got " + std::to_string(num_params - 1));
- } else {
- auto program = std::make_unique<Program>(std::move(*this));
- EXPECT_FALSE(program->IsValid());
- }
-}
-
-TEST_P(FloatAllMatching, Param_Mismatch_Scalar) {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Expr(1.0f));
- }
- // Can't mismatch single parameter types.
- if (num_params > 1) {
- std::string name = std::get<0>(GetParam());
- params.push_back(Expr(1));
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "expected parameter " + std::to_string(num_params - 1) +
- "'s unwrapped type to match result type for " + name);
- }
-}
-
-TEST_P(FloatAllMatching, Param_Mismatch_Vector) {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Expr(1.0f));
- }
- // Can't mismatch single parameter types.
- if (num_params > 1) {
- std::string name = std::get<0>(GetParam());
- params.push_back(vec2<float>(1.0f, 1.0f));
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "expected parameter " + std::to_string(num_params - 1) +
- "'s unwrapped type to match result type for " + name);
- }
-}
-
-TEST_P(FloatAllMatching, Param_Integer) {
- std::string name = std::get<0>(GetParam());
- // abs, clamp, max and min also support integers.
- if (name != "abs" && name != "clamp" && name != "max" && name != "min") {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(Expr(1));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for " + name +
- ". Requires float scalar or vector value");
- }
-}
-
INSTANTIATE_TEST_SUITE_P(ValidatorBuiltinsTest,
FloatAllMatching,
::testing::Values(std::make_tuple("abs", 1),
@@ -1176,7 +480,6 @@
std::make_tuple("fwidthCoarse", 1),
std::make_tuple("fwidthFine", 1),
std::make_tuple("inverseSqrt", 1),
- std::make_tuple("ldexp", 2),
std::make_tuple("log", 1),
std::make_tuple("log2", 1),
std::make_tuple("max", 2),
@@ -1334,147 +637,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_P(IntegerAllMatching, Param_TooManyParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params + 1; ++i) {
- params.push_back(Construct<uint32_t>(1));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) + " got " +
- std::to_string(num_params + 1));
-}
-
-TEST_P(IntegerAllMatching, Param_TooFewParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Construct<uint32_t>(1));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- // Most intrinsics require a parameter to determine the type so expect type
- // determination to fail at zero parameters.
- if (num_params > 1) {
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) +
- " got " + std::to_string(num_params - 1));
- } else {
- auto program = std::make_unique<Program>(std::move(*this));
- EXPECT_FALSE(program->IsValid());
- }
-}
-
-TEST_P(IntegerAllMatching, Param_Mismatch_Scalar) {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Construct<uint32_t>(1));
- }
- // Can't mismatch single parameter types.
- if (num_params > 1) {
- std::string name = std::get<0>(GetParam());
- params.push_back(Expr(1));
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "expected parameter " + std::to_string(num_params - 1) +
- "'s unwrapped type to match result type for " + name);
- }
-}
-
-TEST_P(IntegerAllMatching, Param_Mismatch_Vector) {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Construct<uint32_t>(1));
- }
- // Can't mismatch single parameter types.
- if (num_params > 1) {
- std::string name = std::get<0>(GetParam());
- params.push_back(vec2<uint32_t>(1, 1));
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "expected parameter " + std::to_string(num_params - 1) +
- "'s unwrapped type to match result type for " + name);
- }
-}
-
-TEST_P(IntegerAllMatching, Param_Mismatch_Sign) {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params - 1; ++i) {
- params.push_back(Construct<uint32_t>(1));
- }
- // Can't mismatch single parameter types.
- if (num_params > 1) {
- std::string name = std::get<0>(GetParam());
- params.push_back(Construct<int32_t>(1));
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "expected parameter " + std::to_string(num_params - 1) +
- "'s unwrapped type to match result type for " + name);
- }
-}
-
-TEST_P(IntegerAllMatching, Param_Float) {
- std::string name = std::get<0>(GetParam());
- // abs, clamp, max and min also support integers.
- if (name != "abs" && name != "clamp" && name != "max" && name != "min") {
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(Expr(1.0f));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect type for " + name +
- ". Requires int scalar or vector value");
- }
-}
-
INSTANTIATE_TEST_SUITE_P(ValidatorBuiltinsTest,
IntegerAllMatching,
::testing::Values(std::make_tuple("abs", 1),
@@ -1487,24 +649,6 @@
using BooleanVectorInput =
ValidatorBuiltinsTestWithParams<std::tuple<std::string, uint32_t>>;
-TEST_P(BooleanVectorInput, Scalar) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(Expr(true));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires bool vector value");
-}
-
TEST_P(BooleanVectorInput, Vec2) {
std::string name = std::get<0>(GetParam());
uint32_t num_params = std::get<1>(GetParam());
@@ -1553,76 +697,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_P(BooleanVectorInput, NoParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- auto* builtin = Call(name);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) +
- " got 0");
-}
-
-TEST_P(BooleanVectorInput, TooManyParams) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params + 1; ++i) {
- params.push_back(vec2<bool>(true, true));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(), "incorrect number of parameters for " + name +
- " expected " + std::to_string(num_params) + " got " +
- std::to_string(num_params + 1));
-}
-
-TEST_P(BooleanVectorInput, Integer) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec2<uint32_t>(1, 1));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires bool vector value");
-}
-
-TEST_P(BooleanVectorInput, Float) {
- std::string name = std::get<0>(GetParam());
- uint32_t num_params = std::get<1>(GetParam());
-
- ast::ExpressionList params;
- for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec2<float>(1.0f, 1.0f));
- }
- auto* builtin = Call(name, params);
- WrapInFunction(builtin);
-
- ValidatorImpl& v = Build();
-
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires bool vector value");
-}
-
INSTANTIATE_TEST_SUITE_P(ValidatorBuiltinsTest,
BooleanVectorInput,
::testing::Values(std::make_tuple("all", 1),
@@ -1638,73 +712,12 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_P(DataPacking4x8, Float_Vec2) {
- auto name = GetParam();
- auto* builtin = Call(name, vec2<float>(1.0f, 1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect vector size for " + name + ". Requires 4 elements");
-}
-
-TEST_P(DataPacking4x8, Int_Vec4) {
- auto name = GetParam();
- auto* builtin = Call(name, vec4<int>(1, 1, 1, 1));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires float vector value");
-}
-
-TEST_P(DataPacking4x8, Float_Scalar) {
- auto name = GetParam();
- auto* builtin = Call(name, Expr(1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires float vector value");
-}
-
-TEST_P(DataPacking4x8, TooFewParams) {
- auto name = GetParam();
- auto* builtin = Call(name);
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for " + name + " expected 1 got 0");
-}
-
-TEST_P(DataPacking4x8, TooManyParams) {
- auto name = GetParam();
- auto* builtin = Call(name, vec4<float>(1.0f, 1.0f, 1.0f, 1.0f),
- vec4<float>(1.0f, 1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for " + name + " expected 1 got 2");
-}
-
INSTANTIATE_TEST_SUITE_P(ValidatorBuiltinsTest,
DataPacking4x8,
::testing::Values("pack4x8snorm", "pack4x8unorm"));
using DataPacking2x16 = ValidatorBuiltinsTestWithParams<std::string>;
-TEST_P(DataPacking2x16, Float_Vec4) {
- auto name = GetParam();
- auto* builtin = Call(name, vec4<float>(1.0f, 1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect vector size for " + name + ". Requires 2 elements");
-}
-
TEST_P(DataPacking2x16, Float_Vec2) {
auto name = GetParam();
auto* builtin = Call(name, vec2<float>(1.0f, 1.0f));
@@ -1713,47 +726,6 @@
EXPECT_TRUE(v.ValidateCallExpr(builtin)) << v.error();
}
-TEST_P(DataPacking2x16, Int_Vec4) {
- auto name = GetParam();
- auto* builtin = Call(name, vec4<int>(1, 1, 1, 1));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires float vector value");
-}
-
-TEST_P(DataPacking2x16, Float_Scalar) {
- auto name = GetParam();
- auto* builtin = Call(name, Expr(1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect type for " + name + ". Requires float vector value");
-}
-
-TEST_P(DataPacking2x16, TooFewParams) {
- auto name = GetParam();
- auto* builtin = Call(name);
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for " + name + " expected 1 got 0");
-}
-
-TEST_P(DataPacking2x16, TooManyParams) {
- auto name = GetParam();
- auto* builtin = Call(name, vec4<float>(1.0f, 1.0f, 1.0f, 1.0f),
- vec4<float>(1.0f, 1.0f, 1.0f, 1.0f));
- WrapInFunction(builtin);
- ValidatorImpl& v = Build();
- EXPECT_FALSE(v.ValidateCallExpr(builtin));
- EXPECT_EQ(v.error(),
- "incorrect number of parameters for " + name + " expected 1 got 2");
-}
-
INSTANTIATE_TEST_SUITE_P(ValidatorBuiltinsTest,
DataPacking2x16,
::testing::Values("pack2x16snorm",
