impeller::compiler::testing::CompilerTest Class Reference

#include <compiler_test.h>

Inheritance diagram for impeller::compiler::testing::CompilerTest:

Public Member Functions
	CompilerTest ()
	~CompilerTest ()
std::unique_ptr< fml::FileMapping >	GetReflectionJson (const char *fixture_name) const
std::unique_ptr< fml::FileMapping >	GetShaderFile (const char *fixture_name, TargetPlatform platform) const
bool	CanCompileAndReflect (const char *fixture_name, SourceType source_type=SourceType::kUnknown, SourceLanguage source_language=SourceLanguage::kGLSL, const char *entry_point_name="main") const

Detailed Description

Definition at line 18 of file compiler_test.h.

Constructor & Destructor Documentation

CompilerTest()

impeller::compiler::testing::CompilerTest::CompilerTest

(

)

Definition at line 26 of file compiler_test.cc.

                           : intermediates_path_(GetIntermediatesPath()) {
  intermediates_directory_ =
      fml::OpenDirectory(intermediates_path_.c_str(),
                         true,  // create if necessary
                         fml::FilePermission::kReadWrite);
  FML_CHECK(intermediates_directory_.is_valid());
}

~CompilerTest()

impeller::compiler::testing::CompilerTest::~CompilerTest

(

)

Definition at line 34 of file compiler_test.cc.

                            {
  intermediates_directory_.reset();
 
  std::filesystem::remove_all(std::filesystem::path(intermediates_path_));
}

Member Function Documentation

CanCompileAndReflect()

bool impeller::compiler::testing::CompilerTest::CanCompileAndReflect	(	const char *	fixture_name,
		SourceType	source_type = SourceType::kUnknown,
		SourceLanguage	source_language = SourceLanguage::kGLSL,
		const char *	entry_point_name = "main"
	)		const

Definition at line 86 of file compiler_test.cc.

                                                                            {
  std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping(fixture_name);
  if (!fixture || !fixture->GetMapping()) {
    VALIDATION_LOG << "Could not find shader in fixtures: " << fixture_name;
    return false;
  }
 
  SourceOptions source_options(fixture_name, source_type);
  source_options.target_platform = GetParam();
  source_options.source_language = source_language;
  source_options.working_directory = std::make_shared<fml::UniqueFD>(
      flutter::testing::OpenFixturesDirectory());
  source_options.entry_point_name = EntryPointFunctionNameFromSourceName(
      fixture_name, SourceTypeFromFileName(fixture_name), source_language,
      entry_point_name);
 
  Reflector::Options reflector_options;
  reflector_options.header_file_name = ReflectionHeaderName(fixture_name);
  reflector_options.shader_name = "shader_name";
 
  Compiler compiler(fixture, source_options, reflector_options);
  if (!compiler.IsValid()) {
    VALIDATION_LOG << "Compilation failed: " << compiler.GetErrorMessages();
    return false;
  }
 
  auto spirv_assembly = compiler.GetSPIRVAssembly();
  if (!spirv_assembly) {
    VALIDATION_LOG << "No spirv was generated.";
    return false;
  }
 
  if (!fml::WriteAtomically(intermediates_directory_,
                            SPIRVFileName(fixture_name).c_str(),
                            *spirv_assembly)) {
    VALIDATION_LOG << "Could not write SPIRV intermediates.";
    return false;
  }
 
  auto sl_source = compiler.GetSLShaderSource();
  if (!sl_source) {
    VALIDATION_LOG << "No SL source was generated.";
    return false;
  }
 
  if (!fml::WriteAtomically(intermediates_directory_,
                            SLFileName(fixture_name, GetParam()).c_str(),
                            *sl_source)) {
    VALIDATION_LOG << "Could not write SL intermediates.";
    return false;
  }
 
  if (TargetPlatformNeedsReflection(GetParam())) {
    auto reflector = compiler.GetReflector();
    if (!reflector) {
      VALIDATION_LOG
          << "No reflector was found for target platform SL compiler.";
      return false;
    }
 
    auto reflection_json = reflector->GetReflectionJSON();
    auto reflection_header = reflector->GetReflectionHeader();
    auto reflection_source = reflector->GetReflectionCC();
 
    if (!reflection_json) {
      VALIDATION_LOG << "Reflection JSON was not found.";
      return false;
    }
 
    if (!reflection_header) {
      VALIDATION_LOG << "Reflection header was not found.";
      return false;
    }
 
    if (!reflection_source) {
      VALIDATION_LOG << "Reflection source was not found.";
      return false;
    }
 
    if (!fml::WriteAtomically(intermediates_directory_,
                              ReflectionHeaderName(fixture_name).c_str(),
                              *reflection_header)) {
      VALIDATION_LOG << "Could not write reflection header intermediates.";
      return false;
    }
 
    if (!fml::WriteAtomically(intermediates_directory_,
                              ReflectionCCName(fixture_name).c_str(),
                              *reflection_source)) {
      VALIDATION_LOG << "Could not write reflection CC intermediates.";
      return false;
    }
 
    if (!fml::WriteAtomically(intermediates_directory_,
                              ReflectionJSONName(fixture_name).c_str(),
                              *reflection_json)) {
      VALIDATION_LOG << "Could not write reflection json intermediates.";
      return false;
    }
  }
  return true;
}

GetReflectionJson()

std::unique_ptr< fml::FileMapping > impeller::compiler::testing::CompilerTest::GetReflectionJson

(

const char *

fixture_name

)

const

Definition at line 71 of file compiler_test.cc.

                                    {
  auto filename = ReflectionJSONName(fixture_name);
  auto fd = fml::OpenFileReadOnly(intermediates_directory_, filename.c_str());
  return fml::FileMapping::CreateReadOnly(fd);
}

GetShaderFile()

std::unique_ptr< fml::FileMapping > impeller::compiler::testing::CompilerTest::GetShaderFile	(	const char *	fixture_name,
		TargetPlatform	platform
	)		const

Definition at line 78 of file compiler_test.cc.

                                   {
  auto filename = SLFileName(fixture_name, platform);
  auto fd = fml::OpenFileReadOnly(intermediates_directory_, filename.c_str());
  return fml::FileMapping::CreateReadOnly(fd);
}

---

The documentation for this class was generated from the following files:

• impeller/compiler/compiler_test.h
• impeller/compiler/compiler_test.cc