// Copyright 2014 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/animation/keyframe_effect.h"

#include <memory>

#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h"
#include "third_party/blink/renderer/bindings/core/v8/unrestricted_double_or_keyframe_effect_options.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_testing.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_effect_timing.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_keyframe_effect_options.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_object_builder.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_optional_effect_timing.h"
#include "third_party/blink/renderer/core/animation/animation.h"
#include "third_party/blink/renderer/core/animation/animation_clock.h"
#include "third_party/blink/renderer/core/animation/animation_test_helpers.h"
#include "third_party/blink/renderer/core/animation/document_timeline.h"
#include "third_party/blink/renderer/core/animation/keyframe_effect_model.h"
#include "third_party/blink/renderer/core/animation/timing.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/dom/node_computed_style.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/core/testing/page_test_base.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h"
#include "v8/include/v8.h"

namespace blink {

#define EXPECT_TIMEDELTA(expected, observed)                          \
  EXPECT_NEAR(expected.InMillisecondsF(), observed.InMillisecondsF(), \
              Animation::kTimeToleranceMs)

using animation_test_helpers::SetV8ObjectPropertyAsNumber;
using animation_test_helpers::SetV8ObjectPropertyAsString;

class KeyframeEffectTest : public PageTestBase {
 protected:
  void SetUp() override {
    PageTestBase::SetUp(IntSize());
    element = GetDocument().CreateElementForBinding("foo");
    GetDocument().documentElement()->AppendChild(element.Get());
  }

  KeyframeEffectModelBase* CreateEmptyEffectModel() {
    return MakeGarbageCollected<StringKeyframeEffectModel>(
        StringKeyframeVector());
  }

  // Returns a two-frame effect updated styles.
  KeyframeEffect* GetTwoFrameEffect(const CSSPropertyID& property,
                                    const String& value_a,
                                    const String& value_b) {
    StringKeyframeVector keyframes(2);
    keyframes[0] = MakeGarbageCollected<StringKeyframe>();
    keyframes[0]->SetOffset(0.0);
    keyframes[0]->SetCSSPropertyValue(
        property, value_a, SecureContextMode::kInsecureContext, nullptr);
    keyframes[1] = MakeGarbageCollected<StringKeyframe>();
    keyframes[1]->SetOffset(1.0);
    keyframes[1]->SetCSSPropertyValue(
        property, value_b, SecureContextMode::kInsecureContext, nullptr);
    auto* model = MakeGarbageCollected<StringKeyframeEffectModel>(keyframes);
    Timing timing;
    auto* effect = MakeGarbageCollected<KeyframeEffect>(element, model, timing);
    // Ensure GetCompositorKeyframeValue is updated which would normally happen
    // when applying the animation styles.
    UpdateAllLifecyclePhasesForTest();
    model->SnapshotAllCompositorKeyframesIfNecessary(
        *element, *element->GetComputedStyle(), nullptr);

    return effect;
  }

  Persistent<Element> element;
};

class AnimationKeyframeEffectV8Test : public KeyframeEffectTest {
 protected:
  static KeyframeEffect* CreateAnimationFromTiming(
      ScriptState* script_state,
      Element* element,
      const ScriptValue& keyframe_object,
      double timing_input) {
    NonThrowableExceptionState exception_state;
    return KeyframeEffect::Create(
        script_state, element, keyframe_object,
        UnrestrictedDoubleOrKeyframeEffectOptions::FromUnrestrictedDouble(
            timing_input),
        exception_state);
  }
  static KeyframeEffect* CreateAnimationFromOption(
      ScriptState* script_state,
      Element* element,
      const ScriptValue& keyframe_object,
      const KeyframeEffectOptions* timing_input) {
    NonThrowableExceptionState exception_state;
    return KeyframeEffect::Create(
        script_state, element, keyframe_object,
        UnrestrictedDoubleOrKeyframeEffectOptions::FromKeyframeEffectOptions(
            const_cast<KeyframeEffectOptions*>(timing_input)),
        exception_state);
  }
  static KeyframeEffect* CreateAnimation(ScriptState* script_state,
                                         Element* element,
                                         const ScriptValue& keyframe_object) {
    NonThrowableExceptionState exception_state;
    return KeyframeEffect::Create(script_state, element, keyframe_object,
                                  exception_state);
  }
};

TEST_F(AnimationKeyframeEffectV8Test, CanCreateAnAnimation) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  NonThrowableExceptionState exception_state;

