impeller::compiler::testing Namespace Reference

Classes
class	CompilerTest
class	CompilerTestBase
class	CompilerTestRuntime
class	CompilerTestSkSL
class	CompilerTestUnknownPlatform

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)
	INSTANTIATE_TEST_SUITE_P (CompilerSuite, CompilerTest, ::testing::Values(TargetPlatform::kOpenGLES, TargetPlatform::kOpenGLDesktop, TargetPlatform::kMetalDesktop, TargetPlatform::kMetalIOS, TargetPlatform::kVulkan), [](const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);})
	INSTANTIATE_TEST_SUITE_P (CompilerSuite, CompilerTestRuntime, ::testing::Values(TargetPlatform::kRuntimeStageMetal, TargetPlatform::kRuntimeStageGLES, TargetPlatform::kRuntimeStageGLES3, TargetPlatform::kRuntimeStageVulkan, TargetPlatform::kSkSL), [](const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);})
	INSTANTIATE_TEST_SUITE_P (CompilerSuite, CompilerTestSkSL, ::testing::Values(TargetPlatform::kSkSL), [](const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);})
	INSTANTIATE_TEST_SUITE_P (CompilerSuite, CompilerTestUnknownPlatform, ::testing::Values(TargetPlatform::kUnknown), [](const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);})
	TEST (CompilerTest, Defines)
	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, UniformBlockInstanceNameCanonicalizedForGL)
	TEST_P (CompilerTest, BindingBaseForFragShader)
	TEST_P (CompilerTestRuntime, UniformsAppearInJson)
	TEST_P (CompilerTestRuntime, PositionedUniformsAppearInJson)
	TEST_P (CompilerTest, UniformsHaveBindingAndSet)
	TEST_P (CompilerTestSkSL, SkSLTextureLookUpOrderOfOperations)
	TEST_P (CompilerTestSkSL, CanCompileStructs)
	TEST_P (CompilerTestSkSL, FailsToCompileDueToArrayInitializerWithConstants)
	TEST_P (CompilerTestSkSL, FailsToCompileDueToArrayInitializerWithVariables)
	TEST_P (CompilerTestSkSL, FailsToCompileDueToArrayAssignment)
	TEST_P (CompilerTestSkSL, CompilesWithValidArrayInitialization)
	TEST_P (CompilerTestRuntime, Mat2Reflection)
	TEST_P (CompilerTestUnknownPlatform, MustFailDueToUnknownPlatform)
	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)
	TEST (ShaderBundleTest, GenerateShaderBundleFlatbufferReportsSourceFilesAsDependencies)
	TEST (ShaderBundleTest, GenerateShaderBundleFlatbufferIgnoresNullDependencyCollector)
	TEST (ShaderBundleTest, DeriveShaderFloatTypeFromDimensions)
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)
	TEST (SwitchesTest, EntryPointPrefixIsApplied)
	TEST (SwitchesTest, CommandLinePathUtf8)

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 120 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();
}

References name, and value.

Referenced by TEST().

GetIntermediatesPath()

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

static

Definition at line 17 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()});
}

References fml::GetCurrentProcId(), flutter::testing::GetCurrentTestName(), flutter::testing::GetFixturesPath(), and fml::paths::JoinPaths().

INSTANTIATE_TEST_SUITE_P() [1/4]

impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P	(	CompilerSuite	,
		CompilerTest	,
		::testing::Values(TargetPlatform::kOpenGLES, TargetPlatform::kOpenGLDesktop, TargetPlatform::kMetalDesktop, TargetPlatform::kMetalIOS, TargetPlatform::kVulkan)	,
		[] (const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);}
	)

References impeller::compiler::TargetPlatformToString().

INSTANTIATE_TEST_SUITE_P() [2/4]

impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P	(	CompilerSuite	,
		CompilerTestRuntime	,
		::testing::Values(TargetPlatform::kRuntimeStageMetal, TargetPlatform::kRuntimeStageGLES, TargetPlatform::kRuntimeStageGLES3, TargetPlatform::kRuntimeStageVulkan, TargetPlatform::kSkSL)	,
		[] (const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);}
	)

