flutter::gpu::testing Namespace Reference

Functions
static std::shared_ptr< fml::Mapping >	CreateMappingFromVector (const std::shared_ptr< std::vector< uint8_t > > &data)
static std::shared_ptr< std::vector< uint8_t > >	BuildValidEmptyBundle ()
static std::shared_ptr< std::vector< uint8_t > >	BuildCorruptBundle ()
	TEST (FlutterGpuShaderLibraryTest, VerifierAcceptsValidBundleRejectsCorrupt)
	TEST (FlutterGpuShaderLibraryTest, MakeFromFlatbufferRejectsCorruptBufferWithValidIdentifier)
	TEST (FlutterGpuShaderLibraryTest, MakeFromFlatbufferRejectsTruncatedBuffer)
	TEST (FlutterGpuShaderLibraryTest, MakeFromFlatbufferRejectsMissingIdentifier)
	TEST (FlutterGpuShaderLibraryTest, MakeFromFlatbufferRejectsNullPayload)
	TEST (FlutterGpuShaderLibraryTest, MakeFromFlatbufferValidEmptyBundleIsNotRejectedByVerifier)

Function Documentation

BuildCorruptBundle()

static std::shared_ptr< std::vector< uint8_t > > flutter::gpu::testing::BuildCorruptBundle ( )

static

Definition at line 61 of file shader_library_unittests.cc.

                                                              {
  auto data = std::make_shared<std::vector<uint8_t>>(32, 0);
  // "IPSB" file identifier at bytes 4-7.
  (*data)[4] = 'I';
  (*data)[5] = 'P';
  (*data)[6] = 'S';
  (*data)[7] = 'B';
  // Root offset (little-endian uint32 at offset 0) pointing out of bounds.
  (*data)[0] = 0xFF;
  (*data)[1] = 0xFF;
  return data;
}

References flutter::data.

Referenced by TEST(), and TEST().

BuildValidEmptyBundle()

static std::shared_ptr< std::vector< uint8_t > > flutter::gpu::testing::BuildValidEmptyBundle ( )

static

Definition at line 38 of file shader_library_unittests.cc.

                                                                 {
  flatbuffers::FlatBufferBuilder builder;
  std::vector<flatbuffers::Offset<impeller::fb::shaderbundle::Shader>> shaders;
  auto shaders_vec = builder.CreateVector(shaders);
  impeller::fb::shaderbundle::ShaderBundleBuilder bundle_builder(builder);
  bundle_builder.add_format_version(static_cast<uint32_t>(
      impeller::fb::shaderbundle::ShaderBundleFormatVersion::kVersion));
  bundle_builder.add_shaders(shaders_vec);
  auto bundle = bundle_builder.Finish();
  // Finish with the "IPSB" file identifier (mirrors the runtime_stage test's
  // builder.Finish(stages, fb::RuntimeStagesIdentifier()) idiom).
  builder.Finish(bundle, impeller::fb::shaderbundle::ShaderBundleIdentifier());
  return std::make_shared<std::vector<uint8_t>>(
      builder.GetBufferPointer(),
      builder.GetBufferPointer() + builder.GetSize());
}

Referenced by TEST(), and TEST().

CreateMappingFromVector()

static std::shared_ptr< fml::Mapping > flutter::gpu::testing::CreateMappingFromVector ( const std::shared_ptr< std::vector< uint8_t > > &  data )

static

Definition at line 25 of file shader_library_unittests.cc.

                                                   {
  const uint8_t* ptr = data->data();
  const size_t size = data->size();
  return std::make_shared<fml::NonOwnedMapping>(ptr, size,
                                                [data](auto, auto) {});
}

References flutter::data, and flutter::size.

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

TEST() [1/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		MakeFromFlatbufferRejectsCorruptBufferWithValidIdentifier
	)

Definition at line 100 of file shader_library_unittests.cc.

                                                                {
  auto mapping = CreateMappingFromVector(BuildCorruptBundle());
  auto library =
      ShaderLibrary::MakeFromFlatbuffer(impeller::Context::BackendType::kMetal,
                                        std::move(mapping), "test_bundle");
  EXPECT_FALSE(library);
}

References BuildCorruptBundle(), CreateMappingFromVector(), impeller::Context::kMetal, and flutter::gpu::ShaderLibrary::MakeFromFlatbuffer().

