impeller::compiler::testing Namespace Reference

Classes
class	CompilerTest

Functions
static std::string	GetIntermediatesPath ()
static std::string	ReflectionHeaderName (const char *fixture_name)
static std::string	ReflectionCCName (const char *fixture_name)
static std::string	ReflectionJSONName (const char *fixture_name)
static std::string	SPIRVFileName (const char *fixture_name)
static std::string	SLFileName (const char *fixture_name, TargetPlatform platform)
	TEST (CompilerTest, ShaderKindMatchingIsSuccessful)
	TEST_P (CompilerTest, CanCompile)
	TEST_P (CompilerTest, CanCompileHLSL)
	TEST_P (CompilerTest, CanCompileHLSLWithMultipleStages)
	TEST_P (CompilerTest, CanCompileComputeShader)
	TEST_P (CompilerTest, MustFailDueToExceedingResourcesLimit)
	TEST_P (CompilerTest, MustFailDueToMultipleLocationPerStructMember)
	TEST_P (CompilerTest, BindingBaseForFragShader)
	TEST_P (CompilerTest, UniformsHaveBindingAndSet)
	TEST_P (CompilerTest, SkSLTextureLookUpOrderOfOperations)
	TEST_P (CompilerTest, CanCompileStructs)
	INSTANTIATE_TARGET_PLATFORM_TEST_SUITE_P (CompilerSuite)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsForInvalidJSON)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsWhenEntryNotObject)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsWhenMissingFile)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsWhenMissingType)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsForInvalidType)
	TEST (ShaderBundleTest, ParseShaderBundleConfigFailsForInvalidLanguage)
	TEST (ShaderBundleTest, ParseShaderBundleConfigReturnsExpectedConfig)
template<typename T >
const T *	FindByName (const std::vector< std::unique_ptr< T > > &collection, const std::string &name)
	TEST (ShaderBundleTest, GenerateShaderBundleFlatbufferProducesCorrectResult)
Switches	MakeSwitchesDesktopGL (std::initializer_list< const char * > additional_options={})
	TEST (SwitchesTest, DoesntMangleUnicodeIncludes)
	TEST (SwitchesTest, SourceLanguageDefaultsToGLSL)
	TEST (SwitchesTest, SourceLanguageCanBeSetToHLSL)
	TEST (SwitchesTest, DefaultEntryPointIsMain)
	TEST (SwitchesTest, EntryPointCanBeSetForHLSL)
	TEST (SwitchesTEst, ConvertToEntrypointName)
	TEST (SwitchesTest, ShaderBundleModeValid)

Variables
const std::string	kUnlitFragmentBundleConfig
const std::string	kUnlitVertexBundleConfig

Function Documentation

FindByName()

template<typename T >

const T * impeller::compiler::testing::FindByName	(	const std::vector< std::unique_ptr< T > > &	collection,
		const std::string &	name
	)

Definition at line 119 of file shader_bundle_unittests.cc.

                                           {
  const auto maybe = std::find_if(
      collection.begin(), collection.end(),
      [&name](const std::unique_ptr<T>& value) { return value->name == name; });
  if (maybe == collection.end()) {
    return nullptr;
  }
  return maybe->get();
}

GetIntermediatesPath()

static std::string impeller::compiler::testing::GetIntermediatesPath ( )

static

Definition at line 16 of file compiler_test.cc.

                                        {
  auto test_name = flutter::testing::GetCurrentTestName();
  std::replace(test_name.begin(), test_name.end(), '/', '_');
  std::replace(test_name.begin(), test_name.end(), '.', '_');
  std::stringstream dir_name;
  dir_name << test_name << "_" << std::to_string(fml::GetCurrentProcId());
  return fml::paths::JoinPaths(
      {flutter::testing::GetFixturesPath(), dir_name.str()});
}

INSTANTIATE_TARGET_PLATFORM_TEST_SUITE_P()

impeller::compiler::testing::INSTANTIATE_TARGET_PLATFORM_TEST_SUITE_P

(

CompilerSuite

)

MakeSwitchesDesktopGL()

Switches impeller::compiler::testing::MakeSwitchesDesktopGL

(

std::initializer_list< const char * >

additional_options = {}

)