References impeller::compiler::TargetPlatformToString().

INSTANTIATE_TEST_SUITE_P() [3/4]

impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P	(	CompilerSuite	,
		CompilerTestSkSL	,
		::testing::Values(TargetPlatform::kSkSL)	,
		[] (const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);}
	)

References impeller::compiler::TargetPlatformToString().

INSTANTIATE_TEST_SUITE_P() [4/4]

impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P	(	CompilerSuite	,
		CompilerTestUnknownPlatform	,
		::testing::Values(TargetPlatform::kUnknown)	,
		[] (const ::testing::TestParamInfo< CompilerTest::ParamType > &info) { return TargetPlatformToString(info.param);}
	)

References impeller::compiler::TargetPlatformToString().

MakeSwitchesDesktopGL()

Switches impeller::compiler::testing::MakeSwitchesDesktopGL

(

std::initializer_list< const char * >

additional_options = {}

)

Definition at line 20 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);
}

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

ReflectionCCName()

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

static

Definition at line 48 of file compiler_test.cc.

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

Referenced by impeller::compiler::testing::CompilerTestBase::CanCompileAndReflect().

ReflectionHeaderName()

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

static

Definition at line 42 of file compiler_test.cc.

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

Referenced by impeller::compiler::testing::CompilerTestBase::CanCompileAndReflect().

ReflectionJSONName()

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

static

Definition at line 54 of file compiler_test.cc.

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

Referenced by impeller::compiler::testing::CompilerTestBase::CanCompileAndReflect(), and impeller::compiler::testing::CompilerTestBase::GetReflectionJson().

SLFileName()

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

static

Definition at line 66 of file compiler_test.cc.

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

References impeller::compiler::TargetPlatformSLExtension().

Referenced by impeller::compiler::testing::CompilerTestBase::CanCompileAndReflect(), and impeller::compiler::testing::CompilerTestBase::GetShaderFile().

SPIRVFileName()

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

static

Definition at line 60 of file compiler_test.cc.

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

Referenced by impeller::compiler::testing::CompilerTestBase::CanCompileAndReflect().

TEST() [1/22]

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

Definition at line 58 of file compiler_unittests.cc.

                            {
  std::shared_ptr<const fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("check_gles_definition.frag");
 
  SourceOptions options;
  options.source_language = SourceLanguage::kGLSL;
  options.target_platform = TargetPlatform::kRuntimeStageGLES;
  options.entry_point_name = "main";
  options.type = SourceType::kFragmentShader;
 
  Reflector::Options reflector_options;
  reflector_options.target_platform = TargetPlatform::kRuntimeStageGLES;
  Compiler compiler = Compiler(fixture, options, reflector_options);
 
  // Should fail as the shader has a compilation error in it.
  EXPECT_EQ(compiler.GetSPIRVAssembly(), nullptr);
 
  // Should succeed as the compilation error is ifdef'd out.
  options.target_platform = TargetPlatform::kRuntimeStageVulkan;
  reflector_options.target_platform = TargetPlatform::kRuntimeStageVulkan;
  Compiler compiler_2 = Compiler(fixture, options, reflector_options);
  EXPECT_NE(compiler_2.GetSPIRVAssembly(), nullptr);
}

References impeller::compiler::SourceOptions::entry_point_name, impeller::compiler::Compiler::GetSPIRVAssembly(), impeller::compiler::kFragmentShader, impeller::compiler::kGLSL, impeller::compiler::kRuntimeStageGLES, impeller::compiler::kRuntimeStageVulkan, flutter::testing::OpenFixtureAsMapping(), impeller::compiler::SourceOptions::source_language, impeller::compiler::Reflector::Options::target_platform, impeller::compiler::SourceOptions::target_platform, and impeller::compiler::SourceOptions::type.

TEST() [2/22]

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

Definition at line 82 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);
}

References impeller::compiler::kComputeShader, impeller::compiler::kFragmentShader, impeller::compiler::kUnknown, impeller::compiler::kVertexShader, and impeller::compiler::SourceTypeFromFileName().

