Web Animations API: Bindings for TimedItem.specified with readonly attributes

Source/platform/animation/TimingFunctionTestHelperTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 77 matching lines @@
     {
         return ::testing::PrintToString(*timing);
     }
 };
 
 TEST_F(TimingFunctionTestHelperTest, LinearPrintTo)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::create();
     EXPECT_THAT(
         PrintToString(linearTiming),
-        ::testing::MatchesRegex("LinearTimingFunction@.*"));
+        ::testing::MatchesRegex("linear"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, CubicPrintTo)
 {
     RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
     EXPECT_THAT(
         PrintToString(cubicEaseTiming),
-        ::testing::MatchesRegex("CubicBezierTimingFunction@.*\\(EaseIn, 0.42, 0, 1, 1\\)"));
+        ::testing::MatchesRegex("ease-in"));
 
     RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     EXPECT_THAT(
         PrintToString(cubicCustomTiming),
-        ::testing::MatchesRegex("CubicBezierTimingFunction@.*\\(Custom, 0.17, 0.67, 1, -1.73\\)"));
+        ::testing::MatchesRegex("cubic-bezier\\(0.17, 0.67, 1, -1.73\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, StepPrintTo)
 {
     RefPtr<TimingFunction> stepTimingStart = StepsTimingFunction::preset(StepsTimingFunction::Start);
     EXPECT_THAT(
         PrintToString(stepTimingStart),
-        ::testing::MatchesRegex("StepsTimingFunction@.*\\(Start, 1, true\\)"));
+        ::testing::MatchesRegex("step-start"));
 
     RefPtr<TimingFunction> stepTimingCustom = StepsTimingFunction::create(5, false);
     EXPECT_THAT(
         PrintToString(stepTimingCustom),
-        ::testing::MatchesRegex("StepsTimingFunction@.*\\(Custom, 5, false\\)"));
+        ::testing::MatchesRegex("steps\\(5, end\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, ChainedPrintTo)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::create();
     RefPtr<ChainedTimingFunction> chainedLinearSingle = ChainedTimingFunction::create();
     chainedLinearSingle->appendSegment(1.0, linearTiming.get());
     EXPECT_THAT(
         PrintToString(chainedLinearSingle),
         ::testing::MatchesRegex(
-            "ChainedTimingFunction@.*\\("
-                "LinearTimingFunction@.*\\[0 -> 1\\]"
+            "chained\\("
+                "linear\\[0 -> 1\\]"
             "\\)"));
 
     RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(1.0, 0.0, 1, -1);
 
     RefPtr<ChainedTimingFunction> chainedMixed = ChainedTimingFunction::create();
     chainedMixed->appendSegment(0.75, chainedLinearSingle.get());
     chainedMixed->appendSegment(1.0, cubicCustomTiming.get());
     EXPECT_THAT(
         PrintToString(chainedMixed),
         ::testing::MatchesRegex(
-            "ChainedTimingFunction@.*\\("
-                "ChainedTimingFunction@.*\\("
-                    "LinearTimingFunction@.*\\[0 -> 1\\]"
+            "chained\\("
+                "chained\\("
+                    "linear\\[0 -> 1\\]"
                 "\\)\\[0 -> 0.75\\], "
-                "CubicBezierTimingFunction@.*\\(Custom, 1, 0, 1, -1\\)\\[0.75 -> 1\\]"
+                "cubic-bezier\\(1, 0, 1, -1\\)\\[0.75 -> 1\\]"
             "\\)"));
 }
 
 TEST_F(TimingFunctionTestHelperTest, BaseOperatorEq)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::create();
     RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
     RefPtr<TimingFunction> cubicTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     RefPtr<TimingFunction> stepsTiming1 = StepsTimingFunction::preset(StepsTimingFunction::End);
     RefPtr<TimingFunction> stepsTiming2 = StepsTimingFunction::create(5, true);
@@ skipping 155 matching lines @@
     EXPECT_REFV_NE(chainedMixed1, chainedSingleCubic1);
     EXPECT_REFV_NE(chainedMixed1, chainedSingleLinear1);
 
     RefPtr<ChainedTimingFunction> chainedMixed4 = ChainedTimingFunction::create();
     chainedMixed4->appendSegment(0.20, chainedSingleLinear1.get()); // Different offset
     chainedMixed4->appendSegment(1.0, cubicTiming1.get());
     EXPECT_REFV_NE(chainedMixed1, chainedMixed4);
 }
 
 } // namespace