  HeapVector<ScriptValue> blink_keyframes = {
      V8ObjectBuilder(script_state)
          .AddString("width", "100px")
          .AddString("offset", "0")
          .AddString("easing", "ease-in-out")
          .GetScriptValue(),
      V8ObjectBuilder(script_state)
          .AddString("width", "0px")
          .AddString("offset", "1")
          .AddString("easing", "cubic-bezier(1, 1, 0.3, 0.3)")
          .GetScriptValue()};

  ScriptValue js_keyframes(
      scope.GetIsolate(),
      ToV8(blink_keyframes, scope.GetContext()->Global(), scope.GetIsolate()));

  KeyframeEffect* animation =
      CreateAnimationFromTiming(script_state, element.Get(), js_keyframes, 0);

  Element* target = animation->target();
  EXPECT_EQ(*element.Get(), *target);

  const KeyframeVector keyframes = animation->Model()->GetFrames();

  EXPECT_EQ(0, keyframes[0]->CheckedOffset());
  EXPECT_EQ(1, keyframes[1]->CheckedOffset());

  const CSSValue& keyframe1_width =
      To<StringKeyframe>(*keyframes[0])
          .CssPropertyValue(PropertyHandle(GetCSSPropertyWidth()));
  const CSSValue& keyframe2_width =
      To<StringKeyframe>(*keyframes[1])
          .CssPropertyValue(PropertyHandle(GetCSSPropertyWidth()));

  EXPECT_EQ("100px", keyframe1_width.CssText());
  EXPECT_EQ("0px", keyframe2_width.CssText());

  EXPECT_EQ(*(CubicBezierTimingFunction::Preset(
                CubicBezierTimingFunction::EaseType::EASE_IN_OUT)),
            keyframes[0]->Easing());
  EXPECT_EQ(*(CubicBezierTimingFunction::Create(1, 1, 0.3, 0.3).get()),
            keyframes[1]->Easing());
}

TEST_F(AnimationKeyframeEffectV8Test, SetAndRetrieveEffectComposite) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  NonThrowableExceptionState exception_state;

  v8::Local<v8::Object> effect_options = v8::Object::New(scope.GetIsolate());
  SetV8ObjectPropertyAsString(scope.GetIsolate(), effect_options, "composite",
                              "add");
  KeyframeEffectOptions* effect_options_dictionary =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), effect_options, exception_state);
  EXPECT_FALSE(exception_state.HadException());

  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());
  KeyframeEffect* effect = CreateAnimationFromOption(
      script_state, element.Get(), js_keyframes, effect_options_dictionary);
  EXPECT_EQ("add", effect->composite());

  effect->setComposite("replace");
  EXPECT_EQ("replace", effect->composite());

  effect->setComposite("accumulate");
  EXPECT_EQ("accumulate", effect->composite());
}

