mirror of
https://github.com/NativeScript/NativeScript.git
synced 2025-11-05 13:26:48 +08:00
645 lines
18 KiB
TypeScript
645 lines
18 KiB
TypeScript
import * as TKUnit from '../../tk-unit';
|
|
import * as helper from '../../ui-helper';
|
|
import * as viewModule from '@nativescript/core/ui/core/view';
|
|
import { Label } from '@nativescript/core/ui/label';
|
|
import { StackLayout } from '@nativescript/core/ui/layouts/stack-layout';
|
|
import * as colorModule from '@nativescript/core/color';
|
|
import { Enums } from '@nativescript/core';
|
|
import { AnimationPromise } from '@nativescript/core/ui/animation';
|
|
|
|
// >> animation-require
|
|
import * as animation from '@nativescript/core/ui/animation';
|
|
import { PercentLengthType, PercentLength } from '@nativescript/core';
|
|
// << animation-require
|
|
|
|
function prepareTest(parentHeight?: number, parentWidth?: number): Label {
|
|
let mainPage = helper.getCurrentPage();
|
|
let label = new Label();
|
|
label.text = 'label';
|
|
|
|
let stackLayout = new StackLayout();
|
|
// optionally size the parent extent to make assertions about percentage values
|
|
if (parentHeight !== undefined) {
|
|
stackLayout.height = PercentLength.parse(parentHeight + '');
|
|
}
|
|
if (parentWidth !== undefined) {
|
|
stackLayout.width = PercentLength.parse(parentWidth + '');
|
|
}
|
|
stackLayout.addChild(label);
|
|
mainPage.content = stackLayout;
|
|
TKUnit.waitUntilReady(() => label.isLoaded);
|
|
|
|
return label;
|
|
}
|
|
|
|
export function test_AnimatingProperties(done) {
|
|
let label = prepareTest();
|
|
|
|
// >> animation-properties
|
|
label
|
|
.animate({
|
|
opacity: 0.75,
|
|
backgroundColor: new colorModule.Color('Red'),
|
|
translate: { x: 100, y: 100 },
|
|
scale: { x: 2, y: 2 },
|
|
rotate: 180,
|
|
duration: 5,
|
|
delay: 10,
|
|
iterations: 3,
|
|
curve: Enums.AnimationCurve.easeIn,
|
|
})
|
|
.then(() => {
|
|
//console.log("Animation finished.");
|
|
// >> (hide)
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
console.log(e.message);
|
|
// >> (hide)
|
|
done(e);
|
|
// << (hide)
|
|
});
|
|
// << animation-properties
|
|
}
|
|
|
|
export function test_PlayRejectsWhenAlreadyPlayingAnimation(done) {
|
|
let label = prepareTest();
|
|
|
|
var animation = label.createAnimation({ translate: { x: 100, y: 100 }, duration: 5 });
|
|
|
|
animation.play();
|
|
animation.play().then(
|
|
() => {
|
|
// should never get here
|
|
throw new Error('Already playing.');
|
|
},
|
|
(e) => {
|
|
TKUnit.assert(animation.isPlaying === true, "animation.isPlaying should be true since it's currently playing.");
|
|
if (e === 'Animation is already playing.') {
|
|
done();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
export function test_CancelIgnoredWhenNotPlayingAnimation() {
|
|
let label = prepareTest();
|
|
|
|
var animation = label.createAnimation({ translate: { x: 100, y: 100 }, duration: 5 });
|
|
animation.cancel(); // should not throw
|
|
TKUnit.assert(!animation.isPlaying, 'animation.isPlaying should be falsey since it was never played.');
|
|
}
|
|
|
|
export function test_CancellingAnimation(done) {
|
|
let label = prepareTest();
|
|
|
|
// >> animation-cancel
|
|
var animation1 = label.createAnimation({ translate: { x: 100, y: 100 }, duration: 5 });
|
|
|
|
animation1
|
|
.play()
|
|
.then(() => {
|
|
//console.log("Animation finished");
|
|
// >> (hide)
|
|
throw new Error('Cancelling Animation - Should not be in the Promise Then()');
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
//console.log("Animation cancelled");
|
|
// >> (hide)
|
|
if (!e) {
|
|
done(new Error('Cancel path did not have proper error'));
|
|
} else if (e.toString() === 'Error: Animation cancelled.') {
|
|
done();
|
|
} else {
|
|
done(e);
|
|
}
|
|
// << (hide)
|
|
});
|
|
animation1.cancel();
|
|
// << animation-cancel
|
|
}
|
|
|
|
export function test_CancellingAnimate(done) {
|
|
let label = prepareTest();
|
|
|
|
// >> animation-cancel2
|
|
var animation1 = label
|
|
.animate({ translate: { x: 100, y: 100 }, duration: 5 })
|
|
.then(() => {
|
|
//console.log("Animation finished");
|
|
// >> (hide)
|
|
throw new Error('Cancelling Animate - Should not be in Promise Then()');
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
//console.log("Animation cancelled");
|
|
// >> (hide)
|
|
if (!e) {
|
|
done(new Error('Cancel path did not have proper error'));
|
|
} else if (e.toString() === 'Error: Animation cancelled.') {
|
|
done();
|
|
} else {
|
|
done(e);
|
|
}
|
|
// << (hide)
|
|
});
|
|
(<AnimationPromise>animation1).cancel();
|
|
// << animation-cancel2
|
|
}
|
|
|
|
export function test_ChainingAnimations(done) {
|
|
let label = prepareTest();
|
|
|
|
// >> animation-chaining
|
|
let duration = 300;
|
|
// >> (hide)
|
|
duration = 5;
|
|
// << (hide)
|
|
label
|
|
.animate({ opacity: 0, duration: duration })
|
|
.then(() => label.animate({ opacity: 1, duration: duration }))
|
|
.then(() => label.animate({ translate: { x: 200, y: 200 }, duration: duration }))
|
|
.then(() => label.animate({ translate: { x: 0, y: 0 }, duration: duration }))
|
|
.then(() => label.animate({ scale: { x: 5, y: 5 }, duration: duration }))
|
|
.then(() => label.animate({ scale: { x: 1, y: 1 }, duration: duration }))
|
|
.then(() => label.animate({ rotate: 180, duration: duration }))
|
|
.then(() => label.animate({ rotate: 0, duration: duration }))
|
|
.then(() => {
|
|
//console.log("Animation finished");
|
|
// >> (hide)
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
console.log(e.message);
|
|
// >> (hide)
|
|
done(e);
|
|
// << (hide)
|
|
});
|
|
// << animation-chaining
|
|
}
|
|
|
|
export function test_ReusingAnimations(done) {
|
|
let label = prepareTest();
|
|
|
|
// >> animation-reusing
|
|
var animation1 = label.createAnimation({ translate: { x: 100, y: 100 }, duration: 5 });
|
|
var animation2 = label.createAnimation({ translate: { x: 0, y: 0 }, duration: 5 });
|
|
|
|
animation1
|
|
.play()
|
|
.then(() => animation2.play())
|
|
.then(() => animation1.play())
|
|
.then(() => animation2.play())
|
|
.then(() => animation1.play())
|
|
.then(() => animation2.play())
|
|
.then(() => {
|
|
//console.log("Animation finished");
|
|
// >> (hide)
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
console.log(e.message);
|
|
// >> (hide)
|
|
done(e);
|
|
// << (hide)
|
|
});
|
|
// << animation-reusing
|
|
}
|
|
|
|
export function test_AnimatingMultipleViews(done) {
|
|
let mainPage = helper.getCurrentPage();
|
|
let label1 = new Label();
|
|
label1.text = 'label1';
|
|
let label2 = new Label();
|
|
label2.text = 'label2';
|
|
let label3 = new Label();
|
|
label3.text = 'label3';
|
|
let stackLayout = new StackLayout();
|
|
stackLayout.addChild(label1);
|
|
stackLayout.addChild(label2);
|
|
stackLayout.addChild(label3);
|
|
mainPage.content = stackLayout;
|
|
TKUnit.waitUntilReady(() => label3.isLoaded);
|
|
|
|
// >> animation-multiple-views
|
|
var animations: Array<animation.AnimationDefinition> = [
|
|
{ target: label1, translate: { x: 200, y: 200 }, duration: 5, delay: 0 },
|
|
{ target: label2, translate: { x: 200, y: 200 }, duration: 5, delay: 2 },
|
|
{ target: label3, translate: { x: 200, y: 200 }, duration: 5, delay: 4 },
|
|
];
|
|
var a = new animation.Animation(animations);
|
|
a.play()
|
|
.then(() => {
|
|
//console.log("Animations finished");
|
|
// >> (hide)
|
|
assertIOSNativeTransformIsCorrect(label1);
|
|
assertIOSNativeTransformIsCorrect(label2);
|
|
assertIOSNativeTransformIsCorrect(label3);
|
|
done();
|
|
// << (hide)
|
|
})
|
|
.catch((e) => {
|
|
console.log(e.message);
|
|
// >> (hide)
|
|
done(e);
|
|
// << (hide)
|
|
});
|
|
// << animation-multiple-views
|
|
}
|
|
|
|
export function test_AnimateOpacity(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({ opacity: 0.75, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.opacity, 0.75, 'label.opacity');
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateOpacity_ShouldThrow_IfNotNumber() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ opacity: <any>'0.75' });
|
|
}, 'Setting opacity to a non number should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateDelay_ShouldThrow_IfNotNumber() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ delay: <any>'1' });
|
|
}, 'Setting delay to a non number should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateDuration_ShouldThrow_IfNotNumber() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ duration: <any>'1' });
|
|
}, 'Setting duration to a non number should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateIterations_ShouldThrow_IfNotNumber() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ iterations: <any>'1' });
|
|
}, 'Setting iterations to a non number should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateRotate_ShouldThrow_IfNotNumber() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ rotate: <any>'1' });
|
|
}, 'Setting rotate to a non number should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateScale_ShouldThrow_IfNotPair() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ scale: <any>'1' });
|
|
}, 'Setting scale to a non Pair should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateTranslate_ShouldThrow_IfNotPair() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ translate: <any>'1' });
|
|
}, 'Setting translate to a non Pair should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateBackgroundColor_ShouldThrow_IfNotValidColorStringOrColor() {
|
|
var label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ backgroundColor: <any>'test' });
|
|
}, 'Setting backgroundColor to a not valid color string or Color should throw.');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateBackgroundColor(done) {
|
|
let label = prepareTest();
|
|
var red = new colorModule.Color('Red');
|
|
|
|
label
|
|
.animate({ backgroundColor: red, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assert((<colorModule.Color>label.backgroundColor).equals(red));
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateBackgroundColor_FromString(done) {
|
|
let label = prepareTest();
|
|
var expected = 'Red';
|
|
var clr = new colorModule.Color(expected);
|
|
|
|
label
|
|
.animate({ backgroundColor: <any>expected, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assert((<colorModule.Color>label.backgroundColor).equals(clr));
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateTranslate(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({ translate: { x: 100, y: 200 }, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.translateX, 100, 'label.translateX');
|
|
TKUnit.assertEqual(label.translateY, 200, 'label.translateY');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateScale(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({ scale: { x: 2, y: 3 }, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.scaleX, 2, 'label.scaleX');
|
|
TKUnit.assertEqual(label.scaleY, 3, 'label.scaleY');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateRotate(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({ rotate: 123, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.rotate, 123, 'label.rotate');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
function animateExtentAndAssertExpected(along: 'height' | 'width', value: PercentLengthType, pixelExpected: PercentLengthType): Promise<void> {
|
|
function pretty(val) {
|
|
return JSON.stringify(val, null, 2);
|
|
}
|
|
const parentExtent = 200;
|
|
const height = along === 'height' ? parentExtent : undefined;
|
|
const width = along === 'height' ? undefined : parentExtent;
|
|
const label = prepareTest(height, width);
|
|
const props = {
|
|
duration: 5,
|
|
[along]: value,
|
|
};
|
|
|
|
return label.animate(props).then(() => {
|
|
const observedString: string = PercentLength.convertToString(label[along]);
|
|
const inputString: string = PercentLength.convertToString(value);
|
|
TKUnit.assertEqual(observedString, inputString, `PercentLength.convertToString(${pretty(value)}) should be "${inputString}" but is "${observedString}"`);
|
|
// assert that the animated view"s calculated pixel extent matches the expected pixel value
|
|
const observedNumber: number = PercentLength.toDevicePixels(label[along], parentExtent, parentExtent);
|
|
const expectedNumber: number = PercentLength.toDevicePixels(pixelExpected, parentExtent, parentExtent);
|
|
TKUnit.assertEqual(observedNumber, expectedNumber, `PercentLength.toDevicePixels(${inputString}) should be "${expectedNumber}" but is "${observedNumber}"`);
|
|
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateExtent_Should_ResolvePercentageStrings(done) {
|
|
let promise: Promise<any> = Promise.resolve();
|
|
const pairs: [string, string][] = [
|
|
['100%', '200px'],
|
|
['50%', '100px'],
|
|
['25%', '50px'],
|
|
['-25%', '-50px'],
|
|
['-50%', '-100px'],
|
|
['-100%', '-200px'],
|
|
];
|
|
pairs.forEach((pair) => {
|
|
const input = PercentLength.parse(pair[0]);
|
|
const expected = PercentLength.parse(pair[1]);
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('height', input, expected);
|
|
});
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('width', input, expected);
|
|
});
|
|
});
|
|
promise.then(() => done()).catch(done);
|
|
}
|
|
|
|
export function test_AnimateExtent_Should_AcceptStringPixelValues(done) {
|
|
let promise: Promise<any> = Promise.resolve();
|
|
const pairs: [string, number][] = [
|
|
['100px', 100],
|
|
['50px', 50],
|
|
];
|
|
pairs.forEach((pair) => {
|
|
const input = PercentLength.parse(pair[0]);
|
|
const expected = {
|
|
unit: 'px',
|
|
value: pair[1],
|
|
} as PercentLengthType;
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('height', input, expected);
|
|
});
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('width', input, expected);
|
|
});
|
|
});
|
|
promise.then(() => done()).catch(done);
|
|
}
|
|
|
|
export function test_AnimateExtent_Should_AcceptNumberValuesAsDip(done) {
|
|
let promise: Promise<any> = Promise.resolve();
|
|
const inputs: any[] = [200, 150, 100, 50, 0];
|
|
inputs.forEach((value) => {
|
|
const parsed = PercentLength.parse(value);
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('height', parsed, parsed);
|
|
});
|
|
promise = promise.then(() => {
|
|
return animateExtentAndAssertExpected('width', parsed, parsed);
|
|
});
|
|
});
|
|
promise.then(() => done()).catch(done);
|
|
}
|
|
|
|
export function test_AnimateExtent_Should_ThrowIfCannotParsePercentLength() {
|
|
const label = new Label();
|
|
helper.buildUIAndRunTest(label, (views: Array<viewModule.View>) => {
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ width: '-frog%' });
|
|
}, 'Invalid percent string should throw');
|
|
TKUnit.assertThrows(() => {
|
|
label.animate({ height: '-frog%' });
|
|
}, 'Invalid percent string should throw');
|
|
});
|
|
}
|
|
|
|
export function test_AnimateTranslateScaleAndRotateSimultaneously(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({
|
|
translate: { x: 100, y: 200 },
|
|
scale: { x: 2, y: 3 },
|
|
rotate: 123,
|
|
duration: 5,
|
|
})
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.translateX, 100, 'label.translateX');
|
|
TKUnit.assertEqual(label.translateY, 200, 'label.translateY');
|
|
TKUnit.assertEqual(label.scaleX, 2, 'label.scaleX');
|
|
TKUnit.assertEqual(label.scaleY, 3, 'label.scaleY');
|
|
TKUnit.assertEqual(label.rotate, 123, 'label.rotate');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimateTranslateScaleAndRotateSequentially(done) {
|
|
let label = prepareTest();
|
|
|
|
label
|
|
.animate({ translate: { x: 100, y: 200 }, duration: 5 })
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.translateX, 100, 'label.translateX');
|
|
TKUnit.assertEqual(label.translateY, 200, 'label.translateY');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
|
|
return label.animate({ scale: { x: 2, y: 3 }, duration: 5 });
|
|
})
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.translateX, 100, 'label.translateX');
|
|
TKUnit.assertEqual(label.translateY, 200, 'label.translateY');
|
|
TKUnit.assertEqual(label.scaleX, 2, 'label.scaleX');
|
|
TKUnit.assertEqual(label.scaleY, 3, 'label.scaleY');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
|
|
return label.animate({ rotate: 123, duration: 5 });
|
|
})
|
|
.then(() => {
|
|
TKUnit.assertEqual(label.translateX, 100, 'label.translateX');
|
|
TKUnit.assertEqual(label.translateY, 200, 'label.translateY');
|
|
TKUnit.assertEqual(label.scaleX, 2, 'label.scaleX');
|
|
TKUnit.assertEqual(label.scaleY, 3, 'label.scaleY');
|
|
TKUnit.assertEqual(label.rotate, 123, 'label.rotate');
|
|
assertIOSNativeTransformIsCorrect(label);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_AnimationsAreAlwaysPlayed(done) {
|
|
let label = prepareTest();
|
|
|
|
var animation1 = label.createAnimation({ opacity: 0, duration: 5 });
|
|
var animation2 = label.createAnimation({ opacity: 1, duration: 5 });
|
|
|
|
animation1
|
|
.play()
|
|
.then(() => {
|
|
TKUnit.assert(label.opacity === 0, `Label opacity should be 0 after first animation, actual value is ${label.opacity}.`);
|
|
|
|
return animation2.play();
|
|
})
|
|
.then(() => {
|
|
TKUnit.assert(label.opacity === 1, `Label opacity should be 1 after second animation, actual value is ${label.opacity}.`);
|
|
done();
|
|
})
|
|
.catch((e) => {
|
|
console.log(e.message);
|
|
done(e);
|
|
});
|
|
}
|
|
|
|
export function test_PlayPromiseIsResolvedWhenAnimationFinishes(done) {
|
|
let label = prepareTest();
|
|
|
|
var animation = label.createAnimation({ opacity: 0, duration: 5 });
|
|
|
|
animation.play().then(
|
|
function onResolved() {
|
|
TKUnit.assert(animation.isPlaying === false, 'Animation.isPlaying should be false when animation play promise is resolved.');
|
|
done();
|
|
},
|
|
function onRejected(e) {
|
|
TKUnit.assert(false, 'Animation play promise should be resolved, not rejected.');
|
|
done(e);
|
|
}
|
|
);
|
|
}
|
|
|
|
export function test_PlayPromiseIsRejectedWhenAnimationIsCancelled(done) {
|
|
let label = prepareTest();
|
|
|
|
var animation = label.createAnimation({ opacity: 0, duration: 5 });
|
|
|
|
animation.play().then(
|
|
function onResolved() {
|
|
TKUnit.assert(false, 'Animation play promise should be rejected, not resolved.');
|
|
done();
|
|
},
|
|
function onRejected(e) {
|
|
TKUnit.assert(animation.isPlaying === false, 'Animation.isPlaying should be false when animation play promise is rejected.');
|
|
done();
|
|
}
|
|
);
|
|
|
|
animation.cancel();
|
|
}
|
|
|
|
function assertIOSNativeTransformIsCorrect(view: viewModule.View) {
|
|
if (view.ios) {
|
|
var errorMessage = (<any>animation)._getTransformMismatchErrorMessage(view);
|
|
if (errorMessage) {
|
|
TKUnit.assert(false, errorMessage);
|
|
}
|
|
}
|
|
}
|