Definition at line 18 of file switches_unittests.cc.

                                                          {}) {
  std::vector<const char*> options = {"--opengl-desktop", "--input=input.vert",
                                      "--sl=output.vert",
                                      "--spirv=output.spirv"};
  options.insert(options.end(), additional_options.begin(),
                 additional_options.end());
 
  auto cl = fml::CommandLineFromIteratorsWithArgv0("impellerc", options.begin(),
                                                   options.end());
  return Switches(cl);
}

ReflectionCCName()

static std::string impeller::compiler::testing::ReflectionCCName ( const char *  fixture_name )

static

Definition at line 46 of file compiler_test.cc.

                                                            {
  std::stringstream stream;
  stream << fixture_name << ".cc";
  return stream.str();
}

ReflectionHeaderName()

static std::string impeller::compiler::testing::ReflectionHeaderName ( const char *  fixture_name )

static

Definition at line 40 of file compiler_test.cc.

                                                                {
  std::stringstream stream;
  stream << fixture_name << ".h";
  return stream.str();
}

ReflectionJSONName()

static std::string impeller::compiler::testing::ReflectionJSONName ( const char *  fixture_name )

static

Definition at line 52 of file compiler_test.cc.

                                                              {
  std::stringstream stream;
  stream << fixture_name << ".json";
  return stream.str();
}

SLFileName()

static std::string impeller::compiler::testing::SLFileName ( const char *  fixture_name, TargetPlatform  platform  )

static

Definition at line 64 of file compiler_test.cc.

                                                       {
  std::stringstream stream;
  stream << fixture_name << "." << TargetPlatformSLExtension(platform);
  return stream.str();
}

SPIRVFileName()

static std::string impeller::compiler::testing::SPIRVFileName ( const char *  fixture_name )

static

Definition at line 58 of file compiler_test.cc.

                                                         {
  std::stringstream stream;
  stream << fixture_name << ".spv";
  return stream.str();
}

TEST() [1/16]

impeller::compiler::testing::TEST	(	CompilerTest	,
		ShaderKindMatchingIsSuccessful
	)

Definition at line 18 of file compiler_unittests.cc.

                                                   {
  ASSERT_EQ(SourceTypeFromFileName("hello.vert"), SourceType::kVertexShader);
  ASSERT_EQ(SourceTypeFromFileName("hello.frag"), SourceType::kFragmentShader);
  ASSERT_EQ(SourceTypeFromFileName("hello.comp"), SourceType::kComputeShader);
  ASSERT_EQ(SourceTypeFromFileName("hello.msl"), SourceType::kUnknown);
  ASSERT_EQ(SourceTypeFromFileName("hello.glsl"), SourceType::kUnknown);
}

TEST() [2/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		GenerateShaderBundleFlatbufferProducesCorrectResult
	)

Verify vertex shader.

Verify fragment shader.

