src/cc/animation/scroll_offset_animation_curve_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/animation/scroll_offset_animation_curve.h"
   6
   7 #include "cc/animation/timing_function.h"
   8 #include "cc/test/geometry_test_utils.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace cc {
  12 namespace {
  13
  14 TEST(ScrollOffsetAnimationCurveTest, Duration) {
  15   gfx::ScrollOffset target_value(100.f, 200.f);
  16   scoped_ptr<ScrollOffsetAnimationCurve> curve(
  17       ScrollOffsetAnimationCurve::Create(
  18           target_value,
  19           EaseInOutTimingFunction::Create().Pass()));
  20
  21   curve->SetInitialValue(target_value);
  22   EXPECT_DOUBLE_EQ(0.0, curve->Duration());
  23
  24   // x decreases, y stays the same.
  25   curve->SetInitialValue(gfx::ScrollOffset(136.f, 200.f));
  26   EXPECT_DOUBLE_EQ(0.1, curve->Duration());
  27
  28   // x increases, y stays the same.
  29   curve->SetInitialValue(gfx::ScrollOffset(19.f, 200.f));
  30   EXPECT_DOUBLE_EQ(0.15, curve->Duration());
  31
  32   // x stays the same, y decreases.
  33   curve->SetInitialValue(gfx::ScrollOffset(100.f, 344.f));
  34   EXPECT_DOUBLE_EQ(0.2, curve->Duration());
  35
  36   // x stays the same, y increases.
  37   curve->SetInitialValue(gfx::ScrollOffset(100.f, 191.f));
  38   EXPECT_DOUBLE_EQ(0.05, curve->Duration());
  39
  40   // x decreases, y decreases.
  41   curve->SetInitialValue(gfx::ScrollOffset(32500.f, 500.f));
  42   EXPECT_DOUBLE_EQ(3.0, curve->Duration());
  43
  44   // x decreases, y increases.
  45   curve->SetInitialValue(gfx::ScrollOffset(150.f, 119.f));
  46   EXPECT_DOUBLE_EQ(0.15, curve->Duration());
  47
  48   // x increases, y decreases.
  49   curve->SetInitialValue(gfx::ScrollOffset(0.f, 14600.f));
  50   EXPECT_DOUBLE_EQ(2.0, curve->Duration());
  51
  52   // x increases, y increases.
  53   curve->SetInitialValue(gfx::ScrollOffset(95.f, 191.f));
  54   EXPECT_DOUBLE_EQ(0.05, curve->Duration());
  55 }
  56
  57 TEST(ScrollOffsetAnimationCurveTest, GetValue) {
  58   gfx::ScrollOffset initial_value(2.f, 40.f);
  59   gfx::ScrollOffset target_value(10.f, 20.f);
  60   scoped_ptr<ScrollOffsetAnimationCurve> curve(
  61       ScrollOffsetAnimationCurve::Create(
  62           target_value,
  63           EaseInOutTimingFunction::Create().Pass()));
  64   curve->SetInitialValue(initial_value);
  65
  66   double duration = curve->Duration();
  67   EXPECT_GT(curve->Duration(), 0);
  68   EXPECT_LT(curve->Duration(), 0.1);
  69
  70   EXPECT_EQ(AnimationCurve::ScrollOffset, curve->Type());
  71   EXPECT_EQ(duration, curve->Duration());
  72
  73   EXPECT_VECTOR2DF_EQ(initial_value, curve->GetValue(-1.0));
  74   EXPECT_VECTOR2DF_EQ(initial_value, curve->GetValue(0.0));
  75   EXPECT_VECTOR2DF_EQ(gfx::ScrollOffset(6.f, 30.f),
  76                       curve->GetValue(duration/2.0));
  77   EXPECT_VECTOR2DF_EQ(target_value, curve->GetValue(duration));
  78   EXPECT_VECTOR2DF_EQ(target_value, curve->GetValue(duration+1.0));
  79
  80   // Verify that GetValue takes the timing function into account.
  81   gfx::ScrollOffset value = curve->GetValue(duration/4.0);
  82   EXPECT_NEAR(3.0333f, value.x(), 0.00015f);
  83   EXPECT_NEAR(37.4168f, value.y(), 0.00015f);
  84 }
  85
  86 // Verify that a clone behaves exactly like the original.
  87 TEST(ScrollOffsetAnimationCurveTest, Clone) {
  88   gfx::ScrollOffset initial_value(2.f, 40.f);
  89   gfx::ScrollOffset target_value(10.f, 20.f);
  90   scoped_ptr<ScrollOffsetAnimationCurve> curve(
  91       ScrollOffsetAnimationCurve::Create(
  92           target_value,
  93           EaseInOutTimingFunction::Create().Pass()));
  94   curve->SetInitialValue(initial_value);
  95   double duration = curve->Duration();
  96
  97   scoped_ptr<AnimationCurve> clone(curve->Clone().Pass());
  98
  99   EXPECT_EQ(AnimationCurve::ScrollOffset, clone->Type());
 100   EXPECT_EQ(duration, clone->Duration());
 101
 102   EXPECT_VECTOR2DF_EQ(initial_value,
 103                       clone->ToScrollOffsetAnimationCurve()->GetValue(-1.0));
 104   EXPECT_VECTOR2DF_EQ(initial_value,
 105                       clone->ToScrollOffsetAnimationCurve()->GetValue(0.0));
 106   EXPECT_VECTOR2DF_EQ(
 107       gfx::ScrollOffset(6.f, 30.f),
 108       clone->ToScrollOffsetAnimationCurve()->GetValue(duration / 2.0));
 109   EXPECT_VECTOR2DF_EQ(
 110       target_value,
 111       clone->ToScrollOffsetAnimationCurve()->GetValue(duration));
 112   EXPECT_VECTOR2DF_EQ(
 113       target_value,
 114       clone->ToScrollOffsetAnimationCurve()->GetValue(duration + 1.0));
 115
 116   // Verify that the timing function was cloned correctly.
 117   gfx::ScrollOffset value =
 118       clone->ToScrollOffsetAnimationCurve()->GetValue(duration / 4.0);
 119   EXPECT_NEAR(3.0333f, value.x(), 0.00015f);
 120   EXPECT_NEAR(37.4168f, value.y(), 0.00015f);
 121 }
 122
 123 TEST(ScrollOffsetAnimationCurveTest, UpdateTarget) {
 124   gfx::ScrollOffset initial_value(0.f, 0.f);
 125   gfx::ScrollOffset target_value(0.f, 3600.f);
 126   scoped_ptr<ScrollOffsetAnimationCurve> curve(
 127       ScrollOffsetAnimationCurve::Create(
 128           target_value, EaseInOutTimingFunction::Create().Pass()));
 129   curve->SetInitialValue(initial_value);
 130   EXPECT_EQ(1.0, curve->Duration());
 131   EXPECT_EQ(1800.0, curve->GetValue(0.5).y());
 132   EXPECT_EQ(3600.0, curve->GetValue(1.0).y());
 133
 134   curve->UpdateTarget(0.5, gfx::ScrollOffset(0.0, 9900.0));
 135
 136   EXPECT_EQ(2.0, curve->Duration());
 137   EXPECT_EQ(1800.0, curve->GetValue(0.5).y());
 138   EXPECT_NEAR(5566.49, curve->GetValue(1.0).y(), 0.01);
 139   EXPECT_EQ(9900.0, curve->GetValue(2.0).y());
 140
 141   curve->UpdateTarget(1.0, gfx::ScrollOffset(0.0, 7200.0));
 142
 143   EXPECT_NEAR(1.674, curve->Duration(), 0.01);
 144   EXPECT_NEAR(5566.49, curve->GetValue(1.0).y(), 0.01);
 145   EXPECT_EQ(7200.0, curve->GetValue(1.674).y());
 146 }
 147
 148 }  // namespace
 149 }  // namespace cc