ash / style / ash_color_mixer_unittest.cc [blame]

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

#include "ash/style/ash_color_mixer.h"

#include <ostream>

#include "testing/gtest/include/gtest/gtest-param-test.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"
#include "ui/color/color_provider.h"
#include "ui/color/color_provider_key.h"
#include "ui/color/color_provider_utils.h"
#include "ui/color/ref_color_mixer.h"
#include "ui/gfx/color_palette.h"

namespace {

struct ColorsTestCase {
  ui::ColorId color_id;
  SkColor expected_color;
};

// Returns a key with reasonable values.
ui::ColorProviderKey MakeColorProviderKey(SkColor seed_color) {
  ui::ColorProviderKey key;
  key.user_color = seed_color;
  key.color_mode = ui::ColorProviderKey::ColorMode::kLight;
  return key;
}

// Initialize ColorProvider for a given key.
void InitializeColorProvider(const ui::ColorProviderKey& key,
                             ui::ColorProvider& color_provider) {
  ui::AddRefColorMixer(&color_provider, key);
  // Roughly mimics the ColorMixer configuration for Ash.
  ash::AddCrosStylesColorMixer(&color_provider, key);
  ash::AddAshColorMixer(&color_provider, key);
}

// Initializes the `color_provider` with `seed_color` and the relevant
// ColorMixers.
void SetUpColorProvider(ui::ColorProvider& color_provider, SkColor seed_color) {
  auto key = MakeColorProviderKey(seed_color);
  InitializeColorProvider(key, color_provider);
}

class AshColorMixerTest : public testing::TestWithParam<ColorsTestCase> {
 public:
  AshColorMixerTest() = default;

  void SetUp() override {
    // Hue angle 217 degrees.
    SkColor seed_color = gfx::kGoogleBlue400;
    SetUpColorProvider(color_provider_, seed_color);
  }

  const ui::ColorProvider& color_provider() { return color_provider_; }