Definition at line 130 of file shader_bundle_unittests.cc.

                                                                            {
  std::string fixtures_path = flutter::testing::GetFixturesPath();
  std::string config =
      "{\"UnlitFragment\": {\"type\": \"fragment\", \"file\": \"" +
      fixtures_path +
      "/flutter_gpu_unlit.frag\"}, \"UnlitVertex\": {\"type\": "
      "\"vertex\", \"file\": \"" +
      fixtures_path + "/flutter_gpu_unlit.vert\"}}";
 
  SourceOptions options;
  options.target_platform = TargetPlatform::kRuntimeStageMetal;
  options.source_language = SourceLanguage::kGLSL;
 
  std::optional<fb::shaderbundle::ShaderBundleT> bundle =
      GenerateShaderBundleFlatbuffer(config, options);
  ASSERT_TRUE(bundle.has_value());
 
  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
  const auto& shaders = bundle->shaders;
  const auto* vertex = FindByName(shaders, "UnlitVertex");
  const auto* fragment = FindByName(shaders, "UnlitFragment");
  ASSERT_NE(vertex, nullptr);
  ASSERT_NE(fragment, nullptr);
 
  // --------------------------------------------------------------------------
  /// Verify vertex shader.
  ///
 
  EXPECT_STREQ(vertex->metal_desktop->entrypoint.c_str(),
               "flutter_gpu_unlit_vertex_main");
  EXPECT_EQ(vertex->metal_desktop->stage,
            fb::shaderbundle::ShaderStage::kVertex);
 
  // Inputs.
  ASSERT_EQ(vertex->metal_desktop->inputs.size(), 1u);
  const auto& v_in_position = vertex->metal_desktop->inputs[0];
  EXPECT_STREQ(v_in_position->name.c_str(), "position");
  EXPECT_EQ(v_in_position->location, 0u);
  EXPECT_EQ(v_in_position->set, 0u);
  EXPECT_EQ(v_in_position->binding, 0u);
  EXPECT_EQ(v_in_position->type, fb::shaderbundle::InputDataType::kFloat);
  EXPECT_EQ(v_in_position->bit_width, 32u);
  EXPECT_EQ(v_in_position->vec_size, 2u);
  EXPECT_EQ(v_in_position->columns, 1u);
  EXPECT_EQ(v_in_position->offset, 0u);
 
  // Uniforms.
  ASSERT_EQ(vertex->metal_desktop->uniform_structs.size(), 1u);
  const auto* vert_info =
      FindByName(vertex->metal_desktop->uniform_structs, "VertInfo");
  ASSERT_NE(vert_info, nullptr);
  EXPECT_EQ(vert_info->ext_res_0, 0u);
  EXPECT_EQ(vert_info->set, 0u);
  EXPECT_EQ(vert_info->binding, 0u);
  ASSERT_EQ(vert_info->fields.size(), 2u);
  const auto& mvp = vert_info->fields[0];
  EXPECT_STREQ(mvp->name.c_str(), "mvp");
  EXPECT_EQ(mvp->type, fb::shaderbundle::UniformDataType::kFloat);
  EXPECT_EQ(mvp->offset_in_bytes, 0u);
  EXPECT_EQ(mvp->element_size_in_bytes, 64u);
  EXPECT_EQ(mvp->total_size_in_bytes, 64u);
  EXPECT_EQ(mvp->array_elements, 0u);
  const auto& color = vert_info->fields[1];
  EXPECT_STREQ(color->name.c_str(), "color");
  EXPECT_EQ(color->type, fb::shaderbundle::UniformDataType::kFloat);
  EXPECT_EQ(color->offset_in_bytes, 64u);
  EXPECT_EQ(color->element_size_in_bytes, 16u);
  EXPECT_EQ(color->total_size_in_bytes, 16u);
  EXPECT_EQ(color->array_elements, 0u);
 
  // --------------------------------------------------------------------------
  /// Verify fragment shader.
  ///
 
  EXPECT_STREQ(fragment->metal_desktop->entrypoint.c_str(),
               "flutter_gpu_unlit_fragment_main");
  EXPECT_EQ(fragment->metal_desktop->stage,
            fb::shaderbundle::ShaderStage::kFragment);
 
  // Inputs (not recorded for fragment shaders).
  ASSERT_EQ(fragment->metal_desktop->inputs.size(), 0u);
 
  // Uniforms.
  ASSERT_EQ(fragment->metal_desktop->inputs.size(), 0u);
}

TEST() [3/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsForInvalidJSON
	)

Definition at line 24 of file shader_bundle_unittests.cc.

                                                                   {
  std::string bundle = "";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(error.str().c_str(),
               "The shader bundle is not a valid JSON object.\n");
}

TEST() [4/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsForInvalidLanguage
	)

Definition at line 76 of file shader_bundle_unittests.cc.

                                                                       {
  std::string bundle =
      "{\"UnlitVertex\": {\"type\": \"vertex\", \"language\": \"invalid\", "
      "\"file\": \"shaders/flutter_gpu_unlit.vert\"}}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(error.str().c_str(),
               "Invalid shader entry \"UnlitVertex\": Unknown language type "
               "\"invalid\".\n");
}

TEST() [5/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsForInvalidType
	)

Definition at line 64 of file shader_bundle_unittests.cc.

                                                                   {
  std::string bundle =
      "{\"UnlitVertex\": {\"type\": \"invalid\", \"file\": "
      "\"shaders/flutter_gpu_unlit.vert\"}}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(error.str().c_str(),
               "Invalid shader entry \"UnlitVertex\": Shader type "
               "\"invalid\" is unknown.\n");
}