TEST() [3/22]

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

Definition at line 273 of file shader_bundle_unittests.cc.

                                                            {
  // Non-float types always map to nullopt.
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kSignedInt, 1, 1), std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kUnsignedInt, 4, 1),
            std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kBoolean, 1, 1), std::nullopt);
 
  // Scalar and vector floats (columns == 1).
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 1, 1),
            ShaderFloatType::kFloat);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 2, 1),
            ShaderFloatType::kVec2);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 3, 1),
            ShaderFloatType::kVec3);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 4, 1),
            ShaderFloatType::kVec4);
 
  // Square matrices (vec_size == columns).
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 2, 2),
            ShaderFloatType::kMat2);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 3, 3),
            ShaderFloatType::kMat3);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 4, 4),
            ShaderFloatType::kMat4);
 
  // Non-square matrices and unsupported shapes return nullopt.
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 3, 2), std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 2, 3), std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 5, 1), std::nullopt);
 
  // Zero values (legacy bundle defaults) map to nullopt.
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 0, 0), std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 0, 1), std::nullopt);
  EXPECT_EQ(DeriveShaderFloatType(ShaderType::kFloat, 1, 0), std::nullopt);
}

References impeller::DeriveShaderFloatType(), impeller::kBoolean, impeller::kFloat, impeller::kMat2, impeller::kMat3, impeller::kMat4, impeller::kSignedInt, impeller::kUnsignedInt, impeller::kVec2, impeller::kVec3, and impeller::kVec4.

TEST() [4/22]

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

Definition at line 251 of file shader_bundle_unittests.cc.

                                                                   {
  // Passing nullptr as the dependency collector is supported and is
  // the default behaviour for callers that don't need a depfile.
  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, /*out_dependencies=*/
                                     nullptr);
  ASSERT_TRUE(bundle.has_value());
}

References impeller::compiler::GenerateShaderBundleFlatbuffer(), flutter::testing::GetFixturesPath(), impeller::compiler::kGLSL, impeller::compiler::kRuntimeStageMetal, impeller::compiler::SourceOptions::source_language, and impeller::compiler::SourceOptions::target_platform.

TEST() [5/22]

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

Verify vertex shader.

Verify fragment shader.

Definition at line 131 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);
  EXPECT_EQ(mvp->vec_size, 4u);
  EXPECT_EQ(mvp->columns, 4u);
  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);
  EXPECT_EQ(color->vec_size, 4u);
  EXPECT_EQ(color->columns, 1u);
 
  // --------------------------------------------------------------------------
  /// 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);
}

References FindByName(), impeller::compiler::GenerateShaderBundleFlatbuffer(), flutter::testing::GetFixturesPath(), impeller::compiler::kGLSL, impeller::compiler::kRuntimeStageMetal, impeller::compiler::SourceOptions::source_language, and impeller::compiler::SourceOptions::target_platform.

TEST() [6/22]

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

Definition at line 222 of file shader_bundle_unittests.cc.

                                                                     {
  std::string fixtures_path = flutter::testing::GetFixturesPath();
  const std::string fragment_path = fixtures_path + "/flutter_gpu_unlit.frag";
  const std::string vertex_path = fixtures_path + "/flutter_gpu_unlit.vert";
  std::string config =
      "{\"UnlitFragment\": {\"type\": \"fragment\", \"file\":\"" +
      fragment_path +
      "\"}, \"UnlitVertex\": {\"type\": \"vertex\", \"file\": \"" +
      vertex_path + "\"}}";
 
  SourceOptions options;
  options.target_platform = TargetPlatform::kRuntimeStageMetal;
  options.source_language = SourceLanguage::kGLSL;
 
  std::set<std::string> dependencies;
  std::optional<fb::shaderbundle::ShaderBundleT> bundle =
      GenerateShaderBundleFlatbuffer(config, options, &dependencies);
  ASSERT_TRUE(bundle.has_value());
 
  // Every primary source file referenced by the bundle config should
  // appear in the dependency set, deduplicated across the multiple
  // target-platform compiles of each shader. The fixtures used here
  // don't contain `#include` directives, so the dependency set
  // contains exactly the two source files.
  EXPECT_NE(dependencies.find(fragment_path), dependencies.end());
  EXPECT_NE(dependencies.find(vertex_path), dependencies.end());
}