 private:
  ui::ColorProvider color_provider_;
};

// Provides nicer logging for mismatched colors.
testing::AssertionResult AssertColorsMatch(const char* m_expr,
                                           const char* n_expr,
                                           SkColor m,
                                           SkColor n) {
  if (m == n) {
    return testing::AssertionSuccess();
  }

  return testing::AssertionFailure()
         << ui::SkColorName(m) << " (actual) and " << ui::SkColorName(n)
         << " (expected) do not match";
}

// Tests that one set of harmonized colors are correct.
TEST_P(AshColorMixerTest, HarmonizedColors) {
  const auto& test_case = GetParam();
  // Prints the color name as the CSS identifier for easier debugging.
  EXPECT_PRED_FORMAT2(AssertColorsMatch,
                      color_provider().GetColor(test_case.color_id),
                      test_case.expected_color)
      << " for " << cros_tokens::ColorIdName(test_case.color_id);
}

INSTANTIATE_TEST_SUITE_P(
    ColorTests,
    AshColorMixerTest,
    testing::ValuesIn<ColorsTestCase>({
        // Green
        {cros_tokens::kCrosRefGreen0, SkColorSetRGB(0, 0, 0)},
        {cros_tokens::kCrosRefGreen10, SkColorSetRGB(0, 33, 14)},
        {cros_tokens::kCrosRefGreen20, SkColorSetRGB(0, 57, 28)},
        {cros_tokens::kCrosRefGreen30, SkColorSetRGB(0, 82, 43)},
        {cros_tokens::kCrosRefGreen40, SkColorSetRGB(0, 109, 59)},
        {cros_tokens::kCrosRefGreen50, SkColorSetRGB(0, 137, 76)},
        {cros_tokens::kCrosRefGreen60, SkColorSetRGB(47, 164, 99)},
        {cros_tokens::kCrosRefGreen70, SkColorSetRGB(79, 192, 123)},
        {cros_tokens::kCrosRefGreen80, SkColorSetRGB(109, 220, 148)},
        {cros_tokens::kCrosRefGreen90, SkColorSetRGB(137, 249, 175)},
        {cros_tokens::kCrosRefGreen95, SkColorSetRGB(194, 255, 208)},
        {cros_tokens::kCrosRefGreen99, SkColorSetRGB(245, 255, 243)},
        {cros_tokens::kCrosRefGreen100, SkColorSetRGB(255, 255, 255)},

        // Red
        {cros_tokens::kCrosRefRed0, SkColorSetRGB(0, 0, 0)},
        {cros_tokens::kCrosRefRed10, SkColorSetRGB(58, 11, 0)},
        {cros_tokens::kCrosRefRed20, SkColorSetRGB(94, 23, 0)},
        {cros_tokens::kCrosRefRed30, SkColorSetRGB(133, 36, 0)},
        {cros_tokens::kCrosRefRed40, SkColorSetRGB(171, 53, 8)},
        {cros_tokens::kCrosRefRed50, SkColorSetRGB(205, 77, 34)},
        {cros_tokens::kCrosRefRed60, SkColorSetRGB(239, 102, 56)},
        {cros_tokens::kCrosRefRed70, SkColorSetRGB(255, 139, 102)},
        {cros_tokens::kCrosRefRed80, SkColorSetRGB(255, 181, 158)},
        {cros_tokens::kCrosRefRed90, SkColorSetRGB(255, 219, 208)},
        {cros_tokens::kCrosRefRed95, SkColorSetRGB(255, 237, 232)},
        {cros_tokens::kCrosRefRed99, SkColorSetRGB(255, 251, 255)},
        {cros_tokens::kCrosRefRed100, SkColorSetRGB(255, 255, 255)},

        // Yellow
        {cros_tokens::kCrosRefYellow0, SkColorSetRGB(0, 0, 0)},
        {cros_tokens::kCrosRefYellow10, SkColorSetRGB(37, 26, 0)},
        {cros_tokens::kCrosRefYellow20, SkColorSetRGB(63, 46, 0)},
        {cros_tokens::kCrosRefYellow30, SkColorSetRGB(90, 67, 0)},
        {cros_tokens::kCrosRefYellow40, SkColorSetRGB(119, 90, 0)},
        {cros_tokens::kCrosRefYellow50, SkColorSetRGB(150, 114, 0)},
        {cros_tokens::kCrosRefYellow60, SkColorSetRGB(181, 138, 0)},
        {cros_tokens::kCrosRefYellow70, SkColorSetRGB(214, 164, 0)},
        {cros_tokens::kCrosRefYellow80, SkColorSetRGB(247, 190, 0)},
        {cros_tokens::kCrosRefYellow90, SkColorSetRGB(255, 223, 153)},
        {cros_tokens::kCrosRefYellow95, SkColorSetRGB(255, 239, 210)},
        {cros_tokens::kCrosRefYellow99, SkColorSetRGB(255, 251, 255)},
        {cros_tokens::kCrosRefYellow100, SkColorSetRGB(255, 255, 255)},

        // Blue
        {cros_tokens::kCrosRefBlue0, SkColorSetRGB(0, 0, 0)},
        {cros_tokens::kCrosRefBlue10, SkColorSetRGB(0, 31, 39)},
        {cros_tokens::kCrosRefBlue20, SkColorSetRGB(0, 54, 66)},
        {cros_tokens::kCrosRefBlue30, SkColorSetRGB(0, 78, 95)},
        {cros_tokens::kCrosRefBlue40, SkColorSetRGB(0, 103, 125)},
        {cros_tokens::kCrosRefBlue50, SkColorSetRGB(0, 130, 157)},
        {cros_tokens::kCrosRefBlue60, SkColorSetRGB(55, 156, 184)},
        {cros_tokens::kCrosRefBlue70, SkColorSetRGB(87, 183, 212)},
        {cros_tokens::kCrosRefBlue80, SkColorSetRGB(117, 211, 240)},
        {cros_tokens::kCrosRefBlue90, SkColorSetRGB(179, 235, 255)},
        {cros_tokens::kCrosRefBlue95, SkColorSetRGB(219, 245, 255)},
        {cros_tokens::kCrosRefBlue99, SkColorSetRGB(249, 253, 255)},
        {cros_tokens::kCrosRefBlue100, SkColorSetRGB(255, 255, 255)},
    }));

struct HuesTestCase {
  SkColor seed_color;
  ColorsTestCase colors;
};

class AshColorMixerHueAngleTest : public testing::TestWithParam<HuesTestCase> {
 public:
  AshColorMixerHueAngleTest() = default;