TEST() [6/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsWhenEntryNotObject
	)

Definition at line 33 of file shader_bundle_unittests.cc.

                                                                       {
  std::string bundle = "{\"UnlitVertex\": []}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(
      error.str().c_str(),
      "Invalid shader entry \"UnlitVertex\": Entry is not a JSON object.\n");
}

TEST() [7/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsWhenMissingFile
	)

Definition at line 43 of file shader_bundle_unittests.cc.

                                                                    {
  std::string bundle = "{\"UnlitVertex\": {\"type\": \"vertex\"}}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(error.str().c_str(),
               "Invalid shader entry \"UnlitVertex\": Missing required "
               "\"file\" field.\n");
}

TEST() [8/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigFailsWhenMissingType
	)

Definition at line 53 of file shader_bundle_unittests.cc.

                                                                    {
  std::string bundle =
      "{\"UnlitVertex\": {\"file\": \"shaders/flutter_gpu_unlit.vert\"}}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_FALSE(result.has_value());
  ASSERT_STREQ(error.str().c_str(),
               "Invalid shader entry \"UnlitVertex\": Missing required "
               "\"type\" field.\n");
}

TEST() [9/16]

impeller::compiler::testing::TEST	(	ShaderBundleTest	,
		ParseShaderBundleConfigReturnsExpectedConfig
	)

Definition at line 88 of file shader_bundle_unittests.cc.

                                                                     {
  std::string bundle =
      "{" + kUnlitVertexBundleConfig + ", " + kUnlitFragmentBundleConfig + "}";
  std::stringstream error;
  auto result = ParseShaderBundleConfig(bundle, error);
  ASSERT_TRUE(result.has_value());
  ASSERT_STREQ(error.str().c_str(), "");
 
  // NOLINTBEGIN(bugprone-unchecked-optional-access)
  auto maybe_vertex = result->find("UnlitVertex");
  auto maybe_fragment = result->find("UnlitFragment");
  ASSERT_TRUE(maybe_vertex != result->end());
  ASSERT_TRUE(maybe_fragment != result->end());
  auto vertex = maybe_vertex->second;
  auto fragment = maybe_fragment->second;
  // NOLINTEND(bugprone-unchecked-optional-access)
 
  EXPECT_EQ(vertex.type, SourceType::kVertexShader);
  EXPECT_EQ(vertex.language, SourceLanguage::kGLSL);
  EXPECT_STREQ(vertex.entry_point.c_str(), "main");
  EXPECT_STREQ(vertex.source_file_name.c_str(),
               "shaders/flutter_gpu_unlit.vert");
 
  EXPECT_EQ(fragment.type, SourceType::kFragmentShader);
  EXPECT_EQ(fragment.language, SourceLanguage::kGLSL);
  EXPECT_STREQ(fragment.entry_point.c_str(), "main");
  EXPECT_STREQ(fragment.source_file_name.c_str(),
               "shaders/flutter_gpu_unlit.frag");
}

TEST() [10/16]

impeller::compiler::testing::TEST	(	SwitchesTEst	,
		ConvertToEntrypointName
	)

Definition at line 72 of file switches_unittests.cc.

                                            {
  ASSERT_EQ(ConvertToEntrypointName("mandelbrot_unrolled"),
            "mandelbrot_unrolled");
  ASSERT_EQ(ConvertToEntrypointName("mandelbrot-unrolled"),
            "mandelbrotunrolled");
  ASSERT_EQ(ConvertToEntrypointName("7_"), "i_7_");
  ASSERT_EQ(ConvertToEntrypointName("415"), "i_415");
  ASSERT_EQ(ConvertToEntrypointName("#$%"), "i_");
  ASSERT_EQ(ConvertToEntrypointName(""), "");
}

TEST() [11/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		DefaultEntryPointIsMain
	)

Definition at line 60 of file switches_unittests.cc.

                                            {
  Switches switches = MakeSwitchesDesktopGL({});
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.entry_point, "main");
}

TEST() [12/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		DoesntMangleUnicodeIncludes
	)

