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

#include "third_party/blink/renderer/core/css/resolver/style_cascade.h"

#include <vector>

#include "third_party/blink/renderer/bindings/core/v8/v8_css_style_sheet_init.h"
#include "third_party/blink/renderer/core/animation/css/css_animations.h"
#include "third_party/blink/renderer/core/css/active_style_sheets.h"
#include "third_party/blink/renderer/core/css/css_custom_property_declaration.h"
#include "third_party/blink/renderer/core/css/css_initial_color_value.h"
#include "third_party/blink/renderer/core/css/css_pending_substitution_value.h"
#include "third_party/blink/renderer/core/css/css_primitive_value.h"
#include "third_party/blink/renderer/core/css/css_revert_value.h"
#include "third_party/blink/renderer/core/css/css_test_helpers.h"
#include "third_party/blink/renderer/core/css/css_variable_reference_value.h"
#include "third_party/blink/renderer/core/css/document_style_environment_variables.h"
#include "third_party/blink/renderer/core/css/media_query_evaluator.h"
#include "third_party/blink/renderer/core/css/parser/css_parser_context.h"
#include "third_party/blink/renderer/core/css/parser/css_parser_local_context.h"
#include "third_party/blink/renderer/core/css/parser/css_parser_token_range.h"
#include "third_party/blink/renderer/core/css/parser/css_property_parser.h"
#include "third_party/blink/renderer/core/css/parser/css_tokenizer.h"
#include "third_party/blink/renderer/core/css/parser/css_variable_parser.h"
#include "third_party/blink/renderer/core/css/properties/css_property_instances.h"
#include "third_party/blink/renderer/core/css/properties/css_property_ref.h"
#include "third_party/blink/renderer/core/css/properties/longhands/custom_property.h"
#include "third_party/blink/renderer/core/css/property_registry.h"
#include "third_party/blink/renderer/core/css/resolver/cascade_filter.h"
#include "third_party/blink/renderer/core/css/resolver/cascade_interpolations.h"
#include "third_party/blink/renderer/core/css/resolver/cascade_map.h"
#include "third_party/blink/renderer/core/css/resolver/cascade_priority.h"
#include "third_party/blink/renderer/core/css/resolver/cascade_resolver.h"
#include "third_party/blink/renderer/core/css/resolver/scoped_style_resolver.h"
#include "third_party/blink/renderer/core/css/resolver/style_resolver.h"
#include "third_party/blink/renderer/core/css/style_engine.h"
#include "third_party/blink/renderer/core/css/style_sheet_contents.h"
#include "third_party/blink/renderer/core/html/html_element.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/core/style_property_shorthand.h"
#include "third_party/blink/renderer/core/testing/color_scheme_helper.h"
#include "third_party/blink/renderer/core/testing/page_test_base.h"
#include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"

namespace blink {

using css_test_helpers::ParseDeclarationBlock;
using css_test_helpers::RegisterProperty;
using Origin = CascadeOrigin;
using Priority = CascadePriority;
using UnitType = CSSPrimitiveValue::UnitType;

class TestCascadeResolver {
  STACK_ALLOCATED();

 public:
  explicit TestCascadeResolver(uint8_t generation = 0)
      : resolver_(CascadeFilter(), generation) {}
  bool InCycle() const { return resolver_.InCycle(); }
  bool DetectCycle(const CSSProperty& property) {
    return resolver_.DetectCycle(property);
  }
  wtf_size_t CycleDepth() const { return resolver_.cycle_depth_; }
  void MarkApplied(CascadePriority* priority) {
    resolver_.MarkApplied(priority);
  }
  void MarkUnapplied(CascadePriority* priority) {
    resolver_.MarkUnapplied(priority);
  }
  uint8_t GetGeneration() { return resolver_.generation_; }
  CascadeResolver& InnerResolver() { return resolver_; }
  const CSSProperty* CurrentProperty() const {
    return resolver_.CurrentProperty();
  }

 private:
  friend class TestCascadeAutoLock;

  CascadeResolver resolver_;
};

class TestCascade {
  STACK_ALLOCATED();

 public:
  TestCascade(Document& document, Element* target = nullptr)
      : state_(document, target ? *target : *document.body()),
        cascade_(InitState(state_)) {}

  scoped_refptr<ComputedStyle> TakeStyle() { return state_.TakeStyle(); }

  StyleResolverState& State() { return state_; }
  StyleCascade& InnerCascade() { return cascade_; }

  void InheritFrom(scoped_refptr<ComputedStyle> parent) {
    state_.SetParentStyle(parent);
    state_.StyleRef().InheritFrom(*parent);
  }

  //  Note that because of how MatchResult works, declarations must be added
  //  in "origin order", i.e. UserAgent first, then User, then Author.

  void Add(String block,
           CascadeOrigin origin = CascadeOrigin::kAuthor,
           unsigned link_match_type = CSSSelector::kMatchAll) {
    CSSParserMode mode =
        origin == CascadeOrigin::kUserAgent ? kUASheetMode : kHTMLStandardMode;
    Add(ParseDeclarationBlock(block, mode), origin, link_match_type);
  }

  void Add(String name, String value, CascadeOrigin origin = Origin::kAuthor) {
    Add(name + ":" + value, origin);
  }

  void Add(const CSSPropertyValueSet* set,
           CascadeOrigin origin = CascadeOrigin::kAuthor,
           unsigned link_match_type = CSSSelector::kMatchAll) {
    DCHECK_LE(origin, CascadeOrigin::kAuthor) << "Animations not supported";
    DCHECK_LE(current_origin_, origin) << "Please add declarations in order";
    EnsureAtLeast(origin);
    cascade_.MutableMatchResult().AddMatchedProperties(set, link_match_type);
  }

  void Apply(CascadeFilter filter = CascadeFilter()) {
    EnsureAtLeast(CascadeOrigin::kAnimation);
    cascade_.Apply(filter);
  }

  void ApplySingle(const CSSProperty& property) {
    EnsureAtLeast(CascadeOrigin::kAnimation);
    cascade_.AnalyzeIfNeeded();
    TestCascadeResolver resolver(++cascade_.generation_);
    cascade_.LookupAndApply(property, resolver.InnerResolver());
  }

  void AnalyzeIfNeeded() { cascade_.AnalyzeIfNeeded(); }

  const CSSValue* Resolve(const CSSProperty& property,
                          const CSSValue& value,
                          CascadeOrigin& origin) {
    TestCascadeResolver resolver;
    return cascade_.Resolve(property, value, origin, resolver.InnerResolver());
  }

  std::unique_ptr<CSSBitset> GetImportantSet() {
    return cascade_.GetImportantSet();
  }

  String ComputedValue(String name) const {
    CSSPropertyRef ref(name, GetDocument());
    DCHECK(ref.IsValid());
    const LayoutObject* layout_object = nullptr;
    bool allow_visited_style = false;
    const CSSValue* value = ref.GetProperty().CSSValueFromComputedStyle(
        *state_.Style(), layout_object, allow_visited_style);
    return value ? value->CssText() : g_null_atom;
  }

  CascadePriority GetPriority(String name) {
    return GetPriority(
        *CSSPropertyName::From(GetDocument().GetExecutionContext(), name));
  }

  CascadePriority GetPriority(CSSPropertyName name) {
    CascadePriority* c = cascade_.map_.Find(name);
    return c ? *c : CascadePriority();
  }

  CascadeOrigin GetOrigin(String name) { return GetPriority(name).GetOrigin(); }

  void CalculateTransitionUpdate() {
    CSSAnimations::CalculateTransitionUpdate(
        state_.AnimationUpdate(), CSSAnimations::PropertyPass::kCustom,
        &state_.GetElement(), *state_.Style());
    CSSAnimations::CalculateTransitionUpdate(
        state_.AnimationUpdate(), CSSAnimations::PropertyPass::kStandard,
        &state_.GetElement(), *state_.Style());
    AddTransitions();
  }

  void CalculateAnimationUpdate() {
    CSSAnimations::CalculateAnimationUpdate(
        state_.AnimationUpdate(), &state_.GetElement(), state_.GetElement(),
        *state_.Style(), state_.ParentStyle(),
        &GetDocument().GetStyleResolver());
    AddAnimations();
  }

  void Reset() {
    cascade_.Reset();
    current_origin_ = CascadeOrigin::kUserAgent;
  }

  bool NeedsMatchResultAnalyze() const {
    return cascade_.needs_match_result_analyze_;
  }
  bool NeedsInterpolationsAnalyze() const {
    return cascade_.needs_interpolations_analyze_;
  }
  bool DependsOnCascadeAffectingProperty() const {
    return cascade_.depends_on_cascade_affecting_property_;
  }

  HeapHashMap<CSSPropertyName, Member<const CSSValue>> GetCascadedValues()
      const {
    return cascade_.GetCascadedValues();
  }

 private:
  Document& GetDocument() const { return state_.GetDocument(); }
  Element* Body() const { return GetDocument().body(); }

  static StyleResolverState& InitState(StyleResolverState& state) {
    state.SetStyle(InitialStyle(state.GetDocument()));
    state.SetParentStyle(InitialStyle(state.GetDocument()));
    return state;
  }

  static scoped_refptr<ComputedStyle> InitialStyle(Document& document) {
    return StyleResolver::InitialStyleForElement(document);
  }

  void FinishOrigin() {
    switch (current_origin_) {
      case CascadeOrigin::kUserAgent:
        cascade_.MutableMatchResult().FinishAddingUARules();
        current_origin_ = CascadeOrigin::kUser;
        break;
      case CascadeOrigin::kUser:
        cascade_.MutableMatchResult().FinishAddingUserRules();
        current_origin_ = CascadeOrigin::kAuthor;
        break;
      case CascadeOrigin::kAuthor:
        cascade_.MutableMatchResult().FinishAddingAuthorRulesForTreeScope(
            GetDocument());
        current_origin_ = CascadeOrigin::kAnimation;
        break;
      case CascadeOrigin::kAnimation:
        break;
      default:
        NOTREACHED();
        break;
    }
  }

  void EnsureAtLeast(CascadeOrigin origin) {
    while (current_origin_ < origin)
      FinishOrigin();
  }

  void AddAnimations() {
    const auto& update = state_.AnimationUpdate();
    if (update.IsEmpty())
      return;
    cascade_.AddInterpolations(
        &update.ActiveInterpolationsForCustomAnimations(),
        CascadeOrigin::kAnimation);
    cascade_.AddInterpolations(
        &update.ActiveInterpolationsForStandardAnimations(),
        CascadeOrigin::kAnimation);
  }

  void AddTransitions() {
    const auto& update = state_.AnimationUpdate();
    if (update.IsEmpty())
      return;
    cascade_.AddInterpolations(
        &update.ActiveInterpolationsForCustomTransitions(),
        CascadeOrigin::kTransition);
    cascade_.AddInterpolations(
        &update.ActiveInterpolationsForStandardTransitions(),
        CascadeOrigin::kTransition);
  }

  CascadeOrigin current_origin_ = CascadeOrigin::kUserAgent;
  StyleResolverState state_;
  StyleCascade cascade_;
};

class TestCascadeAutoLock {
  STACK_ALLOCATED();

 public:
  TestCascadeAutoLock(const CSSProperty& property,
                      TestCascadeResolver& resolver)
      : lock_(property, resolver.resolver_) {}

 private:
  CascadeResolver::AutoLock lock_;
};

class StyleCascadeTest : public PageTestBase {
 public:
  CSSStyleSheet* CreateSheet(const String& css_text) {
    auto* init = MakeGarbageCollected<CSSStyleSheetInit>();
    DummyExceptionStateForTesting exception_state;
    CSSStyleSheet* sheet =
        CSSStyleSheet::Create(GetDocument(), init, exception_state);
    sheet->replaceSync(css_text, exception_state);
    sheet->Contents()->EnsureRuleSet(
        MediaQueryEvaluator(GetDocument().GetFrame()), kRuleHasNoSpecialState);
    return sheet;
  }

  void AppendSheet(const String& css_text) {
    CSSStyleSheet* sheet = CreateSheet(css_text);
    ASSERT_TRUE(sheet);

    Element* body = GetDocument().body();
    ASSERT_TRUE(body->IsInTreeScope());
    TreeScope& tree_scope = body->GetTreeScope();
    ScopedStyleResolver& scoped_resolver =
        tree_scope.EnsureScopedStyleResolver();
    ActiveStyleSheetVector active_sheets;
    active_sheets.push_back(
        std::make_pair(sheet, &sheet->Contents()->GetRuleSet()));
    scoped_resolver.AppendActiveStyleSheets(0, active_sheets);
    GetDocument()
        .GetStyleEngine()
        .GetDocumentStyleSheetCollection()
        .AppendActiveStyleSheet(active_sheets[0]);
  }

  Element* DocumentElement() const { return GetDocument().documentElement(); }

  void SetRootFont(String value) {
    DocumentElement()->SetInlineStyleProperty(CSSPropertyID::kFontSize, value);
    UpdateAllLifecyclePhasesForTest();
  }

