Bug 1335998 - Part 6: Add some unit tests for basic transform operations for Servo. draft
authorBoris Chiou <boris.chiou@gmail.com>
Mon, 29 May 2017 15:12:20 +0800
changeset 589607 ec6d5396e06e96606d2a00eda0a78e5a6b6f4380
parent 589606 a8054c0b3a9d4aa2abcaeb3282cc1722d052359c
child 589608 c16d09125ce5d6b34c128148ee697102ac8700eb
push id62449
push userbmo:boris.chiou@gmail.com
push dateTue, 06 Jun 2017 14:00:19 +0000
bugs1335998
milestone55.0a1
Bug 1335998 - Part 6: Add some unit tests for basic transform operations for Servo. MozReview-Commit-ID: 50mAjN2KVRd
servo/tests/unit/style/animated_properties.rs
--- a/servo/tests/unit/style/animated_properties.rs
+++ b/servo/tests/unit/style/animated_properties.rs
@@ -1,21 +1,25 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use app_units::Au;
 use cssparser::RGBA;
 use style::properties::animated_properties::{Animatable, IntermediateRGBA};
+use style::properties::longhands::transform::computed_value::ComputedOperation as TransformOperation;
+use style::properties::longhands::transform::computed_value::T as TransformList;
 
 fn interpolate_rgba(from: RGBA, to: RGBA, progress: f64) -> RGBA {
     let from: IntermediateRGBA = from.into();
     let to: IntermediateRGBA = to.into();
     from.interpolate(&to, progress).unwrap().into()
 }
 
+// Color
 #[test]
 fn test_rgba_color_interepolation_preserves_transparent() {
     assert_eq!(interpolate_rgba(RGBA::transparent(),
                                 RGBA::transparent(), 0.5),
                RGBA::transparent());
 }
 
 #[test]
@@ -49,8 +53,100 @@ fn test_rgba_color_interepolation_out_of
 }
 
 #[test]
 fn test_rgba_color_interepolation_out_of_range_clamped_2() {
     assert_eq!(interpolate_rgba(RGBA::from_floats(1.0, 0.0, 0.0, 0.8),
                                 RGBA::from_floats(0.0, 1.0, 0.0, 0.2), 1.5),
                RGBA::from_floats(0.0, 0.0, 0.0, 0.0));
 }
+
+// Transform
+#[test]
+fn test_transform_interpolation_on_translate() {
+    use style::values::computed::{CalcLengthOrPercentage, LengthOrPercentage};
+
+    let from = TransformList(Some(vec![
+        TransformOperation::Translate(LengthOrPercentage::Length(Au(0)),
+                                      LengthOrPercentage::Length(Au(100)),
+                                      Au(25))]));
+    let to = TransformList(Some(vec![
+        TransformOperation::Translate(LengthOrPercentage::Length(Au(100)),
+                                      LengthOrPercentage::Length(Au(0)),
+                                      Au(75))]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![
+                   TransformOperation::Translate(LengthOrPercentage::Length(Au(50)),
+                                                 LengthOrPercentage::Length(Au(50)),
+                                                 Au(50))])));
+
+    let from = TransformList(Some(vec![
+        TransformOperation::Translate(LengthOrPercentage::Percentage(0.0),
+                                      LengthOrPercentage::Percentage(1.0),
+                                      Au(25))]));
+    let to = TransformList(Some(vec![
+        TransformOperation::Translate(LengthOrPercentage::Length(Au(100)),
+                                      LengthOrPercentage::Length(Au(0)),
+                                      Au(75))]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![
+                   TransformOperation::Translate(LengthOrPercentage::Calc(
+                                                     // calc(50px + 0%)
+                                                     CalcLengthOrPercentage::new(Au(50),
+                                                                                 Some(0.0))),
+                                                 LengthOrPercentage::Calc(
+                                                     // calc(0px + 50%)
+                                                     CalcLengthOrPercentage::new(Au(0),
+                                                                                 Some(0.5))),
+                                                 Au(50))])));
+}
+
+#[test]
+fn test_transform_interpolation_on_scale() {
+    let from = TransformList(Some(vec![TransformOperation::Scale(1.0, 2.0, 1.0)]));
+    let to = TransformList(Some(vec![TransformOperation::Scale(2.0, 4.0, 2.0)]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![TransformOperation::Scale(1.5, 3.0, 1.5)])));
+}
+
+#[test]
+fn test_transform_interpolation_on_rotate() {
+    use style::values::computed::Angle;
+
+    let from = TransformList(Some(vec![TransformOperation::Rotate(0.0, 0.0, 1.0,
+                                                                  Angle::from_radians(0.0))]));
+    let to = TransformList(Some(vec![TransformOperation::Rotate(0.0, 0.0, 1.0,
+                                                                Angle::from_radians(100.0))]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![TransformOperation::Rotate(0.0, 0.0, 1.0,
+                                                                  Angle::from_radians(50.0))])));
+}
+
+#[test]
+fn test_transform_interpolation_on_skew() {
+    use style::values::computed::Angle;
+
+    let from = TransformList(Some(vec![TransformOperation::Skew(Angle::from_radians(0.0),
+                                                                Angle::from_radians(100.0))]));
+    let to = TransformList(Some(vec![TransformOperation::Skew(Angle::from_radians(100.0),
+                                                              Angle::from_radians(0.0))]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![TransformOperation::Skew(Angle::from_radians(50.0),
+                                                                Angle::from_radians(50.0))])));
+}
+
+#[test]
+fn test_transform_interpolation_on_mismatched_lists() {
+    use style::values::computed::{Angle, LengthOrPercentage, Percentage};
+
+    let from = TransformList(Some(vec![TransformOperation::Rotate(0.0, 0.0, 1.0,
+                                                                  Angle::from_radians(100.0))]));
+    let to = TransformList(Some(vec![
+        TransformOperation::Translate(LengthOrPercentage::Length(Au(100)),
+                                      LengthOrPercentage::Length(Au(0)),
+                                      Au(0))]));
+    assert_eq!(from.interpolate(&to, 0.5).unwrap(),
+               TransformList(Some(vec![TransformOperation::InterpolateMatrix {
+                   from_list: from.clone(),
+                   to_list: to.clone(),
+                   progress: Percentage(0.5)
+               }])));
+}