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
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 23 of file compiler_test.cc.

    : intermediates_directory_(CreateIntermediatesDirectory()) {
  FML_CHECK(intermediates_directory_.is_valid());
}

~CompilerTest()

impeller::compiler::testing::CompilerTest::~CompilerTest ( )

default

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 68 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;
}

References impeller::compiler::SourceOptions::entry_point_name, impeller::compiler::EntryPointFunctionNameFromSourceName(), impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Compiler::GetSLShaderSource(), impeller::compiler::Compiler::GetSPIRVAssembly(), impeller::compiler::Reflector::Options::header_file_name, impeller::compiler::Compiler::IsValid(), 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::SourceOptions::target_platform, impeller::compiler::TargetPlatformNeedsReflection(), VALIDATION_LOG, and impeller::compiler::SourceOptions::working_directory.

GetReflectionJson()

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

(

const char *

fixture_name

)

const

Definition at line 61 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 impeller::compiler::testing::ReflectionJSONName().

---

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

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