  const MutableCSSPropertyValueSet* AnimationTaintedSet(AtomicString name,
                                                        String value) {
    CSSParserMode mode = kHTMLStandardMode;
    auto* set = MakeGarbageCollected<MutableCSSPropertyValueSet>(mode);
    set->SetProperty(name, value, /* important */ false,
                     SecureContextMode::kSecureContext,
                     /* context_style_sheet */ nullptr,
                     /* is_animation_tainted */ true);
    return set;
  }

  // Temporarily create a CSS Environment Variable.
  // https://drafts.csswg.org/css-env-1/
  class AutoEnv {
    STACK_ALLOCATED();

   public:
    AutoEnv(PageTestBase& test, AtomicString name, String value)
        : document_(&test.GetDocument()), name_(name) {
      EnsureEnvironmentVariables().SetVariable(name, value);
    }
    ~AutoEnv() { EnsureEnvironmentVariables().RemoveVariable(name_); }

   private:
    DocumentStyleEnvironmentVariables& EnsureEnvironmentVariables() {
      return document_->GetStyleEngine().EnsureEnvironmentVariables();
    }

    Document* document_;
    AtomicString name_;
  };

  CSSPropertyName PropertyName(String name) {
    return *CSSPropertyName::From(GetDocument().GetExecutionContext(), name);
  }

