impeller::compiler::testing::CompilerTestBase Class Reference

#include <compiler_test.h>

Inheritance diagram for impeller::compiler::testing::CompilerTestBase:

Public Member Functions
	CompilerTestBase ()
	~CompilerTestBase ()
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 Compiler *	GetCompiler () const

Detailed Description

Definition at line 18 of file compiler_test.h.

Constructor & Destructor Documentation

CompilerTestBase()

impeller::compiler::testing::CompilerTestBase::CompilerTestBase

(

)

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

References FML_CHECK, fml::UniqueObject< T, Traits >::is_valid(), fml::kReadWrite, and fml::OpenDirectory().

~CompilerTestBase()

impeller::compiler::testing::CompilerTestBase::~CompilerTestBase

(

)

Definition at line 36 of file compiler_test.cc.

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

References fml::UniqueObject< T, Traits >::reset().

Member Function Documentation

CanCompileAndReflect()

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

Definition at line 88 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.target_platform = GetParam();
  reflector_options.header_file_name = ReflectionHeaderName(fixture_name);
  reflector_options.shader_name = "shader_name";
 
  compiler_ =
      std::make_unique<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;
  }
 
  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;
}

References impeller::compiler::SourceOptions::entry_point_name, impeller::compiler::EntryPointFunctionNameFromSourceName(), impeller::compiler::Reflector::Options::header_file_name, flutter::testing::OpenFixtureAsMapping(), flutter::testing::OpenFixturesDirectory(), impeller::compiler::testing::ReflectionCCName(), impeller::compiler::testing::ReflectionHeaderName(), impeller::compiler::testing::ReflectionJSONName(), impeller::compiler::Reflector::Options::shader_name, impeller::compiler::testing::SLFileName(), impeller::compiler::SourceOptions::source_language, impeller::compiler::SourceTypeFromFileName(), impeller::compiler::testing::SPIRVFileName(), impeller::compiler::Reflector::Options::target_platform, impeller::compiler::SourceOptions::target_platform, VALIDATION_LOG, impeller::compiler::SourceOptions::working_directory, and fml::WriteAtomically().

GetCompiler()

const Compiler * impeller::compiler::testing::CompilerTestBase::GetCompiler

(

)

const

Definition at line 194 of file compiler_test.cc.

                                                    {
  return compiler_.get();
}

GetReflectionJson()

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

(

const char *

fixture_name

)

const

Definition at line 73 of file compiler_test.cc.

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

References fml::FileMapping::CreateReadOnly(), fml::OpenFileReadOnly(), and impeller::compiler::testing::ReflectionJSONName().

GetShaderFile()

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

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

References fml::FileMapping::CreateReadOnly(), fml::OpenFileReadOnly(), and impeller::compiler::testing::SLFileName().

---

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

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