References impeller::compiler::GenerateShaderBundleFlatbuffer(), flutter::testing::GetFixturesPath(), impeller::compiler::kGLSL, impeller::compiler::kRuntimeStageMetal, impeller::compiler::SourceOptions::source_language, and impeller::compiler::SourceOptions::target_platform.

TEST() [7/22]

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

Definition at line 25 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [8/22]

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

Definition at line 77 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [9/22]

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

Definition at line 65 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [10/22]

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

Definition at line 34 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [11/22]

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

Definition at line 44 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [12/22]

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

Definition at line 54 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");
}

References error, and impeller::compiler::ParseShaderBundleConfig().

TEST() [13/22]

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

Definition at line 89 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");
}

References error, impeller::compiler::kFragmentShader, impeller::compiler::kGLSL, kUnlitFragmentBundleConfig, kUnlitVertexBundleConfig, impeller::compiler::kVertexShader, and impeller::compiler::ParseShaderBundleConfig().

TEST() [14/22]

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

Definition at line 109 of file switches_unittests.cc.

                                        {
  std::u16string filename = u"test\u1234";
  std::string input_flag = "--input=" + fml::Utf16ToUtf8(filename);
  Switches switches = MakeSwitchesDesktopGL({input_flag.c_str()});
  ASSERT_TRUE(switches.AreValid(std::cout));
  ASSERT_EQ(switches.source_file_name, filename);
}

References impeller::compiler::Switches::AreValid(), MakeSwitchesDesktopGL(), impeller::compiler::Switches::source_file_name, and fml::Utf16ToUtf8().

TEST() [15/22]

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

Definition at line 74 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(""), "");
}

References impeller::compiler::ConvertToEntrypointName().

TEST() [16/22]

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

Definition at line 62 of file switches_unittests.cc.

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

References impeller::compiler::Switches::AreValid(), impeller::compiler::Switches::entry_point, and MakeSwitchesDesktopGL().

TEST() [17/22]

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

Definition at line 33 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);
}

References impeller::compiler::Switches::AreValid(), fml::CreateDirectory(), flutter::testing::GetFixturesPath(), impeller::compiler::Switches::include_directories, fml::kRead, MakeSwitchesDesktopGL(), and flutter::testing::OpenFixturesDirectory().

TEST() [18/22]

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

Definition at line 68 of file switches_unittests.cc.

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

References impeller::compiler::Switches::AreValid(), impeller::compiler::Switches::entry_point, and MakeSwitchesDesktopGL().

TEST() [19/22]

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

Definition at line 98 of file switches_unittests.cc.

                                              {
  Switches switches =
      MakeSwitchesDesktopGL({"--entry-point-prefix=my_prefix_"});
  ASSERT_TRUE(switches.AreValid(std::cout));
  EXPECT_EQ(switches.entry_point_prefix, "my_prefix_");
 
  switches.source_file_name = "test.frag";
  auto options = switches.CreateSourceOptions();
  EXPECT_EQ(options.entry_point_name, "my_prefix_test_fragment_main");
}

References impeller::compiler::Switches::AreValid(), impeller::compiler::Switches::CreateSourceOptions(), impeller::compiler::Switches::entry_point_prefix, MakeSwitchesDesktopGL(), and impeller::compiler::Switches::source_file_name.

TEST() [20/22]

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

Definition at line 85 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, "{}");
}

References impeller::compiler::Switches::AreValid(), fml::CommandLineFromIteratorsWithArgv0(), and impeller::compiler::Switches::shader_bundle.

TEST() [21/22]

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

Definition at line 56 of file switches_unittests.cc.

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

References impeller::compiler::Switches::AreValid(), impeller::compiler::kHLSL, MakeSwitchesDesktopGL(), and impeller::compiler::Switches::source_language.

TEST() [22/22]

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

Definition at line 50 of file switches_unittests.cc.

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

