ui/color/color_transform_unittest.cc

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/color/color_transform.h"

#include "testing/gtest/include/gtest/gtest.h"
#include "ui/color/color_mixer.h"
#include "ui/color/color_recipe.h"
#include "ui/color/color_test_ids.h"
#include "ui/gfx/color_palette.h"

namespace ui {
namespace {

// Tests initialization with an SkColor value.
TEST(ColorRecipeTest, TestColorRecipeInitialization) {
  const auto verify_initialization = [&](SkColor color) {
    ColorTransform transform = color;
    EXPECT_EQ(color, transform.Run(SK_ColorBLACK, ColorMixer()));
  };
  verify_initialization(SK_ColorBLUE);
  verify_initialization(SK_ColorRED);
  verify_initialization(SK_ColorGREEN);
}

// Tests that AlphaBlend() produces a transform that blends its inputs.
TEST(ColorTransformTest, AlphaBlend) {
  const auto blend = [](SkAlpha alpha) {
    const ColorTransform transform =
        AlphaBlend(SK_ColorWHITE, SK_ColorBLACK, alpha);
    return transform.Run(gfx::kPlaceholderColor, ColorMixer());
  };
  EXPECT_EQ(SK_ColorBLACK, blend(SK_AlphaTRANSPARENT));
  EXPECT_EQ(SK_ColorWHITE, blend(SK_AlphaOPAQUE));
  EXPECT_EQ(SK_ColorGRAY, blend(SkColorGetR(SK_ColorGRAY)));
}

// Tests that BlendForMinContrast(), with the default args, produces a transform
// that blends its foreground color to produce readable contrast against its
// background color.
TEST(ColorTransformTest, BlendForMinContrast) {
  const ColorTransform transform =
      BlendForMinContrast(FromTransformInput(), kColorTest0);
  constexpr SkColor kBackground = SK_ColorWHITE;
  ColorMixer mixer;
  mixer[kColorTest0] = {kBackground};
  const auto verify_contrast = [&](SkColor input) {
    EXPECT_GE(
        color_utils::GetContrastRatio(transform.Run(input, mixer), kBackground),
        color_utils::kMinimumReadableContrastRatio);
  };
  verify_contrast(SK_ColorBLACK);
  verify_contrast(SK_ColorWHITE);
  verify_contrast(SK_ColorRED);
}

// Tests that BlendForMinContrast() supports optional args, which can be used to
// blend toward a specific foreground color and with a specific minimum contrast
// ratio.
TEST(ColorTransformTest, BlendForMinContrastOptionalArgs) {
  constexpr float kMinContrast = 6.0f;
  const ColorTransform transform = BlendForMinContrast(
      FromTransformInput(), kColorTest0, kColorTest1, kMinContrast);
  constexpr SkColor kBackground = SK_ColorWHITE;
  ColorMixer mixer;
  mixer[kColorTest0] = {kBackground};
  mixer[kColorTest1] = {gfx::kGoogleBlue900};
  const auto verify_contrast = [&](SkColor input) {
    EXPECT_GE(
        color_utils::GetContrastRatio(transform.Run(input, mixer), kBackground),
        kMinContrast);
  };
  verify_contrast(SK_ColorBLACK);
  verify_contrast(SK_ColorWHITE);
  verify_contrast(gfx::kGoogleBlue500);
}

// Tests that BlendForMinContrastWithSelf() produces a transform that blends its
// input color towards the color with max contrast.
TEST(ColorTransformTest, BlendForMinContrastWithSelf) {
  constexpr float kContrastRatio = 2;
  const ColorTransform transform =
      BlendForMinContrastWithSelf(FromTransformInput(), kContrastRatio);
  const auto verify_blend = [&](SkColor input) {
    const SkColor target = color_utils::GetColorWithMaxContrast(input);
    EXPECT_LT(color_utils::GetContrastRatio(transform.Run(input, ColorMixer()),
                                            target),
              color_utils::GetContrastRatio(input, target));
  };
  verify_blend(SK_ColorBLACK);
  verify_blend(SK_ColorWHITE);
  verify_blend(SK_ColorRED);
}

// Tests that BlendTowardMaxContrast() produces a transform that blends its
// input color towards the color with max contrast.
TEST(ColorTransformTest, BlendTowardMaxContrast) {
  constexpr SkAlpha kAlpha = 0x20;
  const ColorTransform transform =
      BlendTowardMaxContrast(FromTransformInput(), kAlpha);
  const auto verify_blend = [&](SkColor input) {
    const SkColor target = color_utils::GetColorWithMaxContrast(input);
    EXPECT_LT(color_utils::GetContrastRatio(transform.Run(input, ColorMixer()),
                                            target),
              color_utils::GetContrastRatio(input, target));
  };
  verify_blend(SK_ColorBLACK);
  verify_blend(SK_ColorWHITE);
  verify_blend(SK_ColorRED);
}

// Tests that ContrastInvert() produces a transform that outputs a color with at
// least as much contrast, but against the opposite endpoint.
TEST(ColorTransformTest, ContrastInvert) {
  const ColorTransform transform = ContrastInvert(FromTransformInput());
  const auto verify_invert = [&](SkColor input) {
    const SkColor far_endpoint = color_utils::GetColorWithMaxContrast(input);
    const SkColor near_endpoint =
        color_utils::GetColorWithMaxContrast(far_endpoint);
    EXPECT_GE(color_utils::GetContrastRatio(transform.Run(input, ColorMixer()),
                                            near_endpoint),
              color_utils::GetContrastRatio(input, far_endpoint));
  };
  verify_invert(gfx::kGoogleGrey900);
  verify_invert(SK_ColorWHITE);
  verify_invert(SK_ColorRED);
  verify_invert(gfx::kGoogleBlue500);
}

// Tests that DeriveDefaultIconColor() produces a transform that changes its
// input color.
TEST(ColorTransformTest, DeriveDefaultIconColor) {
  const ColorTransform transform = DeriveDefaultIconColor(FromTransformInput());
  const auto verify_derive = [&](SkColor input) {
    EXPECT_NE(input, transform.Run(input, ColorMixer()));
  };
  verify_derive(SK_ColorBLACK);
  verify_derive(SK_ColorWHITE);
  verify_derive(SK_ColorRED);
}

// Tests that initializing a transform from a color produces a transform that
// ignores the input color and always outputs a specified SkColor.
TEST(ColorTransformTest, FromColor) {
  constexpr SkColor kOutput = SK_ColorGREEN;
  const ColorTransform transform = kOutput;
  const auto verify_color = [&](SkColor input) {
    EXPECT_EQ(kOutput, transform.Run(input, ColorMixer()));
  };
  verify_color(SK_ColorBLACK);
  verify_color(SK_ColorWHITE);
  verify_color(SK_ColorRED);
}

// Tests that a transform created from a ColorId produces a transform that
// ignores the input color and always outputs a specified result color.
TEST(ColorTransformTest, FromColorId) {
  const ColorTransform transform = {kColorTest0};
  constexpr SkColor kTest1Color = SK_ColorRED;
  ColorMixer mixer;
  mixer[kColorTest0] = {kColorTest1};
  mixer[kColorTest1] = {kTest1Color};
  const auto verify_color = [&](SkColor input) {
    EXPECT_EQ(kTest1Color, transform.Run(input, mixer));
  };
  verify_color(SK_ColorBLACK);
  verify_color(SK_ColorWHITE);
  verify_color(SK_ColorRED);
}  // namespace

// Tests that FromTransformInput() returns its input color unmodified.
TEST(ColorTransformTest, FromTransformInput) {
  const ColorTransform transform = FromTransformInput();
  const auto verify_color = [&](SkColor input) {
    EXPECT_EQ(input, transform.Run(input, ColorMixer()));
  };
  verify_color(SK_ColorBLACK);
  verify_color(SK_ColorWHITE);
  verify_color(SK_ColorRED);
}  // namespace

// Tests that GetColorWithMaxContrast() produces a transform that changes white
// to the darkest color.
TEST(ColorTransformTest, GetColorWithMaxContrast) {
  const ColorTransform transform =
      GetColorWithMaxContrast(FromTransformInput());
  constexpr SkColor kNewDarkestColor = gfx::kGoogleGrey500;
  const SkColor default_darkest_color =
      color_utils::SetDarkestColorForTesting(kNewDarkestColor);
  constexpr SkColor kLightestColor = SK_ColorWHITE;
  EXPECT_EQ(kNewDarkestColor, transform.Run(kLightestColor, ColorMixer()));
  color_utils::SetDarkestColorForTesting(default_darkest_color);
  EXPECT_EQ(default_darkest_color, transform.Run(kLightestColor, ColorMixer()));
}

// Tests that GetResultingPaintColor() produces a transform that composites
// opaquely.
TEST(ColorTransformTest, GetResultingPaintColor) {
  const ColorTransform transform =
      GetResultingPaintColor(FromTransformInput(), kColorTest0);
  constexpr SkColor kBackground = SK_ColorWHITE;
  ColorMixer mixer;
  mixer[kColorTest0] = {kBackground};
  EXPECT_EQ(SK_ColorBLACK, transform.Run(SK_ColorBLACK, mixer));
  EXPECT_EQ(kBackground, transform.Run(SK_ColorTRANSPARENT, mixer));
  EXPECT_EQ(color_utils::AlphaBlend(SK_ColorBLACK, kBackground, SkAlpha{0x80}),
            transform.Run(SkColorSetA(SK_ColorBLACK, 0x80), mixer));
}

// Tests that SelectBasedOnDarkInput() produces a transform that toggles between
// inputs based on whether the input color is dark.
TEST(ColorTransformTest, SelectBasedOnDarkInput) {
  constexpr SkColor kDarkOutput = SK_ColorGREEN;
  constexpr SkColor kLightOutput = SK_ColorRED;
  const ColorTransform transform =
      SelectBasedOnDarkInput(FromTransformInput(), kDarkOutput, kLightOutput);
  EXPECT_EQ(kDarkOutput, transform.Run(SK_ColorBLACK, ColorMixer()));
  EXPECT_EQ(kLightOutput, transform.Run(SK_ColorWHITE, ColorMixer()));
  EXPECT_EQ(kDarkOutput, transform.Run(SK_ColorBLUE, ColorMixer()));
  EXPECT_EQ(kLightOutput, transform.Run(SK_ColorRED, ColorMixer()));
}

// Tests that SetAlpha() produces a transform that sets its input's alpha.
TEST(ColorTransformTest, SetAlpha) {
  constexpr SkAlpha kAlpha = 0x20;
  const ColorTransform transform = SetAlpha(FromTransformInput(), kAlpha);
  for (auto color : {SK_ColorBLACK, SK_ColorRED, SK_ColorTRANSPARENT})
    EXPECT_EQ(SkColorSetA(color, kAlpha), transform.Run(color, ColorMixer()));
}

// Tests that PickGoogleColor() produces a transform that picks a Google color
// with appropriate contrast against the specified background.
TEST(ColorTransformTest, PickGoogleColor) {
  constexpr SkColor kBackground = gfx::kGoogleGrey600;
  constexpr float kMinContrast = 2.1f;
  const ColorTransform transform =
      PickGoogleColor(FromTransformInput(), kBackground, kMinContrast);
  EXPECT_EQ(gfx::kGoogleRed900, transform.Run(SK_ColorRED, ColorMixer()));
  EXPECT_EQ(gfx::kGoogleGreen100, transform.Run(SK_ColorGREEN, ColorMixer()));
  EXPECT_EQ(gfx::kGoogleBlue900, transform.Run(SK_ColorBLUE, ColorMixer()));
}

// Tests that PickGoogleColorTwoBackgrounds() produces a transform that picks a
// Google color with appropriate contrast against both specified backgrounds.
TEST(ColorTransformTest, PickGoogleColorTwoBackgrounds) {
  constexpr SkColor kBackgroundA = gfx::kGoogleGrey800;
  constexpr SkColor kBackgroundB = gfx::kGoogleGrey400;
  constexpr float kMinContrast = 1.5f;
  const ColorTransform transform = PickGoogleColorTwoBackgrounds(
      FromTransformInput(), kBackgroundA, kBackgroundB, kMinContrast);
  EXPECT_EQ(gfx::kGoogleRed500, transform.Run(SK_ColorRED, ColorMixer()));
  EXPECT_EQ(gfx::kGoogleGreen050, transform.Run(SK_ColorGREEN, ColorMixer()));
  EXPECT_EQ(gfx::kGoogleBlue800, transform.Run(SK_ColorBLUE, ColorMixer()));
}

// Tests that HSLShift() produces a transform that applies the given HSL shift
// to the given input color.
TEST(ColorTransformTest, HSLShift) {
  constexpr color_utils::HSL kHsl = {0.2, 0.3, 0.4};
  const ColorTransform transform = HSLShift(FromTransformInput(), kHsl);
  const auto verify_color = [&](SkColor input) {
    EXPECT_EQ(color_utils::HSLShift(input, kHsl),
              transform.Run(input, ColorMixer()));
  };
  verify_color(SK_ColorBLACK);
  verify_color(gfx::kGoogleGrey600);
  verify_color(SK_ColorWHITE);
}

}  // namespace
}  // namespace ui