  void SetUp() override {
    color_provider_ = std::make_unique<ui::ColorProvider>();
  }

  void TearDown() override { color_provider_.reset(); }

  ui::ColorProvider& color_provider() { return *color_provider_; }

 private:
  std::unique_ptr<ui::ColorProvider> color_provider_;
};

TEST_P(AshColorMixerHueAngleTest, Hues) {
  const HuesTestCase& test_case = GetParam();
  SetUpColorProvider(color_provider(), test_case.seed_color);

  const ColorsTestCase& colors = test_case.colors;
  EXPECT_PRED_FORMAT2(AssertColorsMatch,
                      color_provider().GetColor(colors.color_id),
                      colors.expected_color)
      << " using seed " << ui::SkColorName(test_case.seed_color) << " for "
      << cros_tokens::ColorIdName(colors.color_id);
}

constexpr SkColor kRed = SkColorSetRGB(0xFF, 0x00, 0x00);      // Hue 0
constexpr SkColor kMustard = SkColorSetRGB(0xFF, 0xD5, 0x00);  // Hue 50
constexpr SkColor kTeal = SkColorSetRGB(0x00, 0xFF, 0xAA);     // Hue 160
constexpr SkColor kOffRed = SkColorSetRGB(0xFF, 0x00, 0x04);   // Hue 359

INSTANTIATE_TEST_SUITE_P(
    HueTests,
    AshColorMixerHueAngleTest,
    testing::ValuesIn<HuesTestCase>({
        // Hue angle 0
        {kRed, {cros_tokens::kCrosRefGreen40, SkColorSetRGB(46, 108, 0)}},
        {kRed, {cros_tokens::kCrosRefRed40, SkColorSetRGB(179, 42, 25)}},
        {kRed, {cros_tokens::kCrosRefYellow40, SkColorSetRGB(134, 83, 0)}},
        {kRed, {cros_tokens::kCrosRefBlue40, SkColorSetRGB(63, 90, 169)}},
        {kRed,
         {cros_tokens::kCrosRefSparkleAnalog40,
          SkColorSetRGB(0x6f, 0x46, 0xb9)}},
        {kRed,
         {cros_tokens::kCrosRefSparkleMuted40,
          SkColorSetRGB(0x5f, 0x57, 0x8f)}},
        {kRed,
         {cros_tokens::kCrosRefSparkleComplement40,
          SkColorSetRGB(0x40, 0x67, 0x43)}},

        // Hue angle 50
        {kMustard, {cros_tokens::kCrosRefGreen40, SkColorSetRGB(26, 109, 0)}},
        {kMustard, {cros_tokens::kCrosRefRed40, SkColorSetRGB(163, 62, 0)}},
        {kMustard, {cros_tokens::kCrosRefYellow40, SkColorSetRGB(121, 89, 0)}},
        {kMustard, {cros_tokens::kCrosRefBlue40, SkColorSetRGB(0, 103, 125)}},
        {kMustard,
         {cros_tokens::kCrosRefSparkleAnalog40,
          SkColorSetRGB(0x4a, 0x51, 0xc3)}},
        {kMustard,
         {cros_tokens::kCrosRefSparkleMuted40,
          SkColorSetRGB(0x4c, 0x5c, 0x90)}},
        {kMustard,
         {cros_tokens::kCrosRefSparkleComplement40,
          SkColorSetRGB(0x30, 0x68, 0x54)}},

        // Hue angel 160
        {kTeal, {cros_tokens::kCrosRefGreen40, SkColorSetRGB(0, 109, 59)}},
        {kTeal, {cros_tokens::kCrosRefRed40, SkColorSetRGB(171, 53, 8)}},
        {kTeal, {cros_tokens::kCrosRefYellow40, SkColorSetRGB(119, 90, 0)}},
        {kTeal, {cros_tokens::kCrosRefBlue40, SkColorSetRGB(0, 103, 125)}},
        {kTeal,
         {cros_tokens::kCrosRefSparkleAnalog40,
          SkColorSetRGB(0x6f, 0x46, 0xb9)}},
        {kTeal,
         {cros_tokens::kCrosRefSparkleMuted40,
          SkColorSetRGB(0x5f, 0x57, 0x8f)}},
        {kTeal,
         {cros_tokens::kCrosRefSparkleComplement40,
          SkColorSetRGB(0x40, 0x67, 0x43)}},

        // Hue angle 359
        {kOffRed, {cros_tokens::kCrosRefGreen40, SkColorSetRGB(0, 108, 74)}},
        {kOffRed, {cros_tokens::kCrosRefRed40, SkColorSetRGB(189, 8, 55)}},
        {kOffRed, {cros_tokens::kCrosRefYellow40, SkColorSetRGB(130, 85, 0)}},
        {kOffRed, {cros_tokens::kCrosRefBlue40, SkColorSetRGB(63, 90, 169)}},
        {kOffRed,
         {cros_tokens::kCrosRefSparkleAnalog40,
          SkColorSetRGB(0x6f, 0x46, 0xb9)}},
        {kOffRed,
         {cros_tokens::kCrosRefSparkleMuted40,
          SkColorSetRGB(0x5f, 0x57, 0x8f)}},
        {kOffRed,
         {cros_tokens::kCrosRefSparkleComplement40,
          SkColorSetRGB(0x40, 0x67, 0x43)}},
    }));

class AshColorGamingColorsTest : public testing::Test {
 public:
  AshColorGamingColorsTest() = default;