Definition at line 31 of file switches_unittests.cc.

                                                {
  const char* directory_name = "test_shader_include_�";
  fml::CreateDirectory(flutter::testing::OpenFixturesDirectory(),
                       {directory_name}, fml::FilePermission::kRead);
 
  auto include_path =
      std::string(flutter::testing::GetFixturesPath()) + "/" + directory_name;
  auto include_option = "--include=" + include_path;
 
  Switches switches = MakeSwitchesDesktopGL({include_option.c_str()});
 
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.include_directories.size(), 1u);
  ASSERT_NE(switches.include_directories[0].dir, nullptr);
  ASSERT_EQ(switches.include_directories[0].name, include_path);
}

TEST() [13/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		EntryPointCanBeSetForHLSL
	)

Definition at line 66 of file switches_unittests.cc.

                                              {
  Switches switches = MakeSwitchesDesktopGL({"--entry-point=CustomEntryPoint"});
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.entry_point, "CustomEntryPoint");
}

TEST() [14/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		ShaderBundleModeValid
	)

Definition at line 83 of file switches_unittests.cc.

                                          {
  // Shader bundles process multiple shaders, and so the single-file input/spirv
  // flags are not required.
  std::vector<const char*> options = {
      "--shader-bundle={}", "--sl=test.shaderbundle", "--runtime-stage-metal"};
 
  auto cl = fml::CommandLineFromIteratorsWithArgv0("impellerc", options.begin(),
                                                   options.end());
  Switches switches(cl);
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.shader_bundle, "{}");
}

TEST() [15/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		SourceLanguageCanBeSetToHLSL
	)

Definition at line 54 of file switches_unittests.cc.

                                                 {
  Switches switches = MakeSwitchesDesktopGL({"--source-language=hLsL"});
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.source_language, SourceLanguage::kHLSL);
}

TEST() [16/16]

impeller::compiler::testing::TEST	(	SwitchesTest	,
		SourceLanguageDefaultsToGLSL
	)

Definition at line 48 of file switches_unittests.cc.

                                                 {
  Switches switches = MakeSwitchesDesktopGL();
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.source_language, SourceLanguage::kGLSL);
}

TEST_P() [1/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		BindingBaseForFragShader
	)

Definition at line 81 of file compiler_unittests.cc.

                                               {
  if (!TargetPlatformIsVulkan(GetParam())) {
    GTEST_SKIP();
  }
 
  ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader));
  ASSERT_TRUE(CanCompileAndReflect("sample.frag", SourceType::kFragmentShader));
 
  auto get_binding = [&](const char* fixture) -> uint32_t {
    auto json_fd = GetReflectionJson(fixture);
    nlohmann::json shader_json = nlohmann::json::parse(json_fd->GetMapping());
    return shader_json["buffers"][0]["binding"].get<uint32_t>();
  };
 
  auto vert_uniform_binding = get_binding("sample.vert");
  auto frag_uniform_binding = get_binding("sample.frag");
 
  ASSERT_GT(frag_uniform_binding, vert_uniform_binding);
}

TEST_P() [2/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		CanCompile
	)

Definition at line 26 of file compiler_unittests.cc.

                                 {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ASSERT_TRUE(CanCompileAndReflect("sample.vert"));
  ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader));
  ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader,
                                   SourceLanguage::kGLSL));
}

TEST_P() [3/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		CanCompileComputeShader
	)

Definition at line 56 of file compiler_unittests.cc.

                                              {
  if (!TargetPlatformIsMetal(GetParam())) {
    GTEST_SKIP_("Only enabled on Metal backends till ES 3.2 support is added.");
  }
  ASSERT_TRUE(CanCompileAndReflect("sample.comp"));
  ASSERT_TRUE(CanCompileAndReflect("sample.comp", SourceType::kComputeShader));
}

TEST_P() [4/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		CanCompileHLSL
	)

Definition at line 36 of file compiler_unittests.cc.

                                     {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ASSERT_TRUE(CanCompileAndReflect(
      "simple.vert.hlsl", SourceType::kVertexShader, SourceLanguage::kHLSL));
}

TEST_P() [5/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		CanCompileHLSLWithMultipleStages
	)