TEST_F(AnimationKeyframeEffectV8Test, KeyframeCompositeOverridesEffect) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  NonThrowableExceptionState exception_state;

  v8::Local<v8::Object> effect_options = v8::Object::New(scope.GetIsolate());
  SetV8ObjectPropertyAsString(scope.GetIsolate(), effect_options, "composite",
                              "add");
  KeyframeEffectOptions* effect_options_dictionary =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), effect_options, exception_state);
  EXPECT_FALSE(exception_state.HadException());

  HeapVector<ScriptValue> blink_keyframes = {
      V8ObjectBuilder(script_state)
          .AddString("width", "100px")
          .AddString("composite", "replace")
          .GetScriptValue(),
      V8ObjectBuilder(script_state).AddString("width", "0px").GetScriptValue()};

  ScriptValue js_keyframes(
      scope.GetIsolate(),
      ToV8(blink_keyframes, scope.GetContext()->Global(), scope.GetIsolate()));

  KeyframeEffect* effect = CreateAnimationFromOption(
      script_state, element.Get(), js_keyframes, effect_options_dictionary);
  EXPECT_EQ("add", effect->composite());

  PropertyHandle property(GetCSSPropertyWidth());
  const PropertySpecificKeyframeVector& keyframes =
      *effect->Model()->GetPropertySpecificKeyframes(property);

  EXPECT_EQ(EffectModel::kCompositeReplace, keyframes[0]->Composite());
  EXPECT_EQ(EffectModel::kCompositeAdd, keyframes[1]->Composite());
}

TEST_F(AnimationKeyframeEffectV8Test, CanSetDuration) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());
  double duration = 2000;

  KeyframeEffect* animation = CreateAnimationFromTiming(
      script_state, element.Get(), js_keyframes, duration);

  EXPECT_TIMEDELTA(AnimationTimeDelta::FromMillisecondsD(duration),
                   animation->SpecifiedTiming().iteration_duration.value());
}

TEST_F(AnimationKeyframeEffectV8Test, CanOmitSpecifiedDuration) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());
  KeyframeEffect* animation =
      CreateAnimation(script_state, element.Get(), js_keyframes);
  EXPECT_FALSE(animation->SpecifiedTiming().iteration_duration);
}

TEST_F(AnimationKeyframeEffectV8Test, SpecifiedGetters) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());

  v8::Local<v8::Object> timing_input = v8::Object::New(scope.GetIsolate());
  SetV8ObjectPropertyAsNumber(scope.GetIsolate(), timing_input, "delay", 2);
  SetV8ObjectPropertyAsNumber(scope.GetIsolate(), timing_input, "endDelay",
                              0.5);
  SetV8ObjectPropertyAsString(scope.GetIsolate(), timing_input, "fill",
                              "backwards");
  SetV8ObjectPropertyAsNumber(scope.GetIsolate(), timing_input,
                              "iterationStart", 2);
  SetV8ObjectPropertyAsNumber(scope.GetIsolate(), timing_input, "iterations",
                              10);
  SetV8ObjectPropertyAsString(scope.GetIsolate(), timing_input, "direction",
                              "reverse");
  SetV8ObjectPropertyAsString(scope.GetIsolate(), timing_input, "easing",
                              "ease-in-out");
  DummyExceptionStateForTesting exception_state;
  KeyframeEffectOptions* timing_input_dictionary =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), timing_input, exception_state);
  EXPECT_FALSE(exception_state.HadException());

  KeyframeEffect* animation = CreateAnimationFromOption(
      script_state, element.Get(), js_keyframes, timing_input_dictionary);

  EffectTiming* timing = animation->getTiming();
  EXPECT_EQ(2, timing->delay());
  EXPECT_EQ(0.5, timing->endDelay());
  EXPECT_EQ("backwards", timing->fill());
  EXPECT_EQ(2, timing->iterationStart());
  EXPECT_EQ(10, timing->iterations());
  EXPECT_EQ("reverse", timing->direction());
  EXPECT_EQ("ease-in-out", timing->easing());
}