  String CssTextAt(
      const HeapHashMap<CSSPropertyName, Member<const CSSValue>>& map,
      String name) {
    const CSSValue* value = map.at(PropertyName(name));
    return value ? value->CssText() : g_null_atom;
  }
};

TEST_F(StyleCascadeTest, ApplySingle) {
  TestCascade cascade(GetDocument());
  cascade.Add("width", "1px", CascadeOrigin::kUserAgent);
  cascade.Add("width", "2px", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("2px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, ApplyImportance) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:1px !important", CascadeOrigin::kUserAgent);
  cascade.Add("width:2px", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("1px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, ApplyAll) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:1px", CascadeOrigin::kUserAgent);
  cascade.Add("height:1px", CascadeOrigin::kUserAgent);
  cascade.Add("all:initial", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("auto", cascade.ComputedValue("width"));
  EXPECT_EQ("auto", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, ApplyAllImportance) {
  TestCascade cascade(GetDocument());
  cascade.Add("opacity:0.5", CascadeOrigin::kUserAgent);
  cascade.Add("display:block !important", CascadeOrigin::kUserAgent);
  cascade.Add("all:initial", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("1", cascade.ComputedValue("opacity"));
  EXPECT_EQ("block", cascade.ComputedValue("display"));
}

TEST_F(StyleCascadeTest, ApplyAllWithPhysicalLonghands) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:1px", CascadeOrigin::kUserAgent);
  cascade.Add("height:1px !important", CascadeOrigin::kUserAgent);
  cascade.Add("all:initial", CascadeOrigin::kAuthor);
  cascade.Apply();
  EXPECT_EQ("auto", cascade.ComputedValue("width"));
  EXPECT_EQ("1px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, ApplyCustomProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", " 10px ");
  cascade.Add("--y", "nope");
  cascade.Apply();

  EXPECT_EQ(" 10px ", cascade.ComputedValue("--x"));
  EXPECT_EQ("nope", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, ApplyGenerations) {
  TestCascade cascade(GetDocument());

  cascade.Add("--x:10px");
  cascade.Add("width:20px");
  cascade.Apply();
  EXPECT_EQ("10px", cascade.ComputedValue("--x"));
  EXPECT_EQ("20px", cascade.ComputedValue("width"));

  cascade.State().StyleRef().SetWidth(Length::Auto());
  cascade.State().StyleRef().SetVariableData("--x", nullptr, true);
  EXPECT_EQ(g_null_atom, cascade.ComputedValue("--x"));
  EXPECT_EQ("auto", cascade.ComputedValue("width"));

  // Apply again
  cascade.Apply();
  EXPECT_EQ("10px", cascade.ComputedValue("--x"));
  EXPECT_EQ("20px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, ApplyCustomPropertyVar) {
  // Apply --x first.
  {
    TestCascade cascade(GetDocument());
    cascade.Add("--x", "yes and var(--y)");
    cascade.Add("--y", "no");
    cascade.Apply();

    EXPECT_EQ("yes and no", cascade.ComputedValue("--x"));
    EXPECT_EQ("no", cascade.ComputedValue("--y"));
  }

  // Apply --y first.
  {
    TestCascade cascade(GetDocument());
    cascade.Add("--y", "no");
    cascade.Add("--x", "yes and var(--y)");
    cascade.Apply();

    EXPECT_EQ("yes and no", cascade.ComputedValue("--x"));
    EXPECT_EQ("no", cascade.ComputedValue("--y"));
  }
}

TEST_F(StyleCascadeTest, InvalidVarReferenceCauseInvalidVariable) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "nope var(--y)");
  cascade.Apply();

  EXPECT_EQ(g_null_atom, cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, ApplyCustomPropertyFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "yes and var(--y,no)");
  cascade.Apply();

  EXPECT_EQ("yes and no", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RegisteredPropertyFallback) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "var(--y,10px)");
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RegisteredPropertyFallbackValidation) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "10px");
  cascade.Add("--y", "var(--x,red)");  // Fallback must be valid <length>.
  cascade.Add("--z", "var(--y,pass)");
  cascade.Apply();

  EXPECT_EQ("pass", cascade.ComputedValue("--z"));
}

TEST_F(StyleCascadeTest, VarInFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "one var(--z,two var(--y))");
  cascade.Add("--y", "three");
  cascade.Apply();

  EXPECT_EQ("one two three", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, VarReferenceInNormalProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "10px");
  cascade.Add("width", "var(--x)");
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, MultipleVarRefs) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "var(--y) bar var(--y)");
  cascade.Add("--y", "foo");
  cascade.Apply();

  EXPECT_EQ("foo bar foo", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RegisteredPropertyComputedValue) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "1in");
  cascade.Apply();

  EXPECT_EQ("96px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RegisteredPropertySyntaxErrorCausesInitial) {
  RegisterProperty(GetDocument(), "--x", "<length>", "10px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "#fefefe");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("--x"));
  EXPECT_EQ("10px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RegisteredPropertySubstitution) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "1in");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();

  EXPECT_EQ("96px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RegisteredPropertyChain) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--z", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "1in");
  cascade.Add("--y", "var(--x)");
  cascade.Add("--z", "calc(var(--y) + 1in)");
  cascade.Apply();

  EXPECT_EQ("96px", cascade.ComputedValue("--x"));
  EXPECT_EQ("96px", cascade.ComputedValue("--y"));
  EXPECT_EQ("192px", cascade.ComputedValue("--z"));
}

TEST_F(StyleCascadeTest, BasicShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin", "1px 2px 3px 4px");
  cascade.Apply();

  EXPECT_EQ("1px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("2px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("3px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("4px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, BasicVarShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin", "1px var(--x) 3px 4px");
  cascade.Add("--x", "2px");
  cascade.Apply();

  EXPECT_EQ("1px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("2px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("3px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("4px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, ApplyingPendingSubstitutionFirst) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin", "1px var(--x) 3px 4px");
  cascade.Add("--x", "2px");
  cascade.Add("margin-right", "5px");
  cascade.Apply();

  EXPECT_EQ("1px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("5px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("3px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("4px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, ApplyingPendingSubstitutionLast) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin-right", "5px");
  cascade.Add("margin", "1px var(--x) 3px 4px");
  cascade.Add("--x", "2px");
  cascade.Apply();

  EXPECT_EQ("1px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("2px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("3px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("4px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, PendingSubstitutionInLogicalShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin-inline:var(--x)");
  cascade.Add("--x:10px 20px");
  cascade.Add("direction:rtl");
  cascade.Apply();

  EXPECT_EQ("20px", cascade.ComputedValue("margin-left"));
  EXPECT_EQ("10px", cascade.ComputedValue("margin-right"));
}

TEST_F(StyleCascadeTest, DetectCycleByName) {
  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  // Two different CustomProperty instances with the same name:
  CustomProperty a1("--a", GetDocument());
  CustomProperty a2("--a", GetDocument());

  {
    TestCascadeAutoLock lock(a1, resolver);
    EXPECT_FALSE(resolver.InCycle());

    // This should still be detected as a cycle, even though it's not the same
    // CustomProperty instance.
    EXPECT_TRUE(resolver.DetectCycle(a2));
    EXPECT_TRUE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverDetectCycle) {
  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());
  CustomProperty b("--b", GetDocument());
  CustomProperty c("--c", GetDocument());

  {
    TestCascadeAutoLock lock(a, resolver);
    EXPECT_FALSE(resolver.InCycle());
    {
      TestCascadeAutoLock lock(b, resolver);
      EXPECT_FALSE(resolver.InCycle());
      {
        TestCascadeAutoLock lock(c, resolver);
        EXPECT_FALSE(resolver.InCycle());

        EXPECT_TRUE(resolver.DetectCycle(a));
        EXPECT_TRUE(resolver.InCycle());
      }
      EXPECT_TRUE(resolver.InCycle());
    }
    EXPECT_TRUE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverDetectNoCycle) {
  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());
  CustomProperty b("--b", GetDocument());
  CustomProperty c("--c", GetDocument());
  CustomProperty x("--x", GetDocument());

  {
    TestCascadeAutoLock lock(a, resolver);
    EXPECT_FALSE(resolver.InCycle());
    {
      TestCascadeAutoLock lock(b, resolver);
      EXPECT_FALSE(resolver.InCycle());
      {
        TestCascadeAutoLock lock(c, resolver);
        EXPECT_FALSE(resolver.InCycle());

        EXPECT_FALSE(resolver.DetectCycle(x));
        EXPECT_FALSE(resolver.InCycle());
      }
      EXPECT_FALSE(resolver.InCycle());
    }
    EXPECT_FALSE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverDetectCycleSelf) {
  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());

  {
    TestCascadeAutoLock lock(a, resolver);
    EXPECT_FALSE(resolver.InCycle());

    EXPECT_TRUE(resolver.DetectCycle(a));
    EXPECT_TRUE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverDetectMultiCycle) {
  using AutoLock = TestCascadeAutoLock;

  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());
  CustomProperty b("--b", GetDocument());
  CustomProperty c("--c", GetDocument());
  CustomProperty d("--d", GetDocument());

  {
    AutoLock lock(a, resolver);
    EXPECT_FALSE(resolver.InCycle());
    {
      AutoLock lock(b, resolver);
      EXPECT_FALSE(resolver.InCycle());
      {
        AutoLock lock(c, resolver);
        EXPECT_FALSE(resolver.InCycle());
        {
          AutoLock lock(d, resolver);
          EXPECT_FALSE(resolver.InCycle());

          // Cycle 1 (big cycle):
          EXPECT_TRUE(resolver.DetectCycle(b));
          EXPECT_TRUE(resolver.InCycle());
          EXPECT_EQ(1u, resolver.CycleDepth());

          // Cycle 2 (small cycle):
          EXPECT_TRUE(resolver.DetectCycle(c));
          EXPECT_TRUE(resolver.InCycle());
          EXPECT_EQ(1u, resolver.CycleDepth());
        }
      }
      EXPECT_TRUE(resolver.InCycle());
    }
    EXPECT_FALSE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverDetectMultiCycleReverse) {
  using AutoLock = TestCascadeAutoLock;

  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());
  CustomProperty b("--b", GetDocument());
  CustomProperty c("--c", GetDocument());
  CustomProperty d("--d", GetDocument());

  {
    AutoLock lock(a, resolver);
    EXPECT_FALSE(resolver.InCycle());
    {
      AutoLock lock(b, resolver);
      EXPECT_FALSE(resolver.InCycle());
      {
        AutoLock lock(c, resolver);
        EXPECT_FALSE(resolver.InCycle());
        {
          AutoLock lock(d, resolver);
          EXPECT_FALSE(resolver.InCycle());

          // Cycle 1 (small cycle):
          EXPECT_TRUE(resolver.DetectCycle(c));
          EXPECT_TRUE(resolver.InCycle());
          EXPECT_EQ(2u, resolver.CycleDepth());

          // Cycle 2 (big cycle):
          EXPECT_TRUE(resolver.DetectCycle(b));
          EXPECT_TRUE(resolver.InCycle());
          EXPECT_EQ(1u, resolver.CycleDepth());
        }
      }
      EXPECT_TRUE(resolver.InCycle());
    }
    EXPECT_FALSE(resolver.InCycle());
  }
  EXPECT_FALSE(resolver.InCycle());
}

TEST_F(StyleCascadeTest, ResolverMarkApplied) {
  TestCascadeResolver resolver(2);

  CascadePriority priority(CascadeOrigin::kAuthor);
  EXPECT_EQ(0, priority.GetGeneration());

  resolver.MarkApplied(&priority);
  EXPECT_EQ(2, priority.GetGeneration());

  // Mark a second time to verify observation of the same generation.
  resolver.MarkApplied(&priority);
  EXPECT_EQ(2, priority.GetGeneration());
}

TEST_F(StyleCascadeTest, CurrentProperty) {
  using AutoLock = TestCascadeAutoLock;

  TestCascade cascade(GetDocument());
  TestCascadeResolver resolver;

  CustomProperty a("--a", GetDocument());
  CustomProperty b("--b", GetDocument());
  CustomProperty c("--c", GetDocument());

  EXPECT_FALSE(resolver.CurrentProperty());
  {
    AutoLock lock(a, resolver);
    EXPECT_EQ(&a, resolver.CurrentProperty());
    {
      AutoLock lock(b, resolver);
      EXPECT_EQ(&b, resolver.CurrentProperty());
      {
        AutoLock lock(c, resolver);
        EXPECT_EQ(&c, resolver.CurrentProperty());
      }
      EXPECT_EQ(&b, resolver.CurrentProperty());
    }
    EXPECT_EQ(&a, resolver.CurrentProperty());
  }
  EXPECT_FALSE(resolver.CurrentProperty());
}

TEST_F(StyleCascadeTest, ResolverMarkUnapplied) {
  TestCascadeResolver resolver(7);

  CascadePriority priority(CascadeOrigin::kAuthor);
  EXPECT_EQ(0, priority.GetGeneration());

  resolver.MarkApplied(&priority);
  EXPECT_EQ(7, priority.GetGeneration());

  resolver.MarkUnapplied(&priority);
  EXPECT_EQ(0, priority.GetGeneration());

  // Mark a second time to verify observation of the same generation.
  resolver.MarkUnapplied(&priority);
  EXPECT_EQ(0, priority.GetGeneration());
}

TEST_F(StyleCascadeTest, BasicCycle) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "foo");
  cascade.Add("--b", "bar");
  cascade.Apply();

  EXPECT_EQ("foo", cascade.ComputedValue("--a"));
  EXPECT_EQ("bar", cascade.ComputedValue("--b"));

  cascade.Reset();
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
}

TEST_F(StyleCascadeTest, SelfCycle) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "foo");
  cascade.Apply();

  EXPECT_EQ("foo", cascade.ComputedValue("--a"));

  cascade.Reset();
  cascade.Add("--a", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
}

TEST_F(StyleCascadeTest, SelfCycleInFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--x, var(--a))");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
}

TEST_F(StyleCascadeTest, SelfCycleInUnusedFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b, var(--a))");
  cascade.Add("--b", "10px");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_EQ("10px", cascade.ComputedValue("--b"));
}

TEST_F(StyleCascadeTest, LongCycle) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--c)");
  cascade.Add("--c", "var(--d)");
  cascade.Add("--d", "var(--e)");
  cascade.Add("--e", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
  EXPECT_FALSE(cascade.ComputedValue("--d"));
  EXPECT_FALSE(cascade.ComputedValue("--e"));
}

TEST_F(StyleCascadeTest, PartialCycle) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Add("--c", "bar var(--d) var(--a)");
  cascade.Add("--d", "foo");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
  EXPECT_EQ("foo", cascade.ComputedValue("--d"));
}

TEST_F(StyleCascadeTest, VarCycleViaFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--x, var(--a))");
  cascade.Add("--c", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
}

TEST_F(StyleCascadeTest, FallbackTriggeredByCycle) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Add("--c", "var(--a,foo)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("foo", cascade.ComputedValue("--c"));
}

TEST_F(StyleCascadeTest, RegisteredCycle) {
  RegisterProperty(GetDocument(), "--a", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--b", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
}

TEST_F(StyleCascadeTest, PartiallyRegisteredCycle) {
  RegisterProperty(GetDocument(), "--a", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
}

TEST_F(StyleCascadeTest, FallbackTriggeredByRegisteredCycle) {
  RegisterProperty(GetDocument(), "--a", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--b", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  // Cycle:
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  // References to cycle:
  cascade.Add("--c", "var(--a,1px)");
  cascade.Add("--d", "var(--b,2px)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("1px", cascade.ComputedValue("--c"));
  EXPECT_EQ("2px", cascade.ComputedValue("--d"));
}

TEST_F(StyleCascadeTest, CycleStillInvalidWithFallback) {
  TestCascade cascade(GetDocument());
  // Cycle:
  cascade.Add("--a", "var(--b,red)");
  cascade.Add("--b", "var(--a,red)");
  // References to cycle:
  cascade.Add("--c", "var(--a,green)");
  cascade.Add("--d", "var(--b,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("green", cascade.ComputedValue("--c"));
  EXPECT_EQ("green", cascade.ComputedValue("--d"));
}

TEST_F(StyleCascadeTest, CycleInFallbackStillInvalid) {
  TestCascade cascade(GetDocument());
  // Cycle:
  cascade.Add("--a", "var(--b,red)");
  cascade.Add("--b", "var(--x,var(--a))");
  // References to cycle:
  cascade.Add("--c", "var(--a,green)");
  cascade.Add("--d", "var(--b,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("green", cascade.ComputedValue("--c"));
  EXPECT_EQ("green", cascade.ComputedValue("--d"));
}

TEST_F(StyleCascadeTest, CycleMultiple) {
  TestCascade cascade(GetDocument());
  // Cycle:
  cascade.Add("--a", "var(--c, red)");
  cascade.Add("--b", "var(--c, red)");
  cascade.Add("--c", "var(--a, blue) var(--b, blue)");
  // References to cycle:
  cascade.Add("--d", "var(--a,green)");
  cascade.Add("--e", "var(--b,green)");
  cascade.Add("--f", "var(--c,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
  EXPECT_EQ("green", cascade.ComputedValue("--d"));
  EXPECT_EQ("green", cascade.ComputedValue("--e"));
  EXPECT_EQ("green", cascade.ComputedValue("--f"));
}

TEST_F(StyleCascadeTest, CycleMultipleFallback) {
  TestCascade cascade(GetDocument());
  // Cycle:
  cascade.Add("--a", "var(--b, red)");
  cascade.Add("--b", "var(--a, var(--c, red))");
  cascade.Add("--c", "var(--b, red)");
  // References to cycle:
  cascade.Add("--d", "var(--a,green)");
  cascade.Add("--e", "var(--b,green)");
  cascade.Add("--f", "var(--c,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
  EXPECT_EQ("green", cascade.ComputedValue("--d"));
  EXPECT_EQ("green", cascade.ComputedValue("--e"));
  EXPECT_EQ("green", cascade.ComputedValue("--f"));
}

TEST_F(StyleCascadeTest, CycleMultipleUnusedFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "red");
  // Cycle:
  cascade.Add("--b", "var(--c, red)");
  cascade.Add("--c", "var(--a, var(--b, red) var(--d, red))");
  cascade.Add("--d", "var(--c, red)");
  // References to cycle:
  cascade.Add("--e", "var(--b,green)");
  cascade.Add("--f", "var(--c,green)");
  cascade.Add("--g", "var(--d,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_FALSE(cascade.ComputedValue("--c"));
  EXPECT_FALSE(cascade.ComputedValue("--d"));
  EXPECT_EQ("green", cascade.ComputedValue("--e"));
  EXPECT_EQ("green", cascade.ComputedValue("--f"));
  EXPECT_EQ("green", cascade.ComputedValue("--g"));
}

TEST_F(StyleCascadeTest, CycleReferencedFromStandardProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Add("color:var(--a,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));
}

TEST_F(StyleCascadeTest, CycleReferencedFromShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("--a", "var(--b)");
  cascade.Add("--b", "var(--a)");
  cascade.Add("background", "var(--a,green)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--a"));
  EXPECT_FALSE(cascade.ComputedValue("--b"));
  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, EmUnit) {
  TestCascade cascade(GetDocument());
  cascade.Add("font-size", "10px");
  cascade.Add("width", "10em");
  cascade.Apply();

  EXPECT_EQ("100px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, EmUnitCustomProperty) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("font-size", "10px");
  cascade.Add("--x", "10em");
  cascade.Apply();

  EXPECT_EQ("100px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, EmUnitNonCycle) {
  TestCascade parent(GetDocument());
  parent.Add("font-size", "10px");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  cascade.Add("font-size", "var(--x)");
  cascade.Add("--x", "10em");
  cascade.Apply();

  // Note: Only registered properties can have cycles with font-size.
  EXPECT_EQ("100px", cascade.ComputedValue("font-size"));
}

TEST_F(StyleCascadeTest, EmUnitCycle) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("font-size", "var(--x)");
  cascade.Add("--x", "10em");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, SubstitutingEmCycles) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("font-size", "var(--x)");
  cascade.Add("--x", "10em");
  cascade.Add("--y", "var(--x)");
  cascade.Add("--z", "var(--x,1px)");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--y"));
  EXPECT_EQ("1px", cascade.ComputedValue("--z"));
}

TEST_F(StyleCascadeTest, RemUnit) {
  SetRootFont("10px");
  UpdateAllLifecyclePhasesForTest();

  TestCascade cascade(GetDocument());
  cascade.Add("width", "10rem");
  cascade.Apply();

  EXPECT_EQ("100px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, RemUnitCustomProperty) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  SetRootFont("10px");
  UpdateAllLifecyclePhasesForTest();

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "10rem");
  cascade.Apply();

  EXPECT_EQ("100px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RemUnitInFontSize) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  SetRootFont("10px");
  UpdateAllLifecyclePhasesForTest();

  TestCascade cascade(GetDocument());
  cascade.Add("font-size", "1rem");
  cascade.Add("--x", "10rem");
  cascade.Apply();

  EXPECT_EQ("100px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RemUnitInRootFontSizeCycle) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument(), DocumentElement());
  cascade.Add("font-size", "var(--x)");
  cascade.Add("--x", "1rem");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RemUnitInRootFontSizeNonCycle) {
  TestCascade cascade(GetDocument(), DocumentElement());
  cascade.Add("font-size", "initial");
  cascade.Apply();

  String expected = cascade.ComputedValue("font-size");

  cascade.Reset();
  cascade.Add("font-size", "var(--x)");
  cascade.Add("--x", "1rem");
  cascade.Apply();

  // Note: Only registered properties can have cycles with font-size.
  EXPECT_EQ("1rem", cascade.ComputedValue("--x"));
  EXPECT_EQ(expected, cascade.ComputedValue("font-size"));
}

TEST_F(StyleCascadeTest, Initial) {
  TestCascade parent(GetDocument());
  parent.Add("--x", "foo");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  cascade.Add("--y", "foo");
  cascade.Apply();

  EXPECT_EQ("foo", cascade.ComputedValue("--x"));
  EXPECT_EQ("foo", cascade.ComputedValue("--y"));

  cascade.Reset();
  cascade.Add("--x", "initial");
  cascade.Add("--y", "initial");
  cascade.Apply();

  EXPECT_FALSE(cascade.ComputedValue("--x"));
  EXPECT_FALSE(cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, Inherit) {
  TestCascade parent(GetDocument());
  parent.Add("--x", "foo");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());

  EXPECT_EQ("foo", cascade.ComputedValue("--x"));

  cascade.Add("--x", "bar");
  cascade.Apply();
  EXPECT_EQ("bar", cascade.ComputedValue("--x"));

  cascade.Reset();
  cascade.Add("--x", "inherit");
  cascade.Apply();
  EXPECT_EQ("foo", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, Unset) {
  TestCascade parent(GetDocument());
  parent.Add("--x", "foo");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  EXPECT_EQ("foo", cascade.ComputedValue("--x"));

  cascade.Add("--x", "bar");
  cascade.Apply();
  EXPECT_EQ("bar", cascade.ComputedValue("--x"));

  cascade.Reset();
  cascade.Add("--x", "unset");
  cascade.Apply();
  EXPECT_EQ("foo", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertUA) {
  TestCascade cascade(GetDocument());
  cascade.Add("display:block", CascadeOrigin::kUserAgent);
  cascade.Add("display:revert", CascadeOrigin::kUserAgent);

  cascade.Add("display:block", CascadeOrigin::kUser);
  cascade.Add("display:revert", CascadeOrigin::kUser);

  cascade.Add("display:block", CascadeOrigin::kAuthor);
  cascade.Add("display:revert", CascadeOrigin::kAuthor);

  cascade.Apply();

  EXPECT_EQ("inline", cascade.ComputedValue("display"));
}

TEST_F(StyleCascadeTest, RevertStandardProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("left:10px", CascadeOrigin::kUserAgent);
  cascade.Add("right:10px", CascadeOrigin::kUserAgent);

  cascade.Add("right:20px", CascadeOrigin::kUser);
  cascade.Add("right:revert", CascadeOrigin::kUser);
  cascade.Add("top:20px", CascadeOrigin::kUser);
  cascade.Add("bottom:20px", CascadeOrigin::kUser);

  cascade.Add("bottom:30px", CascadeOrigin::kAuthor);
  cascade.Add("bottom:revert", CascadeOrigin::kAuthor);
  cascade.Add("left:30px", CascadeOrigin::kAuthor);
  cascade.Add("left:revert", CascadeOrigin::kAuthor);
  cascade.Add("right:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("20px", cascade.ComputedValue("top"));
  EXPECT_EQ("10px", cascade.ComputedValue("right"));
  EXPECT_EQ("20px", cascade.ComputedValue("bottom"));
  EXPECT_EQ("10px", cascade.ComputedValue("left"));
}

TEST_F(StyleCascadeTest, RevertCustomProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x:10px", CascadeOrigin::kUser);

  cascade.Add("--y:fail", CascadeOrigin::kAuthor);

  cascade.Add("--x:revert", CascadeOrigin::kAuthor);
  cascade.Add("--y:revert", CascadeOrigin::kAuthor);

  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("--x"));
  EXPECT_FALSE(cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RevertChain) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:10px", CascadeOrigin::kUserAgent);

  cascade.Add("width:revert", CascadeOrigin::kUser);
  cascade.Add("--x:revert", CascadeOrigin::kUser);

  cascade.Add("width:revert", CascadeOrigin::kAuthor);
  cascade.Add("--x:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_FALSE(cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertFromAuthorToUA) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:10px", CascadeOrigin::kUserAgent);
  cascade.Add("height:10px", CascadeOrigin::kUserAgent);

  cascade.Add("width:20px", CascadeOrigin::kAuthor);
  cascade.Add("height:20px", CascadeOrigin::kAuthor);
  cascade.Add("width:revert", CascadeOrigin::kAuthor);
  cascade.Add("height:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("10px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, RevertInitialFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:20px", CascadeOrigin::kAuthor);
  cascade.Add("width:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("auto", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, RevertInheritedFallback) {
  TestCascade parent(GetDocument());
  parent.Add("color", "red");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  EXPECT_EQ("rgb(255, 0, 0)", cascade.ComputedValue("color"));

  cascade.Add("color:black", CascadeOrigin::kAuthor);
  cascade.Add("color:revert", CascadeOrigin::kAuthor);
  cascade.Apply();
  EXPECT_EQ("rgb(255, 0, 0)", cascade.ComputedValue("color"));
}

TEST_F(StyleCascadeTest, RevertRegistered) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x:20px", CascadeOrigin::kUser);
  cascade.Add("--x:100px", CascadeOrigin::kAuthor);
  cascade.Add("--x:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("20px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertRegisteredInitialFallback) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x:20px", CascadeOrigin::kAuthor);
  cascade.Add("--x:revert", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("0px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertRegisteredInheritedFallback) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", true);

  TestCascade parent(GetDocument());
  parent.Add("--x", "1px");
  parent.Apply();

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  EXPECT_EQ("1px", cascade.ComputedValue("--x"));

  cascade.Add("--x:100px", CascadeOrigin::kAuthor);
  cascade.Add("--x:revert", CascadeOrigin::kAuthor);
  cascade.Apply();
  EXPECT_EQ("1px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertUASurrogate) {
  TestCascade cascade(GetDocument());

  // User-agent:

  // Only logical:
  cascade.Add("inline-size:10px", CascadeOrigin::kUserAgent);
  cascade.Add("min-inline-size:11px", CascadeOrigin::kUserAgent);
  // Only physical:
  cascade.Add("height:12px", CascadeOrigin::kUserAgent);
  cascade.Add("min-height:13px", CascadeOrigin::kUserAgent);
  // Physical first:
  cascade.Add("margin-left:14px", CascadeOrigin::kUserAgent);
  cascade.Add("padding-left:15px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-inline-start:16px", CascadeOrigin::kUserAgent);
  cascade.Add("padding-inline-start:17px", CascadeOrigin::kUserAgent);
  // Logical first:
  cascade.Add("margin-inline-end:18px", CascadeOrigin::kUserAgent);
  cascade.Add("padding-inline-end:19px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-right:20px", CascadeOrigin::kUserAgent);
  cascade.Add("padding-right:21px", CascadeOrigin::kUserAgent);

  // Author:

  cascade.Add("width:100px", CascadeOrigin::kAuthor);
  cascade.Add("height:101px", CascadeOrigin::kAuthor);
  cascade.Add("margin:102px", CascadeOrigin::kAuthor);
  cascade.Add("padding:103px", CascadeOrigin::kAuthor);
  cascade.Add("min-width:104px", CascadeOrigin::kAuthor);
  cascade.Add("min-height:105px", CascadeOrigin::kAuthor);
  // Revert via physical:
  cascade.Add("width:revert", CascadeOrigin::kAuthor);
  cascade.Add("height:revert", CascadeOrigin::kAuthor);
  cascade.Add("margin-left:revert", CascadeOrigin::kAuthor);
  cascade.Add("margin-right:revert", CascadeOrigin::kAuthor);
  // Revert via logical:
  cascade.Add("min-inline-size:revert", CascadeOrigin::kAuthor);
  cascade.Add("min-block-size:revert", CascadeOrigin::kAuthor);
  cascade.Add("padding-inline-start:revert", CascadeOrigin::kAuthor);
  cascade.Add("padding-inline-end:revert", CascadeOrigin::kAuthor);

  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("12px", cascade.ComputedValue("height"));
  EXPECT_EQ("11px", cascade.ComputedValue("min-width"));
  EXPECT_EQ("13px", cascade.ComputedValue("min-height"));
  EXPECT_EQ("102px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("20px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("102px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("16px", cascade.ComputedValue("margin-left"));
  EXPECT_EQ("103px", cascade.ComputedValue("padding-top"));
  EXPECT_EQ("21px", cascade.ComputedValue("padding-right"));
  EXPECT_EQ("103px", cascade.ComputedValue("padding-bottom"));
  EXPECT_EQ("17px", cascade.ComputedValue("padding-left"));

  EXPECT_EQ("10px", cascade.ComputedValue("inline-size"));
  EXPECT_EQ("12px", cascade.ComputedValue("block-size"));
  EXPECT_EQ("11px", cascade.ComputedValue("min-inline-size"));
  EXPECT_EQ("13px", cascade.ComputedValue("min-block-size"));
  EXPECT_EQ("102px", cascade.ComputedValue("margin-block-start"));
  EXPECT_EQ("20px", cascade.ComputedValue("margin-inline-end"));
  EXPECT_EQ("102px", cascade.ComputedValue("margin-block-end"));
  EXPECT_EQ("16px", cascade.ComputedValue("margin-inline-start"));
  EXPECT_EQ("103px", cascade.ComputedValue("padding-block-start"));
  EXPECT_EQ("21px", cascade.ComputedValue("padding-inline-end"));
  EXPECT_EQ("103px", cascade.ComputedValue("padding-block-end"));
  EXPECT_EQ("17px", cascade.ComputedValue("padding-inline-start"));
}

TEST_F(StyleCascadeTest, RevertWithImportantPhysical) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px", CascadeOrigin::kUserAgent);
  cascade.Add("block-size:11px", CascadeOrigin::kUserAgent);

  cascade.Add("width:100px", CascadeOrigin::kAuthor);
  cascade.Add("height:101px", CascadeOrigin::kAuthor);
  cascade.Add("width:revert !important", CascadeOrigin::kAuthor);
  cascade.Add("inline-size:101px", CascadeOrigin::kAuthor);
  cascade.Add("block-size:102px", CascadeOrigin::kAuthor);
  cascade.Add("height:revert !important", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("11px", cascade.ComputedValue("height"));
  EXPECT_EQ("10px", cascade.ComputedValue("inline-size"));
  EXPECT_EQ("11px", cascade.ComputedValue("block-size"));
}

TEST_F(StyleCascadeTest, RevertWithImportantLogical) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px", CascadeOrigin::kUserAgent);
  cascade.Add("block-size:11px", CascadeOrigin::kUserAgent);

  cascade.Add("inline-size:revert !important", CascadeOrigin::kAuthor);
  cascade.Add("width:100px", CascadeOrigin::kAuthor);
  cascade.Add("height:101px", CascadeOrigin::kAuthor);
  cascade.Add("block-size:revert !important", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("11px", cascade.ComputedValue("height"));
  EXPECT_EQ("10px", cascade.ComputedValue("inline-size"));
  EXPECT_EQ("11px", cascade.ComputedValue("block-size"));
}

TEST_F(StyleCascadeTest, RevertSurrogateChain) {
  TestCascade cascade(GetDocument());

  cascade.Add("inline-size:revert", CascadeOrigin::kUserAgent);
  cascade.Add("block-size:10px", CascadeOrigin::kUserAgent);
  cascade.Add("min-inline-size:11px", CascadeOrigin::kUserAgent);
  cascade.Add("min-block-size:12px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-inline:13px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-block:14px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-top:revert", CascadeOrigin::kUserAgent);
  cascade.Add("margin-left:15px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-bottom:16px", CascadeOrigin::kUserAgent);
  cascade.Add("margin-block-end:17px", CascadeOrigin::kUserAgent);

  cascade.Add("inline-size:101px", CascadeOrigin::kUser);
  cascade.Add("block-size:102px", CascadeOrigin::kUser);
  cascade.Add("width:revert", CascadeOrigin::kUser);
  cascade.Add("height:revert", CascadeOrigin::kUser);
  cascade.Add("min-inline-size:103px", CascadeOrigin::kUser);
  cascade.Add("min-block-size:104px", CascadeOrigin::kUser);
  cascade.Add("margin:105px", CascadeOrigin::kUser);
  cascade.Add("margin-block-start:revert", CascadeOrigin::kUser);
  cascade.Add("margin-inline-start:106px", CascadeOrigin::kUser);
  cascade.Add("margin-block-end:revert", CascadeOrigin::kUser);
  cascade.Add("margin-right:107px", CascadeOrigin::kUser);

  cascade.Add("inline-size:revert", CascadeOrigin::kAuthor);
  cascade.Add("block-size:revert", CascadeOrigin::kAuthor);
  cascade.Add("min-inline-size:revert", CascadeOrigin::kAuthor);
  cascade.Add("min-block-size:1001px", CascadeOrigin::kAuthor);
  cascade.Add("margin:1002px", CascadeOrigin::kAuthor);
  cascade.Add("margin-top:revert", CascadeOrigin::kAuthor);
  cascade.Add("margin-left:1003px", CascadeOrigin::kAuthor);
  cascade.Add("margin-bottom:1004px", CascadeOrigin::kAuthor);
  cascade.Add("margin-right:1005px", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("auto", cascade.ComputedValue("width"));
  EXPECT_EQ("10px", cascade.ComputedValue("height"));
  EXPECT_EQ("103px", cascade.ComputedValue("min-width"));
  EXPECT_EQ("1001px", cascade.ComputedValue("min-height"));
  EXPECT_EQ("0px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("1005px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("1004px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("1003px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, RevertInKeyframe) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { margin-left: 0px; }
        to { margin-left: revert; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("margin-left:100px", CascadeOrigin::kUserAgent);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("50px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, RevertToCustomPropertyInKeyframe) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 0px; }
        to { --x: revert; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("--x:100px", CascadeOrigin::kUser);
  cascade.Add("--x:1000px", CascadeOrigin::kAuthor);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("50px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertToCustomPropertyInKeyframeUnset) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--y", "<length>", "1000px", true);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 100px; --y: 100px; }
        to { --x: revert; --y: revert; }
     }
    )HTML");

  TestCascade parent(GetDocument());
  parent.Add("--y: 0px");
  parent.Apply();
  EXPECT_EQ("0px", parent.ComputedValue("--y"));

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  cascade.Add("--x:10000px", CascadeOrigin::kAuthor);
  cascade.Add("--y:10000px", CascadeOrigin::kAuthor);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("50px", cascade.ComputedValue("--x"));
  EXPECT_EQ("50px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RevertToCustomPropertyInKeyframeEmptyInherit) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", true);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 100px; }
        to { --x: revert; }
     }
    )HTML");

  TestCascade cascade(GetDocument());
  cascade.Add("--x:10000px", CascadeOrigin::kAuthor);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("50px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertInKeyframeResponsive) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { margin-left: 0px; }
        to { margin-left: revert; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("--x:100px", CascadeOrigin::kUser);
  cascade.Add("margin-left:var(--x)", CascadeOrigin::kUser);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();
  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("50px", cascade.ComputedValue("margin-left"));

  cascade.Reset();
  cascade.Add("--x:100px", CascadeOrigin::kUser);
  cascade.Add("margin-left:var(--x)", CascadeOrigin::kUser);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Add("--x:80px", CascadeOrigin::kAuthor);
  cascade.Apply();
  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("40px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, RevertToCycleInKeyframe) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 100px; }
        to { --x: revert; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("--x:var(--y)", CascadeOrigin::kUser);
  cascade.Add("--y:var(--x)", CascadeOrigin::kUser);
  cascade.Add("--x:200px", CascadeOrigin::kAuthor);
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("0px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, RevertCausesTransition) {
  TestCascade cascade1(GetDocument());
  cascade1.Add("width:200px", CascadeOrigin::kUser);
  cascade1.Add("width:100px", CascadeOrigin::kAuthor);
  cascade1.Add("transition: width 1000s steps(2, end)", CascadeOrigin::kAuthor);
  cascade1.Apply();

  GetDocument().body()->SetComputedStyle(cascade1.TakeStyle());

  // Now simulate a new style, with new color values.
  TestCascade cascade2(GetDocument());
  cascade2.Add("width:200px", CascadeOrigin::kUser);
  cascade2.Add("width:100px", CascadeOrigin::kAuthor);
  cascade2.Add("width:revert", CascadeOrigin::kAuthor);
  cascade2.Add("transition: width 1000s steps(2, start)",
               CascadeOrigin::kAuthor);
  cascade2.Apply();

  cascade2.CalculateTransitionUpdate();
  cascade2.Apply();

  EXPECT_EQ("150px", cascade2.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, CSSWideKeywordsInFallbacks) {
  {
    TestCascade cascade(GetDocument());
    cascade.Add("display:var(--u,initial)");
    cascade.Add("margin:var(--u,initial)");
    cascade.Apply();
  }
  {
    TestCascade cascade(GetDocument());
    cascade.Add("display:var(--u,inherit)");
    cascade.Add("margin:var(--u,inherit)");
    cascade.Apply();
  }
  {
    TestCascade cascade(GetDocument());
    cascade.Add("display:var(--u,unset)");
    cascade.Add("margin:var(--u,unset)");
    cascade.Apply();
  }
  {
    TestCascade cascade(GetDocument());
    cascade.Add("display:var(--u,revert)");
    cascade.Add("margin:var(--u,revert)");
    cascade.Apply();
  }

  // TODO(crbug.com/1105782): Specs and WPT are currently in conflict
  // regarding the correct behavior here. For now this test just verifies
  // that we don't crash.
}

TEST_F(StyleCascadeTest, RegisteredInitial) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Apply();
  EXPECT_EQ("0px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, SubstituteRegisteredImplicitInitialValue) {
  RegisterProperty(GetDocument(), "--x", "<length>", "13px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--y", " var(--x) ");
  cascade.Apply();
  EXPECT_EQ("13px", cascade.ComputedValue("--x"));
  EXPECT_EQ(" 13px ", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, SubstituteRegisteredUniversal) {
  RegisterProperty(GetDocument(), "--x", "*", "foo", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "bar");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();
  EXPECT_EQ("bar", cascade.ComputedValue("--x"));
  EXPECT_EQ("bar", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, SubstituteRegisteredUniversalInvalid) {
  RegisterProperty(GetDocument(), "--x", "*", base::nullopt, false);

  TestCascade cascade(GetDocument());
  cascade.Add("--y", " var(--x) ");
  cascade.Apply();
  EXPECT_FALSE(cascade.ComputedValue("--x"));
  EXPECT_FALSE(cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, SubstituteRegisteredUniversalInitial) {
  RegisterProperty(GetDocument(), "--x", "*", "foo", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--y", " var(--x) ");
  cascade.Apply();
  EXPECT_EQ("foo", cascade.ComputedValue("--x"));
  EXPECT_EQ(" foo ", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RegisteredExplicitInitial) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "10px");
  cascade.Apply();
  EXPECT_EQ("10px", cascade.ComputedValue("--x"));

  cascade.Reset();
  cascade.Add("--x", "initial");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();
  EXPECT_EQ("0px", cascade.ComputedValue("--x"));
  EXPECT_EQ("0px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RegisteredExplicitInherit) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade parent(GetDocument());
  parent.Add("--x", "15px");
  parent.Apply();
  EXPECT_EQ("15px", parent.ComputedValue("--x"));

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  cascade.Apply();
  EXPECT_EQ("0px", cascade.ComputedValue("--x"));  // Note: inherit==false

  cascade.Reset();
  cascade.Add("--x", "inherit");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();
  EXPECT_EQ("15px", cascade.ComputedValue("--x"));
  EXPECT_EQ("15px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, RegisteredExplicitUnset) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--y", "<length>", "0px", true);

  TestCascade parent(GetDocument());
  parent.Add("--x", "15px");
  parent.Add("--y", "15px");
  parent.Apply();
  EXPECT_EQ("15px", parent.ComputedValue("--x"));
  EXPECT_EQ("15px", parent.ComputedValue("--y"));

  TestCascade cascade(GetDocument());
  cascade.InheritFrom(parent.TakeStyle());
  cascade.Add("--x", "2px");
  cascade.Add("--y", "2px");
  cascade.Apply();
  EXPECT_EQ("2px", cascade.ComputedValue("--x"));
  EXPECT_EQ("2px", cascade.ComputedValue("--y"));

  cascade.Reset();
  cascade.Add("--x", "unset");
  cascade.Add("--y", "unset");
  cascade.Add("--z", "var(--x) var(--y)");
  cascade.Apply();
  EXPECT_EQ("0px", cascade.ComputedValue("--x"));
  EXPECT_EQ("15px", cascade.ComputedValue("--y"));
  EXPECT_EQ("0px 15px", cascade.ComputedValue("--z"));
}

TEST_F(StyleCascadeTest, SubstituteAnimationTaintedInCustomProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add(AnimationTaintedSet("--x", "15px"));
  cascade.Add("--y", "var(--x)");
  cascade.Apply();
  EXPECT_EQ("15px", cascade.ComputedValue("--x"));
  EXPECT_EQ("15px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, SubstituteAnimationTaintedInStandardProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add(AnimationTaintedSet("--x", "15px"));
  cascade.Add("width", "var(--x)");
  cascade.Apply();
  EXPECT_EQ("15px", cascade.ComputedValue("--x"));
  EXPECT_EQ("15px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, SubstituteAnimationTaintedInAnimationProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "20s");
  cascade.Add("animation-duration", "var(--x)");
  cascade.Apply();

  EXPECT_EQ("20s", cascade.ComputedValue("--x"));
  EXPECT_EQ("20s", cascade.ComputedValue("animation-duration"));

  cascade.Reset();
  cascade.Add(AnimationTaintedSet("--y", "20s"));
  cascade.Add("animation-duration", "var(--y)");
  cascade.Apply();

  EXPECT_EQ("20s", cascade.ComputedValue("--y"));
  EXPECT_EQ("0s", cascade.ComputedValue("animation-duration"));
}

TEST_F(StyleCascadeTest, IndirectlyAnimationTainted) {
  TestCascade cascade(GetDocument());
  cascade.Add(AnimationTaintedSet("--x", "20s"));
  cascade.Add("--y", "var(--x)");
  cascade.Add("animation-duration", "var(--y)");
  cascade.Apply();

  EXPECT_EQ("20s", cascade.ComputedValue("--x"));
  EXPECT_EQ("20s", cascade.ComputedValue("--y"));
  EXPECT_EQ("0s", cascade.ComputedValue("animation-duration"));
}

TEST_F(StyleCascadeTest, AnimationTaintedFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add(AnimationTaintedSet("--x", "20s"));
  cascade.Add("animation-duration", "var(--x,1s)");
  cascade.Apply();

  EXPECT_EQ("20s", cascade.ComputedValue("--x"));
  EXPECT_EQ("1s", cascade.ComputedValue("animation-duration"));
}

TEST_F(StyleCascadeTest, EnvMissingNestedVar) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "rgb(0, 0, 0)");
  cascade.Add("background-color", "env(missing, var(--x))");
  cascade.Apply();

  EXPECT_EQ("rgb(0, 0, 0)", cascade.ComputedValue("--x"));
  EXPECT_EQ("rgb(0, 0, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, EnvMissingNestedVarFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("background-color", "env(missing, var(--missing, blue))");
  cascade.Apply();

  EXPECT_EQ("rgb(0, 0, 255)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, EnvMissingFallback) {
  TestCascade cascade(GetDocument());
  cascade.Add("background-color", "env(missing, blue)");
  cascade.Apply();

  EXPECT_EQ("rgb(0, 0, 255)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, ValidEnv) {
  AutoEnv env(*this, "test", "red");

  TestCascade cascade(GetDocument());
  cascade.Add("background-color", "env(test, blue)");
  cascade.Apply();

  EXPECT_EQ("rgb(255, 0, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, ValidEnvFallback) {
  AutoEnv env(*this, "test", "red");

  TestCascade cascade(GetDocument());
  cascade.Add("background-color", "env(test, blue)");
  cascade.Apply();

  EXPECT_EQ("rgb(255, 0, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, ValidEnvInUnusedFallback) {
  AutoEnv env(*this, "test", "red");

  TestCascade cascade(GetDocument());
  cascade.Add("--x", "rgb(0, 0, 0)");
  cascade.Add("background-color", "var(--x, env(test))");
  cascade.Apply();

  EXPECT_EQ("rgb(0, 0, 0)", cascade.ComputedValue("--x"));
  EXPECT_EQ("rgb(0, 0, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, ValidEnvInUsedFallback) {
  AutoEnv env(*this, "test", "red");

  TestCascade cascade(GetDocument());
  cascade.Add("background-color", "var(--missing, env(test))");
  cascade.Apply();

  EXPECT_EQ("rgb(255, 0, 0)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, AnimationApplyFilter) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { color: white; background-color: white; }
        to { color: gray; background-color: gray; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation: test linear 10s -5s");
  cascade.Add("color:green");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply(CascadeFilter(CSSProperty::kInherited, true));

  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));
  EXPECT_EQ("rgb(192, 192, 192)", cascade.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, TransitionApplyFilter) {
  TestCascade cascade1(GetDocument());
  cascade1.Add("background-color: white");
  cascade1.Add("color: white");
  cascade1.Add("transition: all steps(2, start) 100s");
  cascade1.Apply();

  // Set the old style on the element, so that the transition
  // update detects it.
  GetDocument().body()->SetComputedStyle(cascade1.TakeStyle());

  // Now simulate a new style, with new color values.
  TestCascade cascade2(GetDocument());
  cascade2.Add("background-color: gray");
  cascade2.Add("color: gray");
  cascade2.Add("transition: all steps(2, start) 100s");
  cascade2.Apply();

  cascade2.CalculateTransitionUpdate();
  cascade2.Apply(CascadeFilter(CSSProperty::kInherited, true));

  EXPECT_EQ("rgb(128, 128, 128)", cascade2.ComputedValue("color"));
  EXPECT_EQ("rgb(192, 192, 192)", cascade2.ComputedValue("background-color"));
}

TEST_F(StyleCascadeTest, PendingKeyframeAnimation) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 10px; }
        to { --x: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "1s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetPriority("--x").GetOrigin());
}

TEST_F(StyleCascadeTest, PendingKeyframeAnimationApply) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 10px; }
        to { --x: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetPriority("--x").GetOrigin());
  EXPECT_EQ("15px", cascade.ComputedValue("--x"));
}

TEST_F(StyleCascadeTest, TransitionCausesInterpolationValue) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  // First, simulate an "old style".
  TestCascade cascade1(GetDocument());
  cascade1.Add("--x", "10px");
  cascade1.Add("transition", "--x 1s");
  cascade1.Apply();

  // Set the old style on the element, so that the animation
  // update detects it.
  GetDocument().body()->SetComputedStyle(cascade1.TakeStyle());

  // Now simulate a new style, with a new value for --x.
  TestCascade cascade2(GetDocument());
  cascade2.Add("--x", "20px");
  cascade2.Add("transition", "--x 1s");
  cascade2.Apply();

  cascade2.CalculateTransitionUpdate();
  cascade2.Apply();

  EXPECT_EQ(CascadeOrigin::kTransition,
            cascade2.GetPriority("--x").GetOrigin());
}

TEST_F(StyleCascadeTest, TransitionDetectedForChangedFontSize) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  TestCascade cascade1(GetDocument());
  cascade1.Add("font-size", "10px");
  cascade1.Add("--x", "10em");
  cascade1.Add("width", "10em");
  cascade1.Add("height", "10px");
  cascade1.Add("transition", "--x 1s, width 1s");
  cascade1.Apply();

  GetDocument().body()->SetComputedStyle(cascade1.TakeStyle());

  TestCascade cascade2(GetDocument());
  cascade2.Add("font-size", "20px");
  cascade2.Add("--x", "10em");
  cascade2.Add("width", "10em");
  cascade2.Add("height", "10px");
  cascade2.Add("transition", "--x 1s, width 1s");
  cascade2.Apply();

  cascade2.CalculateTransitionUpdate();
  cascade2.Apply();

  EXPECT_EQ(CascadeOrigin::kTransition, cascade2.GetOrigin("--x"));
  EXPECT_EQ(CascadeOrigin::kTransition, cascade2.GetOrigin("width"));
  EXPECT_EQ("10px", cascade2.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, AnimatingVarReferences) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: var(--from); }
        to { --x: var(--to); }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Add("--from", "10px");
  cascade.Add("--to", "20px");
  cascade.Add("--y", "var(--x)");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("15px", cascade.ComputedValue("--x"));
  EXPECT_EQ("15px", cascade.ComputedValue("--y"));
}

TEST_F(StyleCascadeTest, AnimateStandardProperty) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { width: 10px; }
        to { width: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("width"));
  EXPECT_EQ("15px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, AnimateLogicalProperty) {
  // We don't support smooth interpolation of css-logical properties yet,
  // so this test uses a paused animation at t=0.
  // TODO(crbug.com/865579): Support animations of css-logical properties

  AppendSheet(R"HTML(
     @keyframes test {
        from { margin-inline-start: 10px; }
        to { margin-inline-start: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("margin-left:1000px");
  cascade.Add("animation:test 1s linear paused");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-left"));
  EXPECT_EQ("10px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, AnimateLogicalPropertyWithLookup) {
  // We don't support smooth interpolation of css-logical properties yet,
  // so this test uses a paused animation at t=0.
  // TODO(crbug.com/865579): Support animations of css-logical properties

  AppendSheet(R"HTML(
     @keyframes test {
        from { margin-inline-start: 10px; }
        to { margin-inline-start: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("margin-left:1000px");
  cascade.Add("animation:test 1s linear paused");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.ApplySingle(GetCSSPropertyMarginLeft());

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-left"));
  EXPECT_EQ("10px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, AuthorImportantWinOverAnimations) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { width: 10px; height: 10px; }
        to { width: 20px; height: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Add("width:40px");
  cascade.Add("height:40px !important");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("width"));
  EXPECT_EQ(CascadeOrigin::kAuthor, cascade.GetOrigin("height"));

  EXPECT_EQ("15px", cascade.ComputedValue("width"));
  EXPECT_EQ("40px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, TransitionsWinOverAuthorImportant) {
  // First, simulate an "old style".
  TestCascade cascade1(GetDocument());
  cascade1.Add("width:10px !important");
  cascade1.Add("height:10px !important");
  cascade1.Add("transition:all 1s");
  cascade1.Apply();

  // Set the old style on the element, so that the animation
  // update detects it.
  GetDocument().body()->SetComputedStyle(cascade1.TakeStyle());

  // Now simulate a new style, with a new value for width/height.
  TestCascade cascade2(GetDocument());
  cascade2.Add("width:20px !important");
  cascade2.Add("height:20px !important");
  cascade2.Add("transition:all 1s");
  cascade2.Apply();

  cascade2.CalculateTransitionUpdate();
  cascade2.Apply();

  EXPECT_EQ(CascadeOrigin::kTransition,
            cascade2.GetPriority("width").GetOrigin());
  EXPECT_EQ(CascadeOrigin::kTransition,
            cascade2.GetPriority("height").GetOrigin());
}

TEST_F(StyleCascadeTest, EmRespondsToAnimatedFontSize) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { font-size: 10px; }
        to { font-size: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Add("--x", "2em");
  cascade.Add("width", "10em");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("30px", cascade.ComputedValue("--x"));
  EXPECT_EQ("150px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, AnimateStandardPropertyWithVar) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { width: var(--from); }
        to { width: var(--to); }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Add("--from", "10px");
  cascade.Add("--to", "20px");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ("15px", cascade.ComputedValue("width"));
}

TEST_F(StyleCascadeTest, AnimateStandardShorthand) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { margin: 10px; }
        to { margin: 20px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-top"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-right"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-bottom"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-left"));

  EXPECT_EQ("15px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, AnimatedVisitedImportantOverride) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { background-color: rgb(100, 100, 100); }
        to { background-color: rgb(200, 200, 200); }
     }
    )HTML");

  TestCascade cascade(GetDocument());
  cascade.State().Style()->SetInsideLink(EInsideLink::kInsideVisitedLink);

  cascade.Add(ParseDeclarationBlock("background-color:red !important"),
              CascadeOrigin::kAuthor, CSSSelector::kMatchVisited);
  cascade.Add("animation-name:test");
  cascade.Add("animation-duration:10s");
  cascade.Add("animation-timing-function:linear");
  cascade.Add("animation-delay:-5s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();
  EXPECT_EQ("rgb(150, 150, 150)", cascade.ComputedValue("background-color"));

  auto style = cascade.TakeStyle();

  style->SetInsideLink(EInsideLink::kInsideVisitedLink);
  EXPECT_EQ(Color(255, 0, 0),
            style->VisitedDependentColor(GetCSSPropertyBackgroundColor()));

  style->SetInsideLink(EInsideLink::kNotInsideLink);
  EXPECT_EQ(Color(150, 150, 150),
            style->VisitedDependentColor(GetCSSPropertyBackgroundColor()));
}

TEST_F(StyleCascadeTest, AnimatedVisitedHighPrio) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { color: rgb(100, 100, 100); }
        to { color: rgb(200, 200, 200); }
     }
    )HTML");

  TestCascade cascade(GetDocument());
  cascade.Add("color:red");
  cascade.Add("animation:test 10s -5s linear");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();
  EXPECT_EQ("rgb(150, 150, 150)", cascade.ComputedValue("color"));

  auto style = cascade.TakeStyle();

  style->SetInsideLink(EInsideLink::kInsideVisitedLink);
  EXPECT_EQ(Color(150, 150, 150),
            style->VisitedDependentColor(GetCSSPropertyColor()));

  style->SetInsideLink(EInsideLink::kNotInsideLink);
  EXPECT_EQ(Color(150, 150, 150),
            style->VisitedDependentColor(GetCSSPropertyColor()));
}

TEST_F(StyleCascadeTest, AnimatePendingSubstitutionValue) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);

  AppendSheet(R"HTML(
     @keyframes test {
        from { margin: var(--from); }
        to { margin: var(--to); }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name", "test");
  cascade.Add("animation-duration", "10s");
  cascade.Add("animation-timing-function", "linear");
  cascade.Add("animation-delay", "-5s");
  cascade.Add("--from", "10px");
  cascade.Add("--to", "20px");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-top"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-right"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-bottom"));
  EXPECT_EQ(CascadeOrigin::kAnimation, cascade.GetOrigin("margin-left"));

  EXPECT_EQ("15px", cascade.ComputedValue("margin-top"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-right"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-bottom"));
  EXPECT_EQ("15px", cascade.ComputedValue("margin-left"));
}

TEST_F(StyleCascadeTest, ZoomCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("zoom:200%", CascadeOrigin::kUserAgent);
  cascade.Add("zoom:normal", CascadeOrigin::kUserAgent);
  cascade.Apply();

  EXPECT_EQ(1.0f, cascade.TakeStyle()->EffectiveZoom());
}

TEST_F(StyleCascadeTest, ZoomVsAll) {
  TestCascade cascade(GetDocument());
  cascade.Add("zoom:200%", CascadeOrigin::kUserAgent);
  cascade.Add("all:initial");
  cascade.Apply();

  EXPECT_EQ(1.0f, cascade.TakeStyle()->EffectiveZoom());
}

TEST_F(StyleCascadeTest, ZoomReversedCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("zoom:normal", CascadeOrigin::kUserAgent);
  cascade.Add("zoom:200%", CascadeOrigin::kUserAgent);
  cascade.Apply();

  EXPECT_EQ(2.0f, cascade.TakeStyle()->EffectiveZoom());
}

TEST_F(StyleCascadeTest, ZoomImportant) {
  TestCascade cascade(GetDocument());
  cascade.Add("zoom:200% !important", CascadeOrigin::kUserAgent);
  cascade.Add("zoom:normal", CascadeOrigin::kAuthor);
  cascade.Apply();

  EXPECT_EQ(2.0f, cascade.TakeStyle()->EffectiveZoom());
}

TEST_F(StyleCascadeTest, WritingModeCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("writing-mode", "vertical-lr");
  cascade.Add("-webkit-writing-mode", "vertical-rl");
  cascade.Apply();

  EXPECT_EQ("vertical-rl", cascade.ComputedValue("writing-mode"));
  EXPECT_EQ("vertical-rl", cascade.ComputedValue("-webkit-writing-mode"));
}

TEST_F(StyleCascadeTest, WritingModeReversedCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-writing-mode", "vertical-rl");
  cascade.Add("writing-mode", "vertical-lr");
  cascade.Apply();

  EXPECT_EQ("vertical-lr", cascade.ComputedValue("writing-mode"));
  EXPECT_EQ("vertical-lr", cascade.ComputedValue("-webkit-writing-mode"));
}

TEST_F(StyleCascadeTest, WritingModePriority) {
  TestCascade cascade(GetDocument());
  cascade.Add("writing-mode:vertical-lr !important", Origin::kAuthor);
  cascade.Add("-webkit-writing-mode:vertical-rl", Origin::kAuthor);
  cascade.Apply();

  EXPECT_EQ("vertical-lr", cascade.ComputedValue("writing-mode"));
  EXPECT_EQ("vertical-lr", cascade.ComputedValue("-webkit-writing-mode"));
}

TEST_F(StyleCascadeTest, RubyPositionCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("ruby-position", "over");
  cascade.Add("-webkit-ruby-position", "after");
  cascade.Apply();

  EXPECT_EQ("under", cascade.ComputedValue("ruby-position"));
  EXPECT_EQ("after", cascade.ComputedValue("-webkit-ruby-position"));
}

TEST_F(StyleCascadeTest, RubyPositionReverseCascadeOrder) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-ruby-position", "after");
  cascade.Add("ruby-position", "over");
  cascade.Apply();

  EXPECT_EQ("over", cascade.ComputedValue("ruby-position"));
  EXPECT_EQ("before", cascade.ComputedValue("-webkit-ruby-position"));
}

TEST_F(StyleCascadeTest, RubyPositionSurrogateCanCascadeAsOriginal) {
  // Note: ruby-position is defined as the surrogate, and -webkit-ruby-position
  // is the original.
  ASSERT_TRUE(GetCSSPropertyRubyPosition().IsSurrogate());
  ASSERT_FALSE(GetCSSPropertyWebkitRubyPosition().IsSurrogate());

  const struct {
    CSSValueID specified;
    const char* webkit_expected;
    const char* unprefixed_expected;
  } tests[] = {
      {CSSValueID::kBefore, "before", "over"},
      {CSSValueID::kAfter, "after", "under"},
      {CSSValueID::kOver, "before", "over"},
      {CSSValueID::kUnder, "after", "under"},
  };

  for (const auto& test : tests) {
    TestCascade cascade(GetDocument());
    auto* set =
        MakeGarbageCollected<MutableCSSPropertyValueSet>(kHTMLStandardMode);
    set->SetProperty(CSSPropertyID::kWebkitRubyPosition,
                     *CSSIdentifierValue::Create(test.specified));
    cascade.Add(set);
    cascade.Apply();
    EXPECT_EQ(test.unprefixed_expected, cascade.ComputedValue("ruby-position"));
    EXPECT_EQ(test.webkit_expected,
              cascade.ComputedValue("-webkit-ruby-position"));
  }
}

TEST_F(StyleCascadeTest, TextOrientationPriority) {
  TestCascade cascade(GetDocument());
  cascade.Add("text-orientation:upright !important");
  cascade.Add("-webkit-text-orientation:sideways");
  cascade.Apply();

  EXPECT_EQ("upright", cascade.ComputedValue("text-orientation"));
  EXPECT_EQ("upright", cascade.ComputedValue("-webkit-text-orientation"));
}

TEST_F(StyleCascadeTest, TextOrientationRevert) {
  TestCascade cascade(GetDocument());
  cascade.Add("text-orientation:upright", CascadeOrigin::kUserAgent);
  cascade.Add("-webkit-text-orientation:mixed");
  cascade.Add("-webkit-text-orientation:revert");
  cascade.Apply();

  EXPECT_EQ("upright", cascade.ComputedValue("text-orientation"));
  EXPECT_EQ("upright", cascade.ComputedValue("-webkit-text-orientation"));
}

TEST_F(StyleCascadeTest, TextOrientationLegacyKeyword) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-text-orientation:vertical-right");
  cascade.Apply();

  EXPECT_EQ("mixed", cascade.ComputedValue("text-orientation"));
  EXPECT_EQ("vertical-right",
            cascade.ComputedValue("-webkit-text-orientation"));
}

TEST_F(StyleCascadeTest, WebkitBorderImageCascadeOrder) {
  String gradient1("linear-gradient(rgb(0, 0, 0), rgb(0, 128, 0))");
  String gradient2("linear-gradient(rgb(0, 0, 0), rgb(0, 200, 0))");

  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-border-image", gradient1 + " round 40 / 10px / 20px",
              Origin::kAuthor);
  cascade.Add("border-image-source", gradient2, Origin::kAuthor);
  cascade.Add("border-image-slice", "20", Origin::kAuthor);
  cascade.Add("border-image-width", "6px", Origin::kAuthor);
  cascade.Add("border-image-outset", "4px", Origin::kAuthor);
  cascade.Add("border-image-repeat", "space", Origin::kAuthor);
  cascade.Apply();

  EXPECT_EQ(gradient2, cascade.ComputedValue("border-image-source"));
  EXPECT_EQ("20", cascade.ComputedValue("border-image-slice"));
  EXPECT_EQ("6px", cascade.ComputedValue("border-image-width"));
  EXPECT_EQ("4px", cascade.ComputedValue("border-image-outset"));
  EXPECT_EQ("space", cascade.ComputedValue("border-image-repeat"));
}

TEST_F(StyleCascadeTest, WebkitBorderImageReverseCascadeOrder) {
  String gradient1("linear-gradient(rgb(0, 0, 0), rgb(0, 128, 0))");
  String gradient2("linear-gradient(rgb(0, 0, 0), rgb(0, 200, 0))");

  TestCascade cascade(GetDocument());
  cascade.Add("border-image-source", gradient2, Origin::kAuthor);
  cascade.Add("border-image-slice", "20", Origin::kAuthor);
  cascade.Add("border-image-width", "6px", Origin::kAuthor);
  cascade.Add("border-image-outset", "4px", Origin::kAuthor);
  cascade.Add("border-image-repeat", "space", Origin::kAuthor);
  cascade.Add("-webkit-border-image", gradient1 + " round 40 / 10px / 20px",
              Origin::kAuthor);
  cascade.Apply();

  EXPECT_EQ(gradient1, cascade.ComputedValue("border-image-source"));
  EXPECT_EQ("40 fill", cascade.ComputedValue("border-image-slice"));
  EXPECT_EQ("10px", cascade.ComputedValue("border-image-width"));
  EXPECT_EQ("20px", cascade.ComputedValue("border-image-outset"));
  EXPECT_EQ("round", cascade.ComputedValue("border-image-repeat"));
}

TEST_F(StyleCascadeTest, WebkitBorderImageMixedOrder) {
  String gradient1("linear-gradient(rgb(0, 0, 0), rgb(0, 128, 0))");
  String gradient2("linear-gradient(rgb(0, 0, 0), rgb(0, 200, 0))");

  TestCascade cascade(GetDocument());
  cascade.Add("border-image-source", gradient2, Origin::kAuthor);
  cascade.Add("border-image-width", "6px", Origin::kAuthor);
  cascade.Add("-webkit-border-image", gradient1 + " round 40 / 10px / 20px",
              Origin::kAuthor);
  cascade.Add("border-image-slice", "20", Origin::kAuthor);
  cascade.Add("border-image-outset", "4px", Origin::kAuthor);
  cascade.Add("border-image-repeat", "space", Origin::kAuthor);
  cascade.Apply();

  EXPECT_EQ(gradient1, cascade.ComputedValue("border-image-source"));
  EXPECT_EQ("20", cascade.ComputedValue("border-image-slice"));
  EXPECT_EQ("10px", cascade.ComputedValue("border-image-width"));
  EXPECT_EQ("4px", cascade.ComputedValue("border-image-outset"));
  EXPECT_EQ("space", cascade.ComputedValue("border-image-repeat"));
}

TEST_F(StyleCascadeTest, InitialDirection) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin-inline-start:10px");
  cascade.Add("margin-inline-end:20px");
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("margin-left"));
  EXPECT_EQ("20px", cascade.ComputedValue("margin-right"));
}

TEST_F(StyleCascadeTest, NonInitialDirection) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin-inline-start:10px");
  cascade.Add("margin-inline-end:20px");
  cascade.Add("direction:rtl");
  cascade.Apply();

  EXPECT_EQ("20px", cascade.ComputedValue("margin-left"));
  EXPECT_EQ("10px", cascade.ComputedValue("margin-right"));
}

TEST_F(StyleCascadeTest, InitialWritingMode) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px");
  cascade.Add("block-size:20px");
  cascade.Apply();

  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("20px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, NonInitialWritingMode) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px");
  cascade.Add("block-size:20px");
  cascade.Add("writing-mode:vertical-lr");
  cascade.Apply();

  EXPECT_EQ("20px", cascade.ComputedValue("width"));
  EXPECT_EQ("10px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, DoesNotDependOnCascadeAffectingProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:10px");
  cascade.Add("height:20px");
  cascade.Apply();

  EXPECT_FALSE(cascade.DependsOnCascadeAffectingProperty());
  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("20px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, DependsOnCascadeAffectingProperty) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px");
  cascade.Add("height:20px");
  cascade.Apply();

  EXPECT_TRUE(cascade.DependsOnCascadeAffectingProperty());
  EXPECT_EQ("10px", cascade.ComputedValue("width"));
  EXPECT_EQ("20px", cascade.ComputedValue("height"));
}

TEST_F(StyleCascadeTest, ResetDependsOnCascadeAffectingPropertyFlag) {
  TestCascade cascade(GetDocument());
  cascade.Add("inline-size:10px");
  cascade.Add("height:20px");
  cascade.Apply();

  EXPECT_TRUE(cascade.DependsOnCascadeAffectingProperty());
  cascade.Reset();
  EXPECT_FALSE(cascade.DependsOnCascadeAffectingProperty());
}

TEST_F(StyleCascadeTest, MarkReferenced) {
  RegisterProperty(GetDocument(), "--x", "<length>", "0px", false);
  RegisterProperty(GetDocument(), "--y", "<length>", "0px", false);

  TestCascade cascade(GetDocument());
  cascade.Add("width", "var(--x)");
  cascade.Apply();

  const auto& registry = GetDocument().EnsurePropertyRegistry();

  EXPECT_TRUE(registry.WasReferenced("--x"));
  EXPECT_FALSE(registry.WasReferenced("--y"));
}

TEST_F(StyleCascadeTest, MarkHasVariableReferenceLonghand) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "1px");
  cascade.Add("width", "var(--x)");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_TRUE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, MarkHasVariableReferenceShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x", "1px");
  cascade.Add("margin", "var(--x)");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_TRUE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, MarkHasVariableReferenceLonghandMissingVar) {
  TestCascade cascade(GetDocument());
  cascade.Add("width", "var(--x)");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_TRUE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, MarkHasVariableReferenceShorthandMissingVar) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin", "var(--x)");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_TRUE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, NoMarkHasVariableReferenceInherited) {
  TestCascade cascade(GetDocument());
  cascade.Add("color", "var(--x)");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, NoMarkHasVariableReferenceWithoutVar) {
  TestCascade cascade(GetDocument());
  cascade.Add("width", "1px");
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, InternalVisitedColorLonghand) {
  TestCascade cascade(GetDocument());
  cascade.Add("color:green", CascadeOrigin::kAuthor);
  cascade.Add("color:red", CascadeOrigin::kAuthor, CSSSelector::kMatchVisited);

  cascade.State().Style()->SetInsideLink(EInsideLink::kInsideVisitedLink);
  cascade.Apply();

  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));

  Color red(255, 0, 0);
  const CSSProperty& color = GetCSSPropertyColor();
  EXPECT_EQ(red, cascade.TakeStyle()->VisitedDependentColor(color));
}

TEST_F(StyleCascadeTest, VarInInternalVisitedColorShorthand) {
  TestCascade cascade(GetDocument());
  cascade.Add("--x:red", CascadeOrigin::kAuthor);
  cascade.Add("outline:medium solid var(--x)", CascadeOrigin::kAuthor,
              CSSSelector::kMatchVisited);
  cascade.Add("outline-color:green", CascadeOrigin::kAuthor,
              CSSSelector::kMatchLink);

  cascade.State().Style()->SetInsideLink(EInsideLink::kInsideVisitedLink);
  cascade.Apply();

  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("outline-color"));

  Color red(255, 0, 0);
  const CSSProperty& outline_color = GetCSSPropertyOutlineColor();
  EXPECT_EQ(red, cascade.TakeStyle()->VisitedDependentColor(outline_color));
}

TEST_F(StyleCascadeTest, ApplyWithFilter) {
  TestCascade cascade(GetDocument());
  cascade.Add("color", "blue", Origin::kAuthor);
  cascade.Add("background-color", "green", Origin::kAuthor);
  cascade.Add("display", "inline", Origin::kAuthor);
  cascade.Apply();

  cascade.Reset();
  cascade.Add("color", "green", Origin::kAuthor);
  cascade.Add("background-color", "red", Origin::kAuthor);
  cascade.Add("display", "block", Origin::kAuthor);
  cascade.Apply(CascadeFilter(CSSProperty::kInherited, false));
  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));
  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("background-color"));
  EXPECT_EQ("inline", cascade.ComputedValue("display"));
}

TEST_F(StyleCascadeTest, HasAuthorBackground) {
  Vector<String> properties = {"background-attachment", "background-blend-mode",
                               "background-clip",       "background-image",
                               "background-origin",     "background-position-x",
                               "background-position-y", "background-size"};

  for (String property : properties) {
    TestCascade cascade(GetDocument());
    cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
    cascade.Add(property, "unset", Origin::kAuthor);
    cascade.Apply();
    EXPECT_TRUE(cascade.TakeStyle()->HasAuthorBackground());
  }
}

TEST_F(StyleCascadeTest, HasAuthorBorder) {
  Vector<String> properties = {
      "border-top-color",          "border-right-color",
      "border-bottom-color",       "border-left-color",
      "border-top-style",          "border-right-style",
      "border-bottom-style",       "border-left-style",
      "border-top-width",          "border-right-width",
      "border-bottom-width",       "border-left-width",
      "border-top-left-radius",    "border-top-right-radius",
      "border-bottom-left-radius", "border-bottom-right-radius",
      "border-image-source",       "border-image-slice",
      "border-image-width",        "border-image-outset",
      "border-image-repeat"};

  for (String property : properties) {
    TestCascade cascade(GetDocument());
    cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
    cascade.Add(property, "unset", Origin::kAuthor);
    cascade.Apply();
    EXPECT_TRUE(cascade.TakeStyle()->HasAuthorBorder());
  }
}

TEST_F(StyleCascadeTest, HasAuthorBorderLogical) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
  cascade.Add("border-block-start-color", "red", Origin::kUserAgent);
  cascade.Add("border-block-start-color", "green", Origin::kAuthor);
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_TRUE(style->HasAuthorBorder());
}

TEST_F(StyleCascadeTest, NoAuthorBackgroundOrBorder) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
  cascade.Add("background-color", "red", Origin::kUserAgent);
  cascade.Add("border-left-color", "green", Origin::kUserAgent);
  cascade.Add("background-clip", "padding-box", Origin::kUser);
  cascade.Add("border-right-color", "green", Origin::kUser);
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasAuthorBackground());
  EXPECT_FALSE(style->HasAuthorBorder());
}

TEST_F(StyleCascadeTest, AuthorBackgroundRevert) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
  cascade.Add("background-color", "red", Origin::kUserAgent);
  cascade.Add("background-color", "revert", Origin::kAuthor);
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasAuthorBackground());
}

TEST_F(StyleCascadeTest, AuthorBorderRevert) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
  cascade.Add("border-top-color", "red", Origin::kUserAgent);
  cascade.Add("border-top-color", "revert", Origin::kAuthor);
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasAuthorBorder());
}

TEST_F(StyleCascadeTest, AuthorBorderRevertLogical) {
  TestCascade cascade(GetDocument());
  cascade.Add("-webkit-appearance", "button", Origin::kUserAgent);
  cascade.Add("border-block-start-color", "red", Origin::kUserAgent);
  cascade.Add("border-block-start-color", "revert", Origin::kAuthor);
  cascade.Apply();
  auto style = cascade.TakeStyle();
  EXPECT_FALSE(style->HasAuthorBorder());
}

TEST_F(StyleCascadeTest, AnalyzeMatchResult) {
  auto ua = CascadeOrigin::kUserAgent;
  auto author = CascadeOrigin::kAuthor;

  TestCascade cascade(GetDocument());
  cascade.Add("display:none;left:5px", ua);
  cascade.Add("font-size:1px !important", ua);
  cascade.Add("display:block;color:red", author);
  cascade.Add("font-size:3px", author);
  cascade.Apply();

  EXPECT_EQ(cascade.GetPriority("display").GetOrigin(), author);
  EXPECT_EQ(cascade.GetPriority("left").GetOrigin(), ua);
  EXPECT_EQ(cascade.GetPriority("color").GetOrigin(), author);
  EXPECT_EQ(cascade.GetPriority("font-size").GetOrigin(), ua);
}

TEST_F(StyleCascadeTest, AnalyzeMatchResultAll) {
  auto ua = CascadeOrigin::kUserAgent;
  auto author = CascadeOrigin::kAuthor;

  TestCascade cascade(GetDocument());
  cascade.Add("display:block", ua);
  cascade.Add("font-size:1px !important", ua);
  cascade.Add("all:unset", author);
  cascade.Apply();

  EXPECT_EQ(cascade.GetPriority("display").GetOrigin(), author);
  EXPECT_EQ(cascade.GetPriority("font-size").GetOrigin(), ua);

  // Random sample from another property affected by 'all'.
  EXPECT_EQ(cascade.GetPriority("color").GetOrigin(), author);
  EXPECT_EQ(cascade.GetPriority("color"), cascade.GetPriority("display"));
}

TEST_F(StyleCascadeTest, AnalyzeFlagsClean) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { top: 0px; }
        to { top: 10px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("bottom:10px");
  cascade.Add("animation:test linear 1000s -500s");
  cascade.Apply();
  EXPECT_FALSE(cascade.NeedsMatchResultAnalyze());
  EXPECT_FALSE(cascade.NeedsInterpolationsAnalyze());

  cascade.CalculateAnimationUpdate();
  cascade.Apply();
  EXPECT_FALSE(cascade.NeedsMatchResultAnalyze());
  EXPECT_FALSE(cascade.NeedsInterpolationsAnalyze());
}

TEST_F(StyleCascadeTest, ApplyMatchResultFilter) {
  TestCascade cascade(GetDocument());
  cascade.Add("display:block");
  cascade.Add("color:green");
  cascade.Add("font-size:3px");
  cascade.Apply();

  cascade.Reset();
  cascade.Add("display:inline");
  cascade.Add("color:red");
  cascade.Apply(CascadeFilter(CSSProperty::kInherited, true));

  EXPECT_EQ("inline", cascade.ComputedValue("display"));
  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));
  EXPECT_EQ("3px", cascade.ComputedValue("font-size"));
}

TEST_F(StyleCascadeTest, ApplyMatchResultAllFilter) {
  TestCascade cascade(GetDocument());
  cascade.Add("color:green");
  cascade.Add("display:block");
  cascade.Apply();

  cascade.Reset();
  cascade.Add("all:unset");
  cascade.Apply(CascadeFilter(CSSProperty::kInherited, true));

  EXPECT_EQ("rgb(0, 128, 0)", cascade.ComputedValue("color"));
  EXPECT_EQ("inline", cascade.ComputedValue("display"));
}

TEST_F(StyleCascadeTest, MarkHasReferenceLonghand) {
  TestCascade cascade(GetDocument());

  cascade.Add("--x:red");
  cascade.Add("background-color:var(--x)");
  cascade.Apply();

  EXPECT_TRUE(cascade.State()
                  .StyleRef()
                  .HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, MarkHasReferenceShorthand) {
  TestCascade cascade(GetDocument());

  cascade.Add("--x:red");
  cascade.Add("background:var(--x)");
  cascade.Apply();

  EXPECT_TRUE(cascade.State()
                  .StyleRef()
                  .HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, NoMarkHasReferenceForInherited) {
  TestCascade cascade(GetDocument());

  cascade.Add("--x:red");
  cascade.Add("--y:caption");
  cascade.Add("color:var(--x)");
  cascade.Add("font:var(--y)");
  cascade.Apply();

  EXPECT_FALSE(cascade.State()
                   .StyleRef()
                   .HasVariableReferenceFromNonInheritedProperty());
}

TEST_F(StyleCascadeTest, Reset) {
  TestCascade cascade(GetDocument());

  EXPECT_EQ(CascadePriority(), cascade.GetPriority("color"));
  EXPECT_EQ(CascadePriority(), cascade.GetPriority("--x"));

  cascade.Add("color:red");
  cascade.Add("--x:red");
  cascade.Apply();  // generation=1
  cascade.Apply();  // generation=2

  EXPECT_EQ(2u, cascade.GetPriority("color").GetGeneration());
  EXPECT_EQ(2u, cascade.GetPriority("--x").GetGeneration());

  cascade.Reset();

  EXPECT_EQ(CascadePriority(), cascade.GetPriority("color"));
  EXPECT_EQ(CascadePriority(), cascade.GetPriority("--x"));
}

TEST_F(StyleCascadeTest, GetImportantSetEmpty) {
  TestCascade cascade(GetDocument());
  cascade.Add("color:red");
  cascade.Add("width:1px");
  cascade.Add("--x:green");
  EXPECT_FALSE(cascade.GetImportantSet());
}

TEST_F(StyleCascadeTest, GetImportantSetSingle) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:1px !important");
  ASSERT_TRUE(cascade.GetImportantSet());
  EXPECT_EQ(CSSBitset({CSSPropertyID::kWidth}), *cascade.GetImportantSet());
}

TEST_F(StyleCascadeTest, GetImportantSetMany) {
  TestCascade cascade(GetDocument());
  cascade.Add("width:1px !important");
  cascade.Add("height:1px !important");
  cascade.Add("top:1px !important");
  ASSERT_TRUE(cascade.GetImportantSet());
  EXPECT_EQ(CSSBitset({CSSPropertyID::kWidth, CSSPropertyID::kHeight,
                       CSSPropertyID::kTop}),
            *cascade.GetImportantSet());
}

TEST_F(StyleCascadeTest, RootColorNotModifiedByEmptyCascade) {
  TestCascade cascade(GetDocument(), GetDocument().documentElement());
  cascade.Add("color:red");
  cascade.Apply();

  cascade.Reset();
  cascade.Add("display:block");
  cascade.Apply();  // Should not affect 'color'.

  auto style = cascade.TakeStyle();

  style->SetInsideLink(EInsideLink::kInsideVisitedLink);
  EXPECT_EQ(Color(255, 0, 0),
            style->VisitedDependentColor(GetCSSPropertyColor()));

  style->SetInsideLink(EInsideLink::kNotInsideLink);
  EXPECT_EQ(Color(255, 0, 0),
            style->VisitedDependentColor(GetCSSPropertyColor()));
}

TEST_F(StyleCascadeTest, InitialColor) {
  ColorSchemeHelper color_scheme_helper(GetDocument());
  color_scheme_helper.SetPreferredColorScheme(
      mojom::blink::PreferredColorScheme::kDark);

  TestCascade cascade(GetDocument(), GetDocument().documentElement());
  cascade.Add("color-scheme:dark");

  // CSSInitialColorValue is not reachable via a string, hence we must
  // create the CSSPropertyValueSet that contains it manually.
  auto* set =
      MakeGarbageCollected<MutableCSSPropertyValueSet>(kHTMLStandardMode);
  set->SetProperty(CSSPropertyID::kColor, *CSSInitialColorValue::Create());
  cascade.Add(set);

  cascade.Apply();

  auto style = cascade.TakeStyle();

  style->SetInsideLink(EInsideLink::kInsideVisitedLink);
  EXPECT_EQ(Color::kWhite, style->VisitedDependentColor(GetCSSPropertyColor()));

  style->SetInsideLink(EInsideLink::kNotInsideLink);
  EXPECT_EQ(Color::kWhite, style->VisitedDependentColor(GetCSSPropertyColor()));
}

TEST_F(StyleCascadeTest, MaxSubstitutionTokens) {
  StringBuilder builder;
  for (size_t i = 0; i < StyleCascade::kMaxSubstitutionTokens; ++i)
    builder.Append(':');  // <colon-token>

  String at_limit = builder.ToString();
  String above_limit = builder.ToString() + ":";

  TestCascade cascade(GetDocument());
  cascade.Add("--at-limit", at_limit);
  cascade.Add("--above-limit", above_limit);
  cascade.Add("--at-limit-reference", "var(--at-limit)");
  cascade.Add("--above-limit-reference", "var(--above-limit)");
  cascade.Add("--at-limit-reference-fallback",
              "var(--unknown,var(--at-limit))");
  cascade.Add("--above-limit-reference-fallback",
              "var(--unknown,var(--above-limit))");
  cascade.Apply();

  EXPECT_EQ(at_limit, cascade.ComputedValue("--at-limit"));
  EXPECT_EQ(above_limit, cascade.ComputedValue("--above-limit"));
  EXPECT_EQ(at_limit, cascade.ComputedValue("--at-limit-reference"));
  EXPECT_EQ(g_null_atom, cascade.ComputedValue("--above-limit-reference"));
  EXPECT_EQ(at_limit, cascade.ComputedValue("--at-limit-reference-fallback"));
  EXPECT_EQ(g_null_atom,
            cascade.ComputedValue("--above-limit-reference-fallback"));
}

TEST_F(StyleCascadeTest, GetCascadedValues) {
  TestCascade cascade(GetDocument());
  cascade.Add("top:1px", CascadeOrigin::kUserAgent);
  cascade.Add("right:2px", CascadeOrigin::kUserAgent);
  cascade.Add("bottom:3px", CascadeOrigin::kUserAgent);
  cascade.Add("left:4px !important", CascadeOrigin::kUserAgent);
  cascade.Add("width:5px", CascadeOrigin::kUserAgent);

  cascade.Add("top:10px", CascadeOrigin::kUser);
  cascade.Add("right:20px", CascadeOrigin::kUser);
  cascade.Add("bottom:30px !important", CascadeOrigin::kUser);
  cascade.Add("left:40px", CascadeOrigin::kUser);
  cascade.Add("height:60px", CascadeOrigin::kUser);
  cascade.Add("height:61px", CascadeOrigin::kUser);
  cascade.Add("--x:70px", CascadeOrigin::kUser);
  cascade.Add("--y:80px !important", CascadeOrigin::kUser);

  cascade.Add("top:100px", CascadeOrigin::kAuthor);
  cascade.Add("right:201px !important", CascadeOrigin::kAuthor);
  cascade.Add("right:200px", CascadeOrigin::kAuthor);
  cascade.Add("bottom:300px", CascadeOrigin::kAuthor);
  cascade.Add("left:400px", CascadeOrigin::kAuthor);
  cascade.Add("--x:700px", CascadeOrigin::kAuthor);
  cascade.Add("--y:800px", CascadeOrigin::kAuthor);

  cascade.Apply();

  auto map = cascade.GetCascadedValues();
  EXPECT_EQ(8u, map.size());

  EXPECT_EQ("100px", CssTextAt(map, "top"));
  EXPECT_EQ("201px", CssTextAt(map, "right"));
  EXPECT_EQ("30px", CssTextAt(map, "bottom"));
  EXPECT_EQ("4px", CssTextAt(map, "left"));
  EXPECT_EQ("5px", CssTextAt(map, "width"));
  EXPECT_EQ("61px", CssTextAt(map, "height"));
  EXPECT_EQ("700px", CssTextAt(map, "--x"));
  EXPECT_EQ("80px ", CssTextAt(map, "--y"));
}

TEST_F(StyleCascadeTest, GetCascadedValuesCssWide) {
  TestCascade cascade(GetDocument());
  cascade.Add("top:initial");
  cascade.Add("right:inherit");
  cascade.Add("bottom:unset");
  cascade.Add("left:revert");
  cascade.Apply();

  auto map = cascade.GetCascadedValues();
  EXPECT_EQ(4u, map.size());

  EXPECT_EQ("initial", CssTextAt(map, "top"));
  EXPECT_EQ("inherit", CssTextAt(map, "right"));
  EXPECT_EQ("unset", CssTextAt(map, "bottom"));
  EXPECT_EQ("revert", CssTextAt(map, "left"));
}

TEST_F(StyleCascadeTest, GetCascadedValuesLogical) {
  TestCascade cascade(GetDocument());
  cascade.Add("margin-inline-start:1px");
  cascade.Add("margin-inline-end:2px");
  cascade.Apply();

  auto map = cascade.GetCascadedValues();
  EXPECT_EQ(2u, map.size());

  EXPECT_EQ("1px", CssTextAt(map, "margin-left"));
  EXPECT_EQ("2px", CssTextAt(map, "margin-right"));
}

TEST_F(StyleCascadeTest, GetCascadedValuesInterpolated) {
  AppendSheet(R"HTML(
     @keyframes test {
        from { --x: 100px; width: 100px; }
        to { --x: 200px; width: 200px; }
     }
    )HTML");

  TestCascade cascade(GetDocument());

  cascade.Add("animation-name: test");
  cascade.Add("animation-timing-function: linear");
  cascade.Add("animation-duration: 10s");
  cascade.Add("animation-delay: -5s");
  cascade.Apply();

  cascade.CalculateAnimationUpdate();
  cascade.Apply();

  // Verify that effect values from the animation did apply:
  EXPECT_EQ(" 200px", cascade.ComputedValue("--x"));
  EXPECT_EQ("150px", cascade.ComputedValue("width"));

  // However, we don't currently support returning interpolated vales from
  // GetCascadedValues:
  auto map = cascade.GetCascadedValues();
  EXPECT_EQ(4u, map.size());

  EXPECT_EQ("test", CssTextAt(map, "animation-name"));
  EXPECT_EQ("linear", CssTextAt(map, "animation-timing-function"));
  EXPECT_EQ("10s", CssTextAt(map, "animation-duration"));
  EXPECT_EQ("-5s", CssTextAt(map, "animation-delay"));
}

TEST_F(StyleCascadeTest, RevertOrigin) {
  TestCascade cascade(GetDocument());

  cascade.Add("width", "1px", CascadeOrigin::kUserAgent);
  cascade.Add("height", "1px", CascadeOrigin::kUserAgent);
  cascade.Add("display", "block", CascadeOrigin::kUserAgent);
  cascade.Add("width", "2px", CascadeOrigin::kUser);
  cascade.Add("height", "revert", CascadeOrigin::kUser);
  cascade.Add("width", "revert", CascadeOrigin::kAuthor);
  cascade.Add("height", "revert", CascadeOrigin::kAuthor);
  cascade.Add("display", "revert", CascadeOrigin::kAuthor);
  cascade.Add("margin-left", "revert", CascadeOrigin::kAuthor);

  cascade.AnalyzeIfNeeded();

  CSSValue* revert_value = cssvalue::CSSRevertValue::Create();

  TestCascadeResolver resolver;

  CascadeOrigin origin = CascadeOrigin::kAuthor;
  const CSSValue* resolved_value =
      cascade.Resolve(GetCSSPropertyWidth(), *revert_value, origin);
  ASSERT_TRUE(resolved_value);
  EXPECT_EQ(CascadeOrigin::kUser, origin);
  EXPECT_EQ("2px", resolved_value->CssText());

  origin = CascadeOrigin::kAuthor;
  resolved_value =
      cascade.Resolve(GetCSSPropertyHeight(), *revert_value, origin);
  ASSERT_TRUE(resolved_value);
  EXPECT_EQ(CascadeOrigin::kUserAgent, origin);
  EXPECT_EQ("1px", resolved_value->CssText());

  origin = CascadeOrigin::kAuthor;
  resolved_value =
      cascade.Resolve(GetCSSPropertyDisplay(), *revert_value, origin);
  ASSERT_TRUE(resolved_value);
  EXPECT_EQ(CascadeOrigin::kUserAgent, origin);
  EXPECT_EQ("block", resolved_value->CssText());

  origin = CascadeOrigin::kAuthor;
  resolved_value =
      cascade.Resolve(GetCSSPropertyMarginLeft(), *revert_value, origin);
  ASSERT_TRUE(resolved_value);
  EXPECT_EQ(CascadeOrigin::kNone, origin);
  EXPECT_EQ("unset", resolved_value->CssText());
}

}  // namespace blink