Definition at line 44 of file compiler_unittests.cc.

                                                       {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ASSERT_TRUE(CanCompileAndReflect("multiple_stages.hlsl",
                                   SourceType::kVertexShader,
                                   SourceLanguage::kHLSL, "VertexShader"));
  ASSERT_TRUE(CanCompileAndReflect("multiple_stages.hlsl",
                                   SourceType::kFragmentShader,
                                   SourceLanguage::kHLSL, "FragmentShader"));
}

TEST_P() [6/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		CanCompileStructs
	)

Definition at line 147 of file compiler_unittests.cc.

                                        {
  if (GetParam() != TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Only supported on SkSL";
  }
  ASSERT_TRUE(CanCompileAndReflect("struct_internal.frag",
                                   SourceType::kFragmentShader));
}

TEST_P() [7/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		MustFailDueToExceedingResourcesLimit
	)

Definition at line 64 of file compiler_unittests.cc.

                                                           {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ScopedValidationDisable disable_validation;
  ASSERT_FALSE(
      CanCompileAndReflect("resources_limit.vert", SourceType::kVertexShader));
}

TEST_P() [8/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		MustFailDueToMultipleLocationPerStructMember
	)

Definition at line 73 of file compiler_unittests.cc.

                                                                   {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ScopedValidationDisable disable_validation;
  ASSERT_FALSE(CanCompileAndReflect("struct_def_bug.vert"));
}

TEST_P() [9/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		SkSLTextureLookUpOrderOfOperations
	)

Definition at line 130 of file compiler_unittests.cc.

                                                         {
  if (GetParam() != TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Only supported on SkSL";
  }
  ASSERT_TRUE(
      CanCompileAndReflect("texture_lookup.frag", SourceType::kFragmentShader));
 
  auto shader = GetShaderFile("texture_lookup.frag", GetParam());
  std::string_view shader_mapping(
      reinterpret_cast<const char*>(shader->GetMapping()), shader->GetSize());
 
  constexpr std::string_view expected =
      "textureA.eval(textureA_size * ( vec2(1.0) + flutter_FragCoord.xy));";
 
  EXPECT_NE(shader_mapping.find(expected), std::string::npos);
}

TEST_P() [10/10]

impeller::compiler::testing::TEST_P	(	CompilerTest	,
		UniformsHaveBindingAndSet
	)

Definition at line 101 of file compiler_unittests.cc.

                                                {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
  ASSERT_TRUE(CanCompileAndReflect("sample_with_binding.vert",
                                   SourceType::kVertexShader));
  ASSERT_TRUE(CanCompileAndReflect("sample.frag", SourceType::kFragmentShader));
 
  struct binding_and_set {
    uint32_t binding;
    uint32_t set;
  };
 
  auto get_binding = [&](const char* fixture) -> binding_and_set {
    auto json_fd = GetReflectionJson(fixture);
    nlohmann::json shader_json = nlohmann::json::parse(json_fd->GetMapping());
    uint32_t binding = shader_json["buffers"][0]["binding"].get<uint32_t>();
    uint32_t set = shader_json["buffers"][0]["set"].get<uint32_t>();
    return {binding, set};
  };
 
  auto vert_uniform_binding = get_binding("sample_with_binding.vert");
  auto frag_uniform_binding = get_binding("sample.frag");
 
  ASSERT_EQ(frag_uniform_binding.set, 0u);
  ASSERT_EQ(vert_uniform_binding.set, 3u);
  ASSERT_EQ(vert_uniform_binding.binding, 17u);
}

Variable Documentation

kUnlitFragmentBundleConfig

const std::string impeller::compiler::testing::kUnlitFragmentBundleConfig

Initial value:

=
    "\"UnlitFragment\": {\"type\": \"fragment\", \"file\": "
    "\"shaders/flutter_gpu_unlit.frag\"}"

Definition at line 17 of file shader_bundle_unittests.cc.

kUnlitVertexBundleConfig

const std::string impeller::compiler::testing::kUnlitVertexBundleConfig

Initial value:

=
    "\"UnlitVertex\": {\"type\": \"vertex\", \"file\": "
    "\"shaders/flutter_gpu_unlit.vert\"}"

Definition at line 20 of file shader_bundle_unittests.cc.