References impeller::compiler::Switches::AreValid(), impeller::compiler::kGLSL, MakeSwitchesDesktopGL(), and impeller::compiler::Switches::source_language.

TEST_P() [1/19]

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

Definition at line 148 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);
}

References impeller::compiler::kFragmentShader, impeller::compiler::kVertexShader, and impeller::compiler::TargetPlatformIsVulkan().

TEST_P() [2/19]

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

Definition at line 90 of file compiler_unittests.cc.

                                 {
  ASSERT_TRUE(CanCompileAndReflect("sample.vert"));
  ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader));
  ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader,
                                   SourceLanguage::kGLSL));
}

References impeller::compiler::kGLSL, and impeller::compiler::kVertexShader.

TEST_P() [3/19]

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

Definition at line 111 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));
}

References impeller::compiler::kComputeShader, and impeller::compiler::TargetPlatformIsMetal().

TEST_P() [4/19]

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

Definition at line 97 of file compiler_unittests.cc.

                                     {
  ASSERT_TRUE(CanCompileAndReflect(
      "simple.vert.hlsl", SourceType::kVertexShader, SourceLanguage::kHLSL));
}

References impeller::compiler::kHLSL, and impeller::compiler::kVertexShader.

TEST_P() [5/19]

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

Definition at line 102 of file compiler_unittests.cc.

                                                       {
  ASSERT_TRUE(CanCompileAndReflect("multiple_stages.hlsl",
                                   SourceType::kVertexShader,
                                   SourceLanguage::kHLSL, "VertexShader"));
  ASSERT_TRUE(CanCompileAndReflect("multiple_stages.hlsl",
                                   SourceType::kFragmentShader,
                                   SourceLanguage::kHLSL, "FragmentShader"));
}

References impeller::compiler::kFragmentShader, impeller::compiler::kHLSL, and impeller::compiler::kVertexShader.

TEST_P() [6/19]

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

Definition at line 120 of file compiler_unittests.cc.

                                                           {
  ScopedValidationDisable disable_validation;
  ASSERT_FALSE(
      CanCompileAndReflect("resources_limit.vert", SourceType::kVertexShader));
}

References impeller::compiler::kVertexShader.

TEST_P() [7/19]

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

Definition at line 126 of file compiler_unittests.cc.

                                                                   {
  ScopedValidationDisable disable_validation;
  ASSERT_FALSE(CanCompileAndReflect("struct_def_bug.vert"));
}

TEST_P() [8/19]

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

Definition at line 131 of file compiler_unittests.cc.

                                                                 {
  if (!TargetPlatformIsOpenGL(GetParam())) {
    GTEST_SKIP() << "Only GL targets lower uniform blocks to flat structs.";
  }
  // `mat2_test.frag` has `uniform Params { ... } uParams;`. Without
  // canonicalization, BufferBindingsGLES cannot resolve `uParams.uMat2`.
  ASSERT_TRUE(
      CanCompileAndReflect("mat2_test.frag", SourceType::kFragmentShader));
  auto sl_source = GetCompiler()->GetSLShaderSource();
  ASSERT_NE(sl_source, nullptr);
  const std::string source(
      reinterpret_cast<const char*>(sl_source->GetMapping()),
      sl_source->GetSize());
  EXPECT_EQ(source.find("uParams."), std::string::npos) << source;
  EXPECT_NE(source.find("_Params."), std::string::npos) << source;
}

References impeller::compiler::kFragmentShader, and impeller::compiler::TargetPlatformIsOpenGL().

TEST_P() [9/19]

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

Definition at line 352 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);
}

References impeller::compiler::kFragmentShader, impeller::compiler::kSkSL, and impeller::compiler::kVertexShader.

TEST_P() [10/19]

impeller::compiler::testing::TEST_P	(	CompilerTestRuntime	,
		Mat2Reflection
	)