  void SetUp() override {
    color_provider_ = std::make_unique<ui::ColorProvider>();
  }

  void TearDown() override { color_provider_.reset(); }

  ui::ColorProvider& color_provider() { return *color_provider_; }

  void SetUpColorProvider(SkColor seed_color,
                          ui::ColorProviderKey::SchemeVariant scheme,
                          ui::ColorProviderKey::ColorMode color_mode) {
    ui::ColorProviderKey key;
    key.user_color = seed_color;
    key.color_mode = color_mode;
    key.scheme_variant = scheme;

    InitializeColorProvider(key, color_provider());
  }

 private:
  std::unique_ptr<ui::ColorProvider> color_provider_;
};

// A random color
constexpr SkColor kGamingTestSeed = SkColorSetRGB(17, 220, 96);

TEST_F(AshColorGamingColorsTest, MatchesVibrant) {
  SetUpColorProvider(kGamingTestSeed,
                     ui::ColorProviderKey::SchemeVariant::kVibrant,
                     ui::ColorProviderKey::ColorMode::kLight);
  EXPECT_PRED_FORMAT2(
      AssertColorsMatch,
      color_provider().GetColor(
          cros_tokens::kCrosSysGamingControlButtonDefault),
      color_provider().GetColor(cros_tokens::kCrosRefPrimary40));
  EXPECT_PRED_FORMAT2(
      AssertColorsMatch,
      color_provider().GetColor(cros_tokens::kCrosSysGamingControlButtonHover),
      color_provider().GetColor(cros_tokens::kCrosRefPrimary50));
  EXPECT_PRED_FORMAT2(
      AssertColorsMatch,
      color_provider().GetColor(
          cros_tokens::kCrosSysGamingControlButtonBorderHover),
      color_provider().GetColor(cros_tokens::kCrosRefPrimary80));
}

TEST_F(AshColorGamingColorsTest, DoesNotMatchTonal) {
  SetUpColorProvider(kGamingTestSeed,
                     ui::ColorProviderKey::SchemeVariant::kTonalSpot,
                     ui::ColorProviderKey::ColorMode::kLight);

  EXPECT_NE(color_provider().GetColor(
                cros_tokens::kCrosSysGamingControlButtonDefault),
            color_provider().GetColor(cros_tokens::kCrosRefPrimary40));
}

}  // namespace