TEST_F(AnimationKeyframeEffectV8Test, SpecifiedDurationGetter) {
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());

  v8::Local<v8::Object> timing_input_with_duration =
      v8::Object::New(scope.GetIsolate());
  SetV8ObjectPropertyAsNumber(scope.GetIsolate(), timing_input_with_duration,
                              "duration", 2.5);
  DummyExceptionStateForTesting exception_state;
  KeyframeEffectOptions* timing_input_dictionary_with_duration =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), timing_input_with_duration, exception_state);
  EXPECT_FALSE(exception_state.HadException());

  KeyframeEffect* animation_with_duration =
      CreateAnimationFromOption(script_state, element.Get(), js_keyframes,
                                timing_input_dictionary_with_duration);

  EffectTiming* specified_with_duration = animation_with_duration->getTiming();
  UnrestrictedDoubleOrString duration = specified_with_duration->duration();
  EXPECT_TRUE(duration.IsUnrestrictedDouble());
  EXPECT_EQ(2.5, duration.GetAsUnrestrictedDouble());
  EXPECT_FALSE(duration.IsString());

  v8::Local<v8::Object> timing_input_no_duration =
      v8::Object::New(scope.GetIsolate());
  KeyframeEffectOptions* timing_input_dictionary_no_duration =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), timing_input_no_duration, exception_state);
  EXPECT_FALSE(exception_state.HadException());

  KeyframeEffect* animation_no_duration =
      CreateAnimationFromOption(script_state, element.Get(), js_keyframes,
                                timing_input_dictionary_no_duration);

  EffectTiming* specified_no_duration = animation_no_duration->getTiming();
  UnrestrictedDoubleOrString duration2 = specified_no_duration->duration();
  EXPECT_FALSE(duration2.IsUnrestrictedDouble());
  EXPECT_TRUE(duration2.IsString());
  EXPECT_EQ("auto", duration2.GetAsString());
}

TEST_F(AnimationKeyframeEffectV8Test, SetKeyframesAdditiveCompositeOperation) {
  // AnimationWorklet also needs to be disabled since it depends on
  // WebAnimationsAPI and prevents us from turning it off if enabled.
  ScopedAnimationWorkletForTest no_animation_worklet(false);
  ScopedWebAnimationsAPIForTest no_web_animations(false);
  V8TestingScope scope;
  ScriptState* script_state = scope.GetScriptState();
  ScriptValue js_keyframes = ScriptValue::CreateNull(scope.GetIsolate());
  v8::Local<v8::Object> timing_input = v8::Object::New(scope.GetIsolate());
  DummyExceptionStateForTesting exception_state;
  KeyframeEffectOptions* timing_input_dictionary =
      NativeValueTraits<KeyframeEffectOptions>::NativeValue(
          scope.GetIsolate(), timing_input, exception_state);
  ASSERT_FALSE(exception_state.HadException());

  // Since there are no CSS-targeting keyframes, we can create a KeyframeEffect
  // with composite = 'add'.
  timing_input_dictionary->setComposite("add");
  KeyframeEffect* effect = CreateAnimationFromOption(
      script_state, element.Get(), js_keyframes, timing_input_dictionary);
  EXPECT_EQ(effect->Model()->Composite(), EffectModel::kCompositeAdd);

  // But if we then setKeyframes with CSS-targeting keyframes, the composite
  // should fallback to 'replace'.
  HeapVector<ScriptValue> blink_keyframes = {
      V8ObjectBuilder(script_state).AddString("width", "10px").GetScriptValue(),
      V8ObjectBuilder(script_state).AddString("width", "0px").GetScriptValue()};
  ScriptValue new_js_keyframes(
      scope.GetIsolate(),
      ToV8(blink_keyframes, scope.GetContext()->Global(), scope.GetIsolate()));
  effect->setKeyframes(script_state, new_js_keyframes, exception_state);
  ASSERT_FALSE(exception_state.HadException());
  EXPECT_EQ(effect->Model()->Composite(), EffectModel::kCompositeReplace);
}