Definition at line 488 of file compiler_unittests.cc.

                                            {
  if (GetParam() == TargetPlatform::kSkSL) {
    GTEST_SKIP() << "Not supported with SkSL";
  }
 
  ASSERT_TRUE(CanCompileAndReflect(
      "mat2_test.frag", SourceType::kFragmentShader, SourceLanguage::kGLSL));
 
  std::unique_ptr<fml::FileMapping> json_fd =
      GetReflectionJson("mat2_test.frag");
  ASSERT_TRUE(json_fd);
  nlohmann::json shader_json = nlohmann::json::parse(json_fd->GetMapping());
  nlohmann::json::value_type buffers = shader_json["buffers"];
 
  // uParams should be in buffers.
  ASSERT_GE(buffers.size(), 1u);
  nlohmann::json::value_type uParams = buffers[0];
  EXPECT_EQ(uParams["name"], "Params");
 
  nlohmann::json::value_type members = uParams["type"]["members"];
  // We expect 1 member (for the mat2) which is a Point (vec2) with array
  // size 2.
  ASSERT_EQ(members.size(), 1u);
 
  nlohmann::json::value_type mat2Member = members[0];
 
  // Should be Mat2 (vec2)
  EXPECT_EQ(mat2Member["type"], "Mat2");
 
  // Size 8 bytes (vec2)
  EXPECT_EQ(mat2Member["size"], 8u);
 
  // Byte length should be total array size (stride * count)
  // Stride 16 * 2 = 32.
  EXPECT_EQ(mat2Member["byte_length"], 32u);
 
  // Array elements should be 2 (columns).
  EXPECT_EQ(mat2Member["array_elements"], 2u);
 
  // Offset 0
  EXPECT_EQ(mat2Member["offset"], 0u);
}

References impeller::compiler::kFragmentShader, impeller::compiler::kGLSL, and impeller::compiler::kSkSL.

TEST_P() [11/19]

impeller::compiler::testing::TEST_P	(	CompilerTestRuntime	,
		PositionedUniformsAppearInJson
	)

Definition at line 298 of file compiler_unittests.cc.

                                                            {
  if (GetParam() == TargetPlatform::kRuntimeStageVulkan) {
    // TODO(https://github.com/flutter/flutter/issues/182578): Investigate why
    // this does not pass.
    GTEST_SKIP() << "Not supported with Vulkan";
  }
 
  ASSERT_TRUE(CanCompileAndReflect("sample_with_positioned_uniforms.frag",
                                   SourceType::kFragmentShader,
                                   SourceLanguage::kGLSL));
 
  auto json_fd = GetReflectionJson("sample_with_positioned_uniforms.frag");
  ASSERT_TRUE(json_fd);
  nlohmann::json shader_json = nlohmann::json::parse(json_fd->GetMapping());
  auto sampler_list = shader_json["sampled_images"];
  auto float_list = shader_json["uniforms"];
  ASSERT_EQ(sampler_list.size(), 3u);
  ASSERT_EQ(float_list.size(), 7u);
 
  {
    // clang-format off
    std::array expected_infos = {
        UniformInfo::Sampler("uSamplerNotPositioned1", 1u),
        UniformInfo::Sampler("uSampler", 0u),
        UniformInfo::Sampler("uSamplerNotPositioned2", 3u),
    };
    // clang-format on
    ASSERT_EQ(sampler_list.size(), expected_infos.size());
    for (size_t i = 0; i < expected_infos.size(); i++) {
      EXPECT_EQ(UniformInfo::fromJson(sampler_list[i]), expected_infos[i])
          << "index: " << i;
    }
  }
 
  {
    // clang-format off
    std::array expected_infos = {
        UniformInfo::Float("uFloatNotPositioned1", 0u),
        UniformInfo::Float("uFloat", 6u),
        UniformInfo::Vec2("uVec2", 5u),
        UniformInfo::Vec3("uVec3", 3u),
        UniformInfo::Vec4("uVec4", 2u),
        UniformInfo::Mat4("uMat4", 1u),
        UniformInfo::Float("uFloatNotPositioned2", 2u),
    };
    // clang-format on
    ASSERT_EQ(float_list.size(), expected_infos.size());
    for (size_t i = 0; i < expected_infos.size(); i++) {
      EXPECT_EQ(UniformInfo::fromJson(float_list[i]), expected_infos[i])
          << "index: " << i;
    }
  }
}