TEST() [2/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		MakeFromFlatbufferRejectsMissingIdentifier
	)

Definition at line 128 of file shader_library_unittests.cc.

                                                                              {
  auto data = std::make_shared<std::vector<uint8_t>>(32, 0);
  // No identifier bytes set.
  auto library = ShaderLibrary::MakeFromFlatbuffer(
      impeller::Context::BackendType::kMetal, CreateMappingFromVector(data),
      "test_bundle");
  EXPECT_FALSE(library);
}

References CreateMappingFromVector(), flutter::data, impeller::Context::kMetal, and flutter::gpu::ShaderLibrary::MakeFromFlatbuffer().

TEST() [3/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		MakeFromFlatbufferRejectsNullPayload
	)

Definition at line 138 of file shader_library_unittests.cc.

                                                                        {
  auto library = ShaderLibrary::MakeFromFlatbuffer(
      impeller::Context::BackendType::kMetal, nullptr, "test_bundle");
  EXPECT_FALSE(library);
}

References impeller::Context::kMetal, and flutter::gpu::ShaderLibrary::MakeFromFlatbuffer().

TEST() [4/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		MakeFromFlatbufferRejectsTruncatedBuffer
	)

Definition at line 111 of file shader_library_unittests.cc.

                                                                            {
  // 8 bytes: just enough to hold a (bogus) root offset + "IPSB" identifier.
  auto data = std::make_shared<std::vector<uint8_t>>(8, 0);
  (*data)[4] = 'I';
  (*data)[5] = 'P';
  (*data)[6] = 'S';
  (*data)[7] = 'B';
  // Root offset points past the 8-byte buffer.
  (*data)[0] = 0x10;
  auto library = ShaderLibrary::MakeFromFlatbuffer(
      impeller::Context::BackendType::kMetal, CreateMappingFromVector(data),
      "test_bundle");
  EXPECT_FALSE(library);
}

References CreateMappingFromVector(), flutter::data, impeller::Context::kMetal, and flutter::gpu::ShaderLibrary::MakeFromFlatbuffer().

TEST() [5/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		MakeFromFlatbufferValidEmptyBundleIsNotRejectedByVerifier
	)

Definition at line 149 of file shader_library_unittests.cc.

                                                                {
  auto valid = BuildValidEmptyBundle();
  // The verifier accepts it (asserted directly here so this test stands alone).
  flatbuffers::Verifier verifier(valid->data(), valid->size());
  ASSERT_TRUE(impeller::fb::shaderbundle::VerifyShaderBundleBuffer(verifier));
 
  // Driven through the public entry, an empty bundle yields a null library
  // because there are no shaders to register (empty ShaderMap), NOT because the
  // verifier rejected it.
  auto library = ShaderLibrary::MakeFromFlatbuffer(
      impeller::Context::BackendType::kMetal, CreateMappingFromVector(valid),
      "test_bundle");
  EXPECT_FALSE(library);
}

References BuildValidEmptyBundle(), CreateMappingFromVector(), impeller::Context::kMetal, and flutter::gpu::ShaderLibrary::MakeFromFlatbuffer().

TEST() [6/6]

flutter::gpu::testing::TEST	(	FlutterGpuShaderLibraryTest	,
		VerifierAcceptsValidBundleRejectsCorrupt
	)

Definition at line 77 of file shader_library_unittests.cc.

                                                                            {
  auto valid = BuildValidEmptyBundle();
  EXPECT_TRUE(impeller::fb::shaderbundle::ShaderBundleBufferHasIdentifier(
      valid->data()));
  {
    flatbuffers::Verifier verifier(valid->data(), valid->size());
    EXPECT_TRUE(impeller::fb::shaderbundle::VerifyShaderBundleBuffer(verifier));
  }
 
  auto corrupt = BuildCorruptBundle();
  EXPECT_TRUE(impeller::fb::shaderbundle::ShaderBundleBufferHasIdentifier(
      corrupt->data()));
  {
    flatbuffers::Verifier verifier(corrupt->data(), corrupt->size());
    EXPECT_FALSE(
        impeller::fb::shaderbundle::VerifyShaderBundleBuffer(verifier));
  }
}

References BuildCorruptBundle(), and BuildValidEmptyBundle().