TEST_F(KeyframeEffectTest, TimeToEffectChange) {
  Timing timing;
  timing.iteration_duration = AnimationTimeDelta::FromSecondsD(100);
  timing.start_delay = 100;
  timing.end_delay = 100;
  timing.fill_mode = Timing::FillMode::NONE;
  auto* keyframe_effect = MakeGarbageCollected<KeyframeEffect>(
      nullptr, CreateEmptyEffectModel(), timing);
  Animation* animation = GetDocument().Timeline().Play(keyframe_effect);

  // Beginning of the animation.
  EXPECT_TIMEDELTA(AnimationTimeDelta::FromSecondsD(100),
                   keyframe_effect->TimeToForwardsEffectChange());
  EXPECT_EQ(AnimationTimeDelta::Max(),
            keyframe_effect->TimeToReverseEffectChange());

  // End of the before phase.
  animation->setCurrentTime(CSSNumberish::FromDouble(100000));
  EXPECT_TIMEDELTA(AnimationTimeDelta::FromSecondsD(100),
                   keyframe_effect->TimeToForwardsEffectChange());
  EXPECT_TIMEDELTA(AnimationTimeDelta(),
                   keyframe_effect->TimeToReverseEffectChange());

  // Nearing the end of the active phase.
  animation->setCurrentTime(CSSNumberish::FromDouble(199000));
  EXPECT_TIMEDELTA(AnimationTimeDelta::FromSecondsD(1),
                   keyframe_effect->TimeToForwardsEffectChange());
  EXPECT_TIMEDELTA(AnimationTimeDelta(),
                   keyframe_effect->TimeToReverseEffectChange());

  // End of the active phase.
  animation->setCurrentTime(CSSNumberish::FromDouble(200000));
  EXPECT_TIMEDELTA(AnimationTimeDelta::FromSecondsD(100),
                   keyframe_effect->TimeToForwardsEffectChange());
  EXPECT_TIMEDELTA(AnimationTimeDelta(),
                   keyframe_effect->TimeToReverseEffectChange());

  // End of the animation.
  animation->setCurrentTime(CSSNumberish::FromDouble(300000));
  EXPECT_EQ(AnimationTimeDelta::Max(),
            keyframe_effect->TimeToForwardsEffectChange());
  EXPECT_TIMEDELTA(AnimationTimeDelta::FromSecondsD(100),
                   keyframe_effect->TimeToReverseEffectChange());
}

TEST_F(KeyframeEffectTest, CheckCanStartAnimationOnCompositorNoKeyframes) {
  ASSERT_TRUE(element);

  const double animation_playback_rate = 1;
  Timing timing;

  // No keyframes results in an invalid animation.
  {
    auto* keyframe_effect = MakeGarbageCollected<KeyframeEffect>(
        element, CreateEmptyEffectModel(), timing);
    EXPECT_TRUE(keyframe_effect->CheckCanStartAnimationOnCompositor(
                    nullptr, animation_playback_rate) &
                CompositorAnimations::kInvalidAnimationOrEffect);
  }

  // Keyframes but no properties results in an invalid animation.
  {
    StringKeyframeVector keyframes(2);
    keyframes[0] = MakeGarbageCollected<StringKeyframe>();
    keyframes[0]->SetOffset(0.0);
    keyframes[1] = MakeGarbageCollected<StringKeyframe>();
    keyframes[1]->SetOffset(1.0);
    auto* effect_model =
        MakeGarbageCollected<StringKeyframeEffectModel>(keyframes);

    auto* keyframe_effect =
        MakeGarbageCollected<KeyframeEffect>(element, effect_model, timing);
    EXPECT_TRUE(keyframe_effect->CheckCanStartAnimationOnCompositor(
                    nullptr, animation_playback_rate) &
                CompositorAnimations::kInvalidAnimationOrEffect);
  }
}

TEST_F(KeyframeEffectTest, CheckCanStartAnimationOnCompositorNoTarget) {
  const double animation_playback_rate = 1;
  Timing timing;

  // No target results in an invalid animation.
  StringKeyframeVector keyframes(2);
  keyframes[0] = MakeGarbageCollected<StringKeyframe>();
  keyframes[0]->SetOffset(0.0);
  keyframes[0]->SetCSSPropertyValue(CSSPropertyID::kLeft, "0px",
                                    SecureContextMode::kInsecureContext,
                                    nullptr);
  keyframes[1] = MakeGarbageCollected<StringKeyframe>();
  keyframes[1]->SetOffset(1.0);
  keyframes[1]->SetCSSPropertyValue(CSSPropertyID::kLeft, "10px",
                                    SecureContextMode::kInsecureContext,
                                    nullptr);
  auto* effect_model =
      MakeGarbageCollected<StringKeyframeEffectModel>(keyframes);

  auto* keyframe_effect =
      MakeGarbageCollected<KeyframeEffect>(nullptr, effect_model, timing);
  EXPECT_TRUE(keyframe_effect->CheckCanStartAnimationOnCompositor(
                  nullptr, animation_playback_rate) &
              CompositorAnimations::kInvalidAnimationOrEffect);
}