References i, impeller::compiler::kFragmentShader, impeller::compiler::kGLSL, and impeller::compiler::kRuntimeStageVulkan.

TEST_P() [12/19]

impeller::compiler::testing::TEST_P	(	CompilerTestRuntime	,
		UniformsAppearInJson
	)

Definition at line 246 of file compiler_unittests.cc.

                                                  {
  if (GetParam() == TargetPlatform::kRuntimeStageVulkan) {
    // TODO(https://github.com/flutter/flutter/issues/182578): Investigate why
    // this does not pass.
    GTEST_SKIP() << "Not supported with Vulkan";
  }
 
  ASSERT_TRUE(CanCompileAndReflect("sample_with_uniforms.frag",
                                   SourceType::kFragmentShader,
                                   SourceLanguage::kGLSL));
 
  auto json_fd = GetReflectionJson("sample_with_uniforms.frag");
  ASSERT_TRUE(json_fd);
  nlohmann::json shader_json = nlohmann::json::parse(json_fd->GetMapping());
  auto sampler_list = shader_json["sampled_images"];
  auto float_list = shader_json["uniforms"];
  ASSERT_EQ(sampler_list.size(), 2u);
  ASSERT_EQ(float_list.size(), 6u);
 
  {
    // clang-format off
    std::array expected_infos = {
        UniformInfo::Sampler("uFirstSampler", 1u),
        UniformInfo::Sampler("uSampler", 7u),
    };
    // clang-format on
    ASSERT_EQ(sampler_list.size(), expected_infos.size());
    for (size_t i = 0; i < expected_infos.size(); i++) {
      EXPECT_EQ(UniformInfo::fromJson(sampler_list[i]), expected_infos[i])
          << "index: " << i;
    }
  }
 
  {
    // clang-format off
    std::array expected_infos = {
        UniformInfo::Float("uFirstFloat", 0u),
        UniformInfo::Float("uFloat", 2u),
        UniformInfo::Vec2("uVec2", 3u),
        UniformInfo::Vec3("uVec3", 4u),
        UniformInfo::Vec4("uVec4", 5u),
        UniformInfo::Mat4("uMat4", 6u),
    };
    // clang-format on
    ASSERT_EQ(float_list.size(), expected_infos.size());
    for (size_t i = 0; i < expected_infos.size(); i++) {
      EXPECT_EQ(UniformInfo::fromJson(float_list[i]), expected_infos[i])
          << "index: " << i;
    }
  }
}

References i, impeller::compiler::kFragmentShader, impeller::compiler::kGLSL, and impeller::compiler::kRuntimeStageVulkan.

TEST_P() [13/19]

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

Definition at line 395 of file compiler_unittests.cc.

                                            {
  ASSERT_TRUE(CanCompileAndReflect("struct_internal.frag",
                                   SourceType::kFragmentShader));
}

References impeller::compiler::kFragmentShader.

TEST_P() [14/19]

impeller::compiler::testing::TEST_P	(	CompilerTestSkSL	,
		CompilesWithValidArrayInitialization
	)

Definition at line 482 of file compiler_unittests.cc.

                                                               {
  ASSERT_TRUE(
      CanCompileAndReflect("array_initialization_without_initializer.frag",
                           SourceType::kFragmentShader));
}

References impeller::compiler::kFragmentShader.

TEST_P() [15/19]

impeller::compiler::testing::TEST_P	(	CompilerTestSkSL	,
		FailsToCompileDueToArrayAssignment
	)

