// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/ast/call_statement.h"
#include "src/resolver/resolver_test_helper.h"

namespace tint {
namespace {
class ResolverBuiltinsValidationTest : public resolver::TestHelper,
                                       public testing::Test {};

TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_Struct_Fail) {
  // struct MyInputs {
  //   [[builtin(kPosition)]] p: vec4<u32>;
  // };
  // [[stage(fragment)]]
  // fn fragShader(is_front: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* m = Member(
      "position", ty.vec4<u32>(),
      ast::DecorationList{Builtin(Source{{12, 34}}, ast::Builtin::kPosition)});
  auto* s = Structure("MyInputs", {m});
  Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
}

TEST_F(ResolverBuiltinsValidationTest, FragDepthNotF32_Struct_Fail) {
  // struct MyInputs {
  //   [[builtin(kFragDepth)]] p: i32;
  // };
  // [[stage(fragment)]]
  // fn fragShader(is_front: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* m = Member(
      "frag_depth", ty.i32(),
      ast::DecorationList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
  auto* s = Structure("MyInputs", {m});
  Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(frag_depth) must be 'f32'");
}

TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_Struct_Fail) {
  // struct MyInputs {
  //   [[builtin(sample_mask)]] m: f32;
  // };
  // [[stage(fragment)]]
  // fn fragShader(is_front: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* s = Structure(
      "MyInputs", {Member("m", ty.f32(),
                          ast::DecorationList{Builtin(
                              Source{{12, 34}}, ast::Builtin::kSampleMask)})});
  Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(sample_mask) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, SampleMaskIsNotU32_Fail) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(sample_mask)]] arg: bool
  // ) -> [[location(0)]] f32 { return 1.0; }
  auto* arg = Param("arg", ty.bool_(),
                    ast::DecorationList{
                        Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)});
  Func("fs_main", ast::VariableList{arg}, ty.f32(), {Return(1.0f)},
       ast::DecorationList{Stage(ast::PipelineStage::kFragment)},
       {Location(0)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(sample_mask) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Struct_Fail) {
  // struct MyInputs {
  //   [[builtin(sample_index)]] m: f32;
  // };
  // [[stage(fragment)]]
  // fn fragShader(is_front: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* s = Structure(
      "MyInputs", {Member("m", ty.f32(),
                          ast::DecorationList{Builtin(
                              Source{{12, 34}}, ast::Builtin::kSampleIndex)})});
  Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(sample_index) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Fail) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(sample_index)]] arg: bool
  // ) -> [[location(0)]] f32 { return 1.0; }
  auto* arg = Param("arg", ty.bool_(),
                    ast::DecorationList{
                        Builtin(Source{{12, 34}}, ast::Builtin::kSampleIndex)});
  Func("fs_main", ast::VariableList{arg}, ty.f32(), {Return(1.0f)},
       ast::DecorationList{Stage(ast::PipelineStage::kFragment)},
       {Location(0)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(sample_index) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, PositionIsNotF32_Fail) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(kPosition)]] p: vec3<f32>,
  // ) -> [[location(0)]] f32 { return 1.0; }
  auto* p = Param(
      "p", ty.vec3<f32>(),
      ast::DecorationList{Builtin(Source{{12, 34}}, ast::Builtin::kPosition)});
  Func("fs_main", ast::VariableList{p}, ty.f32(), {Return(1.0f)},
       ast::DecorationList{Stage(ast::PipelineStage::kFragment)},
       {Location(0)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
}

TEST_F(ResolverBuiltinsValidationTest, FragDepthIsNotF32_Fail) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(kFragDepth)]] fd: f32,
  // ) -> [[location(0)]] f32 { return 1.0; }
  auto* fd = Param(
      "fd", ty.i32(),
      ast::DecorationList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
  Func("fs_main", ast::VariableList{fd}, ty.f32(), {Return(1.0f)},
       ast::DecorationList{Stage(ast::PipelineStage::kFragment)},
       {Location(0)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(frag_depth) must be 'f32'");
}

TEST_F(ResolverBuiltinsValidationTest, VertexIndexIsNotU32_Fail) {
  // [[stage(vertex)]]
  // fn main(
  //   [[builtin(kVertexIndex)]] vi : f32,
  //   [[builtin(kPosition)]] p :vec4<f32>
  // ) -> [[builtin(kPosition)]] vec4<f32> { return vec4<f32>(); }
  auto* p = Param("p", ty.vec4<f32>(),
                  ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  auto* vi = Param("vi", ty.f32(),
                   ast::DecorationList{
                       Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
  Func("main", ast::VariableList{vi, p}, ty.vec4<f32>(), {Return(Expr("p"))},
       ast::DecorationList{Stage(ast::PipelineStage::kVertex)},
       ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(vertex_index) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, InstanceIndexIsNotU32) {
  // [[stage(vertex)]]
  // fn main(
  //   [[builtin(kInstanceIndex)]] ii : f32,
  //   [[builtin(kPosition)]] p :vec4<f32>
  // ) -> [[builtin(kPosition)]] vec4<f32> { return vec4<f32>(); }
  auto* p = Param("p", ty.vec4<f32>(),
                  ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  auto* ii = Param("ii", ty.f32(),
                   ast::DecorationList{Builtin(Source{{12, 34}},
                                               ast::Builtin::kInstanceIndex)});
  Func("main", ast::VariableList{ii, p}, ty.vec4<f32>(), {Return(Expr("p"))},
       ast::DecorationList{Stage(ast::PipelineStage::kVertex)},
       ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(instance_index) must be 'u32'");
}

TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(kPosition)]] p: vec4<f32>,
  //   [[builtin(front_facing)]] ff: bool,
  //   [[builtin(frag_depth)]] fd: f32,
  //   [[builtin(sample_index)]] si: u32,
  //   [[builtin(sample_mask)]] sm : u32
  // ) -> [[location(0)]] f32 { return 1.0; }
  auto* p = Param("p", ty.vec4<f32>(),
                  ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  auto* ff = Param("ff", ty.bool_(),
                   ast::DecorationList{Builtin(ast::Builtin::kFrontFacing)});
  auto* fd = Param("fd", ty.f32(),
                   ast::DecorationList{Builtin(ast::Builtin::kFragDepth)});
  auto* si = Param("si", ty.u32(),
                   ast::DecorationList{Builtin(ast::Builtin::kSampleIndex)});
  auto* sm = Param("sm", ty.u32(),
                   ast::DecorationList{Builtin(ast::Builtin::kSampleMask)});
  Func(
      "fs_main", ast::VariableList{p, ff, fd, si, sm}, ty.f32(), {Return(1.0f)},
      ast::DecorationList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, VertexBuiltin_Pass) {
  // [[stage(vertex)]]
  // fn main(
  //   [[builtin(kVertexIndex)]] vi : u32,
  //   [[builtin(kInstanceIndex)]] ii : u32,
  //   [[builtin(kPosition)]] p :vec4<f32>
  // ) {}
  auto* vi = Param("vi", ty.u32(),
                   ast::DecorationList{
                       Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
  auto* p = Param("p", ty.vec4<f32>(),
                  ast::DecorationList{Builtin(ast::Builtin::kPosition)});
  auto* ii = Param("ii", ty.u32(),
                   ast::DecorationList{Builtin(Source{{12, 34}},
                                               ast::Builtin::kInstanceIndex)});
  Func("main", ast::VariableList{vi, ii, p}, ty.vec4<f32>(),
       {
           Return(Expr(p)),
       },
       ast::DecorationList{Stage(ast::PipelineStage::kVertex)},
       ast::DecorationList{Builtin(ast::Builtin::kPosition)});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_Pass) {
  // [[stage(compute)]]
  // fn main(
  //   [[builtin(local_invocationId)]] li_id: vec3<u32>,
  //   [[builtin(local_invocationIndex)]] li_index: u32,
  //   [[builtin(global_invocationId)]] gi: vec3<u32>,
  //   [[builtin(workgroup_id)]] wi: vec3<u32>,
  // ) {}

  auto* li_id =
      Param("li_id", ty.vec3<u32>(),
            ast::DecorationList{Builtin(ast::Builtin::kLocalInvocationId)});
  auto* li_index =
      Param("li_index", ty.u32(),
            ast::DecorationList{Builtin(ast::Builtin::kLocalInvocationIndex)});
  auto* gi =
      Param("gi", ty.vec3<u32>(),
            ast::DecorationList{Builtin(ast::Builtin::kGlobalInvocationId)});
  auto* wi = Param("wi", ty.vec3<u32>(),
                   ast::DecorationList{Builtin(ast::Builtin::kWorkgroupId)});

  Func("main", ast::VariableList{li_id, li_index, gi, wi}, ty.void_(), {},
       ast::DecorationList{
           Stage(ast::PipelineStage::kCompute),
           WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) {
  auto* wi = Param("wi", ty.f32(),
                   ast::DecorationList{
                       Builtin(Source{{12, 34}}, ast::Builtin::kWorkgroupId)});
  Func("main", ast::VariableList{wi}, ty.void_(), {},
       ast::DecorationList{
           Stage(ast::PipelineStage::kCompute),
           WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(workgroup_id) must be "
            "'vec3<u32>'");
}

TEST_F(ResolverBuiltinsValidationTest,
       ComputeBuiltin_GlobalInvocationNotVec3U32) {
  auto* gi = Param("gi", ty.vec3<i32>(),
                   ast::DecorationList{Builtin(
                       Source{{12, 34}}, ast::Builtin::kGlobalInvocationId)});
  Func("main", ast::VariableList{gi}, ty.void_(), {},
       ast::DecorationList{
           Stage(ast::PipelineStage::kCompute),
           WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(global_invocation_id) must be "
            "'vec3<u32>'");
}

TEST_F(ResolverBuiltinsValidationTest,
       ComputeBuiltin_LocalInvocationIndexNotU32) {
  auto* li_index =
      Param("li_index", ty.vec3<u32>(),
            ast::DecorationList{Builtin(Source{{12, 34}},
                                        ast::Builtin::kLocalInvocationIndex)});
  Func("main", ast::VariableList{li_index}, ty.void_(), {},
       ast::DecorationList{
           Stage(ast::PipelineStage::kCompute),
           WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(
      r()->error(),
      "12:34 error: store type of builtin(local_invocation_index) must be "
      "'u32'");
}

TEST_F(ResolverBuiltinsValidationTest,
       ComputeBuiltin_LocalInvocationNotVec3U32) {
  auto* li_id = Param("li_id", ty.vec2<u32>(),
                      ast::DecorationList{Builtin(
                          Source{{12, 34}}, ast::Builtin::kLocalInvocationId)});
  Func("main", ast::VariableList{li_id}, ty.void_(), {},
       ast::DecorationList{
           Stage(ast::PipelineStage::kCompute),
           WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(local_invocation_id) must be "
            "'vec3<u32>'");
}

TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltinStruct_Pass) {
  // Struct MyInputs {
  //   [[builtin(kPosition)]] p: vec4<f32>;
  //   [[builtin(front_facing)]] ff: bool;
  //   [[builtin(frag_depth)]] fd: f32;
  //   [[builtin(sample_index)]] si: u32;
  //   [[builtin(sample_mask)]] sm : u32;;
  // };
  // [[stage(fragment)]]
  // fn fragShader(arg: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* s = Structure(
      "MyInputs",
      {Member("position", ty.vec4<f32>(),
              ast::DecorationList{Builtin(ast::Builtin::kPosition)}),
       Member("front_facing", ty.bool_(),
              ast::DecorationList{Builtin(ast::Builtin::kFrontFacing)}),
       Member("frag_depth", ty.f32(),
              ast::DecorationList{Builtin(ast::Builtin::kFragDepth)}),
       Member("sample_index", ty.u32(),
              ast::DecorationList{Builtin(ast::Builtin::kSampleIndex)}),
       Member("sample_mask", ty.u32(),
              ast::DecorationList{Builtin(ast::Builtin::kSampleMask)})});
  Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, FrontFacingParamIsNotBool_Fail) {
  // [[stage(fragment)]]
  // fn fs_main(
  //   [[builtin(front_facing)]] is_front: i32;
  // ) -> [[location(0)]] f32 { return 1.0; }

  auto* is_front = Param("is_front", ty.i32(),
                         ast::DecorationList{Builtin(
                             Source{{12, 34}}, ast::Builtin::kFrontFacing)});
  Func("fs_main", ast::VariableList{is_front}, ty.f32(), {Return(1.0f)},
       ast::DecorationList{Stage(ast::PipelineStage::kFragment)},
       {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(front_facing) must be 'bool'");
}

TEST_F(ResolverBuiltinsValidationTest, FrontFacingMemberIsNotBool_Fail) {
  // struct MyInputs {
  //   [[builtin(front_facing)]] pos: f32;
  // };
  // [[stage(fragment)]]
  // fn fragShader(is_front: MyInputs) -> [[location(0)]] f32 { return 1.0; }

  auto* s = Structure(
      "MyInputs", {Member("pos", ty.f32(),
                          ast::DecorationList{Builtin(
                              Source{{12, 34}}, ast::Builtin::kFrontFacing)})});
  Func("fragShader", {Param("is_front", ty.Of(s))}, ty.f32(), {Return(1.0f)},
       {Stage(ast::PipelineStage::kFragment)}, {Location(0)});

  EXPECT_FALSE(r()->Resolve());
  EXPECT_EQ(r()->error(),
            "12:34 error: store type of builtin(front_facing) must be 'bool'");
}

TEST_F(ResolverBuiltinsValidationTest, Length_Float_Scalar) {
  auto* builtin = Call("length", 1.0f);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec2) {
  auto* builtin = Call("length", vec2<f32>(1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec3) {
  auto* builtin = Call("length", vec3<f32>(1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec4) {
  auto* builtin = Call("length", vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Scalar) {
  auto* builtin = Call("distance", 1.0f, 1.0f);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec2) {
  auto* builtin =
      Call("distance", vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec3) {
  auto* builtin = Call("distance", vec3<f32>(1.0f, 1.0f, 1.0f),
                       vec3<f32>(1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec4) {
  auto* builtin = Call("distance", vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f),
                       vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat2x2) {
  auto* builtin = Call(
      "determinant", mat2x2<f32>(vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f)));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat3x3) {
  auto* builtin = Call("determinant", mat3x3<f32>(vec3<f32>(1.0f, 1.0f, 1.0f),
                                                  vec3<f32>(1.0f, 1.0f, 1.0f),
                                                  vec3<f32>(1.0f, 1.0f, 1.0f)));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat4x4) {
  auto* builtin =
      Call("determinant", mat4x4<f32>(vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f),
                                      vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f),
                                      vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f),
                                      vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f)));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Frexp_Scalar) {
  auto* a = Var("a", ty.i32());
  auto* builtin = Call("frexp", 1.0f, AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->Is<sem::F32>());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec2) {
  auto* a = Var("a", ty.vec2<int>());
  auto* builtin = Call("frexp", vec2<f32>(1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec3) {
  auto* a = Var("a", ty.vec3<int>());
  auto* builtin =
      Call("frexp", vec3<f32>(1.0f, 1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec4) {
  auto* a = Var("a", ty.vec4<int>());
  auto* builtin =
      Call("frexp", vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Modf_Scalar) {
  auto* a = Var("a", ty.f32());
  auto* builtin = Call("modf", 1.0f, AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->Is<sem::F32>());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Modf_Vec2) {
  auto* a = Var("a", ty.vec2<f32>());
  auto* builtin = Call("modf", vec2<f32>(1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Modf_Vec3) {
  auto* a = Var("a", ty.vec3<f32>());
  auto* builtin =
      Call("modf", vec3<f32>(1.0f, 1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Modf_Vec4) {
  auto* a = Var("a", ty.vec4<f32>());
  auto* builtin =
      Call("modf", vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f), AddressOf(Expr("a")));
  WrapInFunction(Decl(a), builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
  EXPECT_TRUE(TypeOf(builtin->params()[1])->Is<sem::Pointer>());
}

TEST_F(ResolverBuiltinsValidationTest, Cross_Float_Vec3) {
  auto* builtin =
      Call("cross", vec3<f32>(1.0f, 1.0f, 1.0f), vec3<f32>(1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec2) {
  auto* builtin = Call("dot", vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec3) {
  auto* builtin =
      Call("dot", vec3<f32>(1.0f, 1.0f, 1.0f), vec3<f32>(1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec4) {
  auto* builtin = Call("dot", vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f),
                       vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Float_Scalar) {
  auto* builtin = Call("select", Expr(1.0f), Expr(1.0f), Expr(true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Scalar) {
  auto* builtin = Call("select", Expr(1), Expr(1), Expr(true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Boolean_Scalar) {
  auto* builtin = Call("select", Expr(true), Expr(true), Expr(true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Float_Vec2) {
  auto* builtin = Call("select", vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f),
                       vec2<bool>(true, true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Vec2) {
  auto* builtin =
      Call("select", vec2<int>(1, 1), vec2<int>(1, 1), vec2<bool>(true, true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_F(ResolverBuiltinsValidationTest, Select_Boolean_Vec2) {
  auto* builtin = Call("select", vec2<bool>(true, true), vec2<bool>(true, true),
                       vec2<bool>(true, true));
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

template <typename T>
class ResolverBuiltinsValidationTestWithParams
    : public resolver::TestHelper,
      public testing::TestWithParam<T> {};

using FloatAllMatching =
    ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>;

TEST_P(FloatAllMatching, 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(1.0f));
  }
  auto* builtin = Call(name, params);
  Func("func", {}, ty.void_(), {Ignore(builtin)},
       {create<ast::StageDecoration>(ast::PipelineStage::kFragment)});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->Is<sem::F32>());
}

TEST_P(FloatAllMatching, Vec2) {
  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<f32>(1.0f, 1.0f));
  }
  auto* builtin = Call(name, params);
  Func("func", {}, ty.void_(), {Ignore(builtin)},
       {create<ast::StageDecoration>(ast::PipelineStage::kFragment)});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
}

TEST_P(FloatAllMatching, Vec3) {
  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(vec3<f32>(1.0f, 1.0f, 1.0f));
  }
  auto* builtin = Call(name, params);
  Func("func", {}, ty.void_(), {Ignore(builtin)},
       {create<ast::StageDecoration>(ast::PipelineStage::kFragment)});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
}

TEST_P(FloatAllMatching, Vec4) {
  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(vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f));
  }
  auto* builtin = Call(name, params);
  Func("func", {}, ty.void_(), {Ignore(builtin)},
       {create<ast::StageDecoration>(ast::PipelineStage::kFragment)});

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_float_vector());
}

INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
                         FloatAllMatching,
                         ::testing::Values(std::make_tuple("abs", 1),
                                           std::make_tuple("acos", 1),
                                           std::make_tuple("asin", 1),
                                           std::make_tuple("atan", 1),
                                           std::make_tuple("atan2", 2),
                                           std::make_tuple("ceil", 1),
                                           std::make_tuple("clamp", 3),
                                           std::make_tuple("cos", 1),
                                           std::make_tuple("cosh", 1),
                                           std::make_tuple("dpdx", 1),
                                           std::make_tuple("dpdxCoarse", 1),
                                           std::make_tuple("dpdxFine", 1),
                                           std::make_tuple("dpdy", 1),
                                           std::make_tuple("dpdyCoarse", 1),
                                           std::make_tuple("dpdyFine", 1),
                                           std::make_tuple("exp", 1),
                                           std::make_tuple("exp2", 1),
                                           std::make_tuple("faceForward", 3),
                                           std::make_tuple("floor", 1),
                                           std::make_tuple("fma", 3),
                                           std::make_tuple("fract", 1),
                                           std::make_tuple("fwidth", 1),
                                           std::make_tuple("fwidthCoarse", 1),
                                           std::make_tuple("fwidthFine", 1),
                                           std::make_tuple("inverseSqrt", 1),
                                           std::make_tuple("log", 1),
                                           std::make_tuple("log2", 1),
                                           std::make_tuple("max", 2),
                                           std::make_tuple("min", 2),
                                           std::make_tuple("mix", 3),
                                           std::make_tuple("pow", 2),
                                           std::make_tuple("reflect", 2),
                                           std::make_tuple("round", 1),
                                           std::make_tuple("sign", 1),
                                           std::make_tuple("sin", 1),
                                           std::make_tuple("sinh", 1),
                                           std::make_tuple("smoothStep", 3),
                                           std::make_tuple("sqrt", 1),
                                           std::make_tuple("step", 2),
                                           std::make_tuple("tan", 1),
                                           std::make_tuple("tanh", 1),
                                           std::make_tuple("trunc", 1)));

using IntegerAllMatching =
    ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>;

TEST_P(IntegerAllMatching, ScalarUnsigned) {
  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(Construct<uint32_t>(1));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->Is<sem::U32>());
}

TEST_P(IntegerAllMatching, Vec2Unsigned) {
  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>(1u, 1u));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_unsigned_integer_vector());
}

TEST_P(IntegerAllMatching, Vec3Unsigned) {
  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(vec3<uint32_t>(1u, 1u, 1u));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_unsigned_integer_vector());
}

TEST_P(IntegerAllMatching, Vec4Unsigned) {
  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(vec4<uint32_t>(1u, 1u, 1u, 1u));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_unsigned_integer_vector());
}

TEST_P(IntegerAllMatching, ScalarSigned) {
  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(Construct<int32_t>(1));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->Is<sem::I32>());
}

TEST_P(IntegerAllMatching, Vec2Signed) {
  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<int32_t>(1, 1));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_signed_integer_vector());
}

TEST_P(IntegerAllMatching, Vec3Signed) {
  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(vec3<int32_t>(1, 1, 1));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_signed_integer_vector());
}

TEST_P(IntegerAllMatching, Vec4Signed) {
  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(vec4<int32_t>(1, 1, 1, 1));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
  EXPECT_TRUE(TypeOf(builtin)->is_signed_integer_vector());
}

INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
                         IntegerAllMatching,
                         ::testing::Values(std::make_tuple("abs", 1),
                                           std::make_tuple("clamp", 3),
                                           std::make_tuple("countOneBits", 1),
                                           std::make_tuple("max", 2),
                                           std::make_tuple("min", 2),
                                           std::make_tuple("reverseBits", 1)));

using BooleanVectorInput =
    ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>;

TEST_P(BooleanVectorInput, Vec2) {
  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<bool>(true, true));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_P(BooleanVectorInput, Vec3) {
  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(vec3<bool>(true, true, true));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

TEST_P(BooleanVectorInput, Vec4) {
  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(vec4<bool>(true, true, true, true));
  }
  auto* builtin = Call(name, params);
  WrapInFunction(builtin);

  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
                         BooleanVectorInput,
                         ::testing::Values(std::make_tuple("all", 1),
                                           std::make_tuple("any", 1)));

using DataPacking4x8 = ResolverBuiltinsValidationTestWithParams<std::string>;

TEST_P(DataPacking4x8, Float_Vec4) {
  auto name = GetParam();
  auto* builtin = Call(name, vec4<f32>(1.0f, 1.0f, 1.0f, 1.0f));
  WrapInFunction(builtin);
  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
                         DataPacking4x8,
                         ::testing::Values("pack4x8snorm", "pack4x8unorm"));

using DataPacking2x16 = ResolverBuiltinsValidationTestWithParams<std::string>;

TEST_P(DataPacking2x16, Float_Vec2) {
  auto name = GetParam();
  auto* builtin = Call(name, vec2<f32>(1.0f, 1.0f));
  WrapInFunction(builtin);
  EXPECT_TRUE(r()->Resolve()) << r()->error();
}

INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
                         DataPacking2x16,
                         ::testing::Values("pack2x16snorm",
                                           "pack2x16unorm",
                                           "pack2x16float"));

}  // namespace
}  // namespace tint