TEST_F(KeyframeEffectTest, CheckCanStartAnimationOnCompositorBadTarget) {
  const double animation_playback_rate = 1;
  Timing timing;

  StringKeyframeVector keyframes(2);
  keyframes[0] = MakeGarbageCollected<StringKeyframe>();
  keyframes[0]->SetOffset(0.0);
  keyframes[0]->SetCSSPropertyValue(CSSPropertyID::kLeft, "0px",
                                    SecureContextMode::kInsecureContext,
                                    nullptr);
  keyframes[1] = MakeGarbageCollected<StringKeyframe>();
  keyframes[1]->SetOffset(1.0);
  keyframes[1]->SetCSSPropertyValue(CSSPropertyID::kLeft, "10px",
                                    SecureContextMode::kInsecureContext,
                                    nullptr);
  auto* effect_model =
      MakeGarbageCollected<StringKeyframeEffectModel>(keyframes);
  auto* keyframe_effect =
      MakeGarbageCollected<KeyframeEffect>(element, effect_model, timing);

  // If the target has a CSS offset we can't composite it.
  element->SetInlineStyleProperty(CSSPropertyID::kOffsetPosition, "50px 50px");
  UpdateAllLifecyclePhasesForTest();

  ASSERT_TRUE(element->GetComputedStyle()->HasOffset());
  EXPECT_TRUE(keyframe_effect->CheckCanStartAnimationOnCompositor(
                  nullptr, animation_playback_rate) &
              CompositorAnimations::kTargetHasCSSOffset);

  // If the target has multiple transform properties we can't composite it.
  element->SetInlineStyleProperty(CSSPropertyID::kRotate, "90deg");
  element->SetInlineStyleProperty(CSSPropertyID::kScale, "2 1");
  UpdateAllLifecyclePhasesForTest();

  EXPECT_TRUE(keyframe_effect->CheckCanStartAnimationOnCompositor(
                  nullptr, animation_playback_rate) &
              CompositorAnimations::kTargetHasMultipleTransformProperties);
}

TEST_F(KeyframeEffectTest, TranslationTransformsPreserveAxisAlignment) {
  auto* effect =
      GetTwoFrameEffect(CSSPropertyID::kTransform, "translate(10px, 10px)",
                        "translate(20px, 20px)");
  EXPECT_TRUE(effect->UpdateBoxSizeAndCheckTransformAxisAlignment(FloatSize()));
}

TEST_F(KeyframeEffectTest, ScaleTransformsPreserveAxisAlignment) {
  auto* effect =
      GetTwoFrameEffect(CSSPropertyID::kTransform, "scale(2)", "scale(3)");
  EXPECT_TRUE(effect->UpdateBoxSizeAndCheckTransformAxisAlignment(FloatSize()));
}

TEST_F(KeyframeEffectTest, RotationTransformsDoNotPreserveAxisAlignment) {
  auto* effect = GetTwoFrameEffect(CSSPropertyID::kTransform, "rotate(10deg)",
                                   "rotate(20deg)");

  EXPECT_FALSE(
      effect->UpdateBoxSizeAndCheckTransformAxisAlignment(FloatSize()));
}

TEST_F(KeyframeEffectTest, RotationsDoNotPreserveAxisAlignment) {
  auto* effect = GetTwoFrameEffect(CSSPropertyID::kRotate, "10deg", "20deg");
  EXPECT_FALSE(
      effect->UpdateBoxSizeAndCheckTransformAxisAlignment(FloatSize()));
}

}  // namespace blink