Definition at line 420 of file compiler_unittests.cc.

                                                             {
  // Does not EXIT because the backend SkSL compiler doesn't detect the invalid
  // SkSL. Returns false because the Impeller Compiler's post-compile validation
  // fails.
  ASSERT_FALSE(CanCompileAndReflect("array_assignment.frag",
                                    SourceType::kFragmentShader));
 
  const Compiler* compiler = GetCompiler();
  ASSERT_TRUE(compiler);
  // Truncated error message.
  ASSERT_STREQ(
      compiler->GetErrorMessages().c_str(),
      "\"array_assignment.frag\": \n"
      "Compiled to invalid SkSL:\n"
      "        // This SkSL shader is autogenerated by spirv-cross.\n"
      "        \n"
      "        float4 flutter_FragCoord;\n"
      "        \n"
      "        vec4 frag_color;\n"
      "        \n"
      "... (truncated 16 lines)\n"
      "SkSL Error:\n"
      "        error: 12: initializers are not permitted on arrays (or structs "
      "containing arrays)\n"
      "            float more_nums[2] = nums;\n"
      "                                 ^^^^\n"
      "        1 error\n");
  // Full error message.
  ASSERT_STREQ(compiler->GetVerboseErrorMessages().c_str(),
               "\"array_assignment.frag\": \n"
               "Compiled to invalid SkSL:\n"
               "// This SkSL shader is autogenerated by spirv-cross.\n"
               "\n"
               "float4 flutter_FragCoord;\n"
               "\n"
               "vec4 frag_color;\n"
               "\n"
               "void FLT_main()\n"
               "{\n"
               "    float nums[2];\n"
               "    nums[0] = 1.0;\n"
               "    nums[1] = 0.5;\n"
               "    float more_nums[2] = nums;\n"
               "    frag_color = vec4(nums[0], nums[1], 1.0, 1.0);\n"
               "}\n"
               "\n"
               "half4 main(float2 iFragCoord)\n"
               "{\n"
               "      flutter_FragCoord = float4(iFragCoord, 0, 0);\n"
               "      FLT_main();\n"
               "      return frag_color;\n"
               "}\n"
               "\n"
               "SkSL Error:\n"
               "error: 12: initializers are not permitted on arrays (or "
               "structs containing arrays)\n"
               "    float more_nums[2] = nums;\n"
               "                         ^^^^\n"
               "1 error\n"
               "\n");
}

References impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetVerboseErrorMessages(), and impeller::compiler::kFragmentShader.

TEST_P() [16/19]

impeller::compiler::testing::TEST_P	(	CompilerTestSkSL	,
		FailsToCompileDueToArrayInitializerWithConstants
	)

Definition at line 400 of file compiler_unittests.cc.

                                                                           {
  auto expected_err =
      "There was a compiler error: SkSL does not support array initializers: "
      "array_initializer_with_constants.frag:6";
 
  EXPECT_EXIT(CanCompileAndReflect("array_initializer_with_constants.frag",
                                   SourceType::kFragmentShader),
              ::testing::ExitedWithCode(1), expected_err);
}

References impeller::compiler::kFragmentShader.

TEST_P() [17/19]

impeller::compiler::testing::TEST_P	(	CompilerTestSkSL	,
		FailsToCompileDueToArrayInitializerWithVariables
	)

Definition at line 410 of file compiler_unittests.cc.

                                                                           {
  auto expected_err =
      "There was a compiler error: SkSL does not support array initializers: "
      "array_initializer_with_variables.frag:12";
 
  EXPECT_EXIT(CanCompileAndReflect("array_initializer_with_variables.frag",
                                   SourceType::kFragmentShader),
              ::testing::ExitedWithCode(1), expected_err);
}

References impeller::compiler::kFragmentShader.

TEST_P() [18/19]

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

Definition at line 381 of file compiler_unittests.cc.

                                                             {
  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);
}

References impeller::compiler::kFragmentShader.

TEST_P() [19/19]

impeller::compiler::testing::TEST_P	(	CompilerTestUnknownPlatform	,
		MustFailDueToUnknownPlatform
	)

Definition at line 531 of file compiler_unittests.cc.

                                                                  {
  ASSERT_FALSE(
      CanCompileAndReflect("sample.frag", SourceType::kFragmentShader));
}

References impeller::compiler::kFragmentShader.

Variable Documentation

kUnlitFragmentBundleConfig

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

Initial value:

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

Definition at line 18 of file shader_bundle_unittests.cc.

Referenced by TEST().

kUnlitVertexBundleConfig

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

Initial value:

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

Definition at line 21 of file shader_bundle_unittests.cc.

Referenced by TEST().