blob: 2c267e139211780ed6b1471e71ea1d43f8b4b878 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef FLUTTER_SHELL_PLATFORM_EMBEDDER_TESTS_EMBEDDER_ASSERTIONS_H_
#define FLUTTER_SHELL_PLATFORM_EMBEDDER_TESTS_EMBEDDER_ASSERTIONS_H_
#include <sstream>
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/embedder/embedder_engine.h"
#include "flutter/testing/assertions.h"
#include "gtest/gtest.h"
#include "third_party/skia/include/core/SkPoint.h"
#include "third_party/skia/include/core/SkSize.h"
//------------------------------------------------------------------------------
// Equality
//------------------------------------------------------------------------------
inline bool operator==(const FlutterPoint& a, const FlutterPoint& b) {
return flutter::testing::NumberNear(a.x, b.x) &&
flutter::testing::NumberNear(a.y, b.y);
}
inline bool operator==(const FlutterRect& a, const FlutterRect& b) {
return flutter::testing::NumberNear(a.left, b.left) &&
flutter::testing::NumberNear(a.top, b.top) &&
flutter::testing::NumberNear(a.right, b.right) &&
flutter::testing::NumberNear(a.bottom, b.bottom);
}
inline bool operator==(const FlutterSize& a, const FlutterSize& b) {
return flutter::testing::NumberNear(a.width, b.width) &&
flutter::testing::NumberNear(a.height, b.height);
}
inline bool operator==(const FlutterRoundedRect& a,
const FlutterRoundedRect& b) {
return a.rect == b.rect &&
a.upper_left_corner_radius == b.upper_left_corner_radius &&
a.upper_right_corner_radius == b.upper_right_corner_radius &&
a.lower_right_corner_radius == b.lower_right_corner_radius &&
a.lower_left_corner_radius == b.lower_left_corner_radius;
}
inline bool operator==(const FlutterTransformation& a,
const FlutterTransformation& b) {
return a.scaleX == b.scaleX && a.skewX == b.skewX && a.transX == b.transX &&
a.skewY == b.skewY && a.scaleY == b.scaleY && a.transY == b.transY &&
a.pers0 == b.pers0 && a.pers1 == b.pers1 && a.pers2 == b.pers2;
}
inline bool operator==(const FlutterOpenGLTexture& a,
const FlutterOpenGLTexture& b) {
return a.target == b.target && a.name == b.name && a.format == b.format &&
a.user_data == b.user_data &&
a.destruction_callback == b.destruction_callback;
}
inline bool operator==(const FlutterOpenGLFramebuffer& a,
const FlutterOpenGLFramebuffer& b) {
return a.target == b.target && a.name == b.name &&
a.user_data == b.user_data &&
a.destruction_callback == b.destruction_callback;
}
inline bool operator==(const FlutterMetalTexture& a,
const FlutterMetalTexture& b) {
return a.texture_id == b.texture_id && a.texture == b.texture;
}
inline bool operator==(const FlutterVulkanImage& a,
const FlutterVulkanImage& b) {
return a.image == b.image && a.format == b.format;
}
inline bool operator==(const FlutterVulkanBackingStore& a,
const FlutterVulkanBackingStore& b) {
return a.image == b.image;
}
inline bool operator==(const FlutterMetalBackingStore& a,
const FlutterMetalBackingStore& b) {
return a.texture == b.texture;
}
inline bool operator==(const FlutterOpenGLBackingStore& a,
const FlutterOpenGLBackingStore& b) {
if (!(a.type == b.type)) {
return false;
}
switch (a.type) {
case kFlutterOpenGLTargetTypeTexture:
return a.texture == b.texture;
case kFlutterOpenGLTargetTypeFramebuffer:
return a.framebuffer == b.framebuffer;
}
return false;
}
inline bool operator==(const FlutterSoftwareBackingStore& a,
const FlutterSoftwareBackingStore& b) {
return a.allocation == b.allocation && a.row_bytes == b.row_bytes &&
a.height == b.height && a.user_data == b.user_data &&
a.destruction_callback == b.destruction_callback;
}
inline bool operator==(const FlutterSoftwareBackingStore2& a,
const FlutterSoftwareBackingStore2& b) {
return a.allocation == b.allocation && a.row_bytes == b.row_bytes &&
a.height == b.height && a.user_data == b.user_data &&
a.destruction_callback == b.destruction_callback &&
a.pixel_format == b.pixel_format;
}
inline bool operator==(const FlutterBackingStore& a,
const FlutterBackingStore& b) {
if (!(a.struct_size == b.struct_size && a.user_data == b.user_data &&
a.type == b.type && a.did_update == b.did_update)) {
return false;
}
switch (a.type) {
case kFlutterBackingStoreTypeOpenGL:
return a.open_gl == b.open_gl;
case kFlutterBackingStoreTypeSoftware:
return a.software == b.software;
case kFlutterBackingStoreTypeMetal:
return a.metal == b.metal;
case kFlutterBackingStoreTypeVulkan:
return a.vulkan == b.vulkan;
case kFlutterBackingStoreTypeSoftware2:
return a.software2 == b.software2;
}
return false;
}
inline bool operator==(const FlutterPlatformViewMutation& a,
const FlutterPlatformViewMutation& b) {
if (a.type != b.type) {
return false;
}
switch (a.type) {
case kFlutterPlatformViewMutationTypeOpacity:
return flutter::testing::NumberNear(a.opacity, b.opacity);
case kFlutterPlatformViewMutationTypeClipRect:
return a.clip_rect == b.clip_rect;
case kFlutterPlatformViewMutationTypeClipRoundedRect:
return a.clip_rounded_rect == b.clip_rounded_rect;
case kFlutterPlatformViewMutationTypeTransformation:
return a.transformation == b.transformation;
}
return false;
}
inline bool operator==(const FlutterPlatformView& a,
const FlutterPlatformView& b) {
if (!(a.struct_size == b.struct_size && a.identifier == b.identifier &&
a.mutations_count == b.mutations_count)) {
return false;
}
for (size_t i = 0; i < a.mutations_count; ++i) {
if (!(*a.mutations[i] == *b.mutations[i])) {
return false;
}
}
return true;
}
inline bool operator==(const FlutterLayer& a, const FlutterLayer& b) {
if (!(a.struct_size == b.struct_size && a.type == b.type &&
a.offset == b.offset && a.size == b.size)) {
return false;
}
switch (a.type) {
case kFlutterLayerContentTypeBackingStore:
return *a.backing_store == *b.backing_store;
case kFlutterLayerContentTypePlatformView:
return *a.platform_view == *b.platform_view;
}
return false;
}
//------------------------------------------------------------------------------
// Printing
//------------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream& out, const FlutterPoint& point) {
return out << "(" << point.x << ", " << point.y << ")";
}
inline std::ostream& operator<<(std::ostream& out, const FlutterRect& r) {
return out << "LTRB (" << r.left << ", " << r.top << ", " << r.right << ", "
<< r.bottom << ")";
}
inline std::ostream& operator<<(std::ostream& out, const FlutterSize& size) {
return out << "(" << size.width << ", " << size.height << ")";
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterRoundedRect& r) {
out << "Rect: " << r.rect << ", ";
out << "Upper Left Corner Radius: " << r.upper_left_corner_radius << ", ";
out << "Upper Right Corner Radius: " << r.upper_right_corner_radius << ", ";
out << "Lower Right Corner Radius: " << r.lower_right_corner_radius << ", ";
out << "Lower Left Corner Radius: " << r.lower_left_corner_radius;
return out;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterTransformation& t) {
out << "Scale X: " << t.scaleX << ", ";
out << "Skew X: " << t.skewX << ", ";
out << "Trans X: " << t.transX << ", ";
out << "Skew Y: " << t.skewY << ", ";
out << "Scale Y: " << t.scaleY << ", ";
out << "Trans Y: " << t.transY << ", ";
out << "Pers 0: " << t.pers0 << ", ";
out << "Pers 1: " << t.pers1 << ", ";
out << "Pers 2: " << t.pers2;
return out;
}
inline std::string FlutterLayerContentTypeToString(
FlutterLayerContentType type) {
switch (type) {
case kFlutterLayerContentTypeBackingStore:
return "kFlutterLayerContentTypeBackingStore";
case kFlutterLayerContentTypePlatformView:
return "kFlutterLayerContentTypePlatformView";
}
return "Unknown";
}
inline std::string FlutterBackingStoreTypeToString(
FlutterBackingStoreType type) {
switch (type) {
case kFlutterBackingStoreTypeOpenGL:
return "kFlutterBackingStoreTypeOpenGL";
case kFlutterBackingStoreTypeSoftware:
return "kFlutterBackingStoreTypeSoftware";
case kFlutterBackingStoreTypeMetal:
return "kFlutterBackingStoreTypeMetal";
case kFlutterBackingStoreTypeVulkan:
return "kFlutterBackingStoreTypeVulkan";
case kFlutterBackingStoreTypeSoftware2:
return "kFlutterBackingStoreTypeSoftware2";
}
return "Unknown";
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterOpenGLTexture& item) {
return out << "(FlutterOpenGLTexture) Target: 0x" << std::hex << item.target
<< std::dec << " Name: " << item.name << " Format: " << item.format
<< " User Data: " << item.user_data << " Destruction Callback: "
<< reinterpret_cast<void*>(item.destruction_callback);
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterOpenGLFramebuffer& item) {
return out << "(FlutterOpenGLFramebuffer) Target: 0x" << std::hex
<< item.target << std::dec << " Name: " << item.name
<< " User Data: " << item.user_data << " Destruction Callback: "
<< reinterpret_cast<void*>(item.destruction_callback);
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterMetalTexture& item) {
return out << "(FlutterMetalTexture) Texture ID: " << std::hex
<< item.texture_id << std::dec << " Handle: 0x" << std::hex
<< item.texture;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterVulkanImage& item) {
return out << "(FlutterVulkanTexture) Image Handle: " << std::hex
<< item.image << std::dec << " Format: " << item.format;
}
inline std::string FlutterPlatformViewMutationTypeToString(
FlutterPlatformViewMutationType type) {
switch (type) {
case kFlutterPlatformViewMutationTypeOpacity:
return "kFlutterPlatformViewMutationTypeOpacity";
case kFlutterPlatformViewMutationTypeClipRect:
return "kFlutterPlatformViewMutationTypeClipRect";
case kFlutterPlatformViewMutationTypeClipRoundedRect:
return "kFlutterPlatformViewMutationTypeClipRoundedRect";
case kFlutterPlatformViewMutationTypeTransformation:
return "kFlutterPlatformViewMutationTypeTransformation";
}
return "Unknown";
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterPlatformViewMutation& m) {
out << "(FlutterPlatformViewMutation) Type: "
<< FlutterPlatformViewMutationTypeToString(m.type) << " ";
switch (m.type) {
case kFlutterPlatformViewMutationTypeOpacity:
out << "Opacity: " << m.opacity;
case kFlutterPlatformViewMutationTypeClipRect:
out << "Clip Rect: " << m.clip_rect;
case kFlutterPlatformViewMutationTypeClipRoundedRect:
out << "Clip Rounded Rect: " << m.clip_rounded_rect;
case kFlutterPlatformViewMutationTypeTransformation:
out << "Transformation: " << m.transformation;
}
return out;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterPlatformView& platform_view) {
out << "["
<< "(FlutterPlatformView) Struct Size: " << platform_view.struct_size
<< " Identifier: " << platform_view.identifier
<< " Mutations Count: " << platform_view.mutations_count;
if (platform_view.mutations_count > 0) {
out << std::endl;
for (size_t i = 0; i < platform_view.mutations_count; i++) {
out << "Mutation " << i << ": " << *platform_view.mutations[i]
<< std::endl;
}
}
out << "]";
return out;
}
inline std::string FlutterOpenGLTargetTypeToString(
FlutterOpenGLTargetType type) {
switch (type) {
case kFlutterOpenGLTargetTypeTexture:
return "kFlutterOpenGLTargetTypeTexture";
case kFlutterOpenGLTargetTypeFramebuffer:
return "kFlutterOpenGLTargetTypeFramebuffer";
}
return "Unknown";
}
inline std::string FlutterSoftwarePixelFormatToString(
FlutterSoftwarePixelFormat pixfmt) {
switch (pixfmt) {
case kGray8:
return "kGray8";
case kRGB565:
return "kRGB565";
case kRGBA4444:
return "kRGBA4444";
case kRGBA8888:
return "kRGBA8888";
case kRGBX8888:
return "kRGBX8888";
case kBGRA8888:
return "kBGRA8888";
case kNative32:
return "kNative32";
default:
FML_LOG(ERROR) << "Invalid software rendering pixel format";
}
return "Unknown";
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterOpenGLBackingStore& item) {
out << "(FlutterOpenGLBackingStore) Type: "
<< FlutterOpenGLTargetTypeToString(item.type) << " ";
switch (item.type) {
case kFlutterOpenGLTargetTypeTexture:
out << item.texture;
break;
case kFlutterOpenGLTargetTypeFramebuffer:
out << item.framebuffer;
break;
}
return out;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterSoftwareBackingStore& item) {
return out << "(FlutterSoftwareBackingStore) Allocation: " << item.allocation
<< " Row Bytes: " << item.row_bytes << " Height: " << item.height
<< " User Data: " << item.user_data << " Destruction Callback: "
<< reinterpret_cast<void*>(item.destruction_callback);
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterMetalBackingStore& item) {
return out << "(FlutterMetalBackingStore) Texture: " << item.texture;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterVulkanBackingStore& item) {
return out << "(FlutterVulkanBackingStore) Image: " << item.image;
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterSoftwareBackingStore2& item) {
return out << "(FlutterSoftwareBackingStore2) Allocation: " << item.allocation
<< " Row Bytes: " << item.row_bytes << " Height: " << item.height
<< " User Data: " << item.user_data << " Destruction Callback: "
<< reinterpret_cast<void*>(item.destruction_callback)
<< " Pixel Format: "
<< FlutterSoftwarePixelFormatToString(item.pixel_format);
}
inline std::ostream& operator<<(std::ostream& out,
const FlutterBackingStore& backing_store) {
out << "(FlutterBackingStore) Struct size: " << backing_store.struct_size
<< " User Data: " << backing_store.user_data
<< " Type: " << FlutterBackingStoreTypeToString(backing_store.type)
<< " ";
switch (backing_store.type) {
case kFlutterBackingStoreTypeOpenGL:
out << backing_store.open_gl;
break;
case kFlutterBackingStoreTypeSoftware:
out << backing_store.software;
break;
case kFlutterBackingStoreTypeMetal:
out << backing_store.metal;
break;
case kFlutterBackingStoreTypeVulkan:
out << backing_store.vulkan;
break;
case kFlutterBackingStoreTypeSoftware2:
out << backing_store.software2;
break;
}
return out;
}
inline std::ostream& operator<<(std::ostream& out, const FlutterLayer& layer) {
out << "(Flutter Layer) Struct size: " << layer.struct_size
<< " Type: " << FlutterLayerContentTypeToString(layer.type);
switch (layer.type) {
case kFlutterLayerContentTypeBackingStore:
out << *layer.backing_store;
break;
case kFlutterLayerContentTypePlatformView:
out << *layer.platform_view;
break;
}
return out << " Offset: " << layer.offset << " Size: " << layer.size;
}
//------------------------------------------------------------------------------
// Factories and Casts
//------------------------------------------------------------------------------
inline FlutterPoint FlutterPointMake(double x, double y) {
FlutterPoint point = {};
point.x = x;
point.y = y;
return point;
}
inline FlutterSize FlutterSizeMake(double width, double height) {
FlutterSize size = {};
size.width = width;
size.height = height;
return size;
}
inline FlutterSize FlutterSizeMake(const SkVector& vector) {
FlutterSize size = {};
size.width = vector.x();
size.height = vector.y();
return size;
}
inline FlutterTransformation FlutterTransformationMake(const SkMatrix& matrix) {
FlutterTransformation transformation = {};
transformation.scaleX = matrix[SkMatrix::kMScaleX];
transformation.skewX = matrix[SkMatrix::kMSkewX];
transformation.transX = matrix[SkMatrix::kMTransX];
transformation.skewY = matrix[SkMatrix::kMSkewY];
transformation.scaleY = matrix[SkMatrix::kMScaleY];
transformation.transY = matrix[SkMatrix::kMTransY];
transformation.pers0 = matrix[SkMatrix::kMPersp0];
transformation.pers1 = matrix[SkMatrix::kMPersp1];
transformation.pers2 = matrix[SkMatrix::kMPersp2];
return transformation;
}
inline SkMatrix SkMatrixMake(const FlutterTransformation& xformation) {
return SkMatrix::MakeAll(xformation.scaleX, //
xformation.skewX, //
xformation.transX, //
xformation.skewY, //
xformation.scaleY, //
xformation.transY, //
xformation.pers0, //
xformation.pers1, //
xformation.pers2 //
);
}
inline flutter::EmbedderEngine* ToEmbedderEngine(const FlutterEngine& engine) {
return reinterpret_cast<flutter::EmbedderEngine*>(engine);
}
inline FlutterRect FlutterRectMake(const SkRect& rect) {
FlutterRect r = {};
r.left = rect.left();
r.top = rect.top();
r.right = rect.right();
r.bottom = rect.bottom();
return r;
}
inline FlutterRect FlutterRectMakeLTRB(double l, double t, double r, double b) {
FlutterRect rect = {};
rect.left = l;
rect.top = t;
rect.right = r;
rect.bottom = b;
return rect;
}
inline SkRect SkRectMake(const FlutterRect& rect) {
return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
}
inline FlutterRoundedRect FlutterRoundedRectMake(const SkRRect& rect) {
FlutterRoundedRect r = {};
r.rect = FlutterRectMake(rect.rect());
r.upper_left_corner_radius =
FlutterSizeMake(rect.radii(SkRRect::Corner::kUpperLeft_Corner));
r.upper_right_corner_radius =
FlutterSizeMake(rect.radii(SkRRect::Corner::kUpperRight_Corner));
r.lower_right_corner_radius =
FlutterSizeMake(rect.radii(SkRRect::Corner::kLowerRight_Corner));
r.lower_left_corner_radius =
FlutterSizeMake(rect.radii(SkRRect::Corner::kLowerLeft_Corner));
return r;
}
#endif // FLUTTER_SHELL_PLATFORM_EMBEDDER_TESTS_EMBEDDER_ASSERTIONS_H_