javascript/NativeScript
1
0
Fork 0
mirror of https://github.com/NativeScript/NativeScript.git synced 2025-11-05 13:26:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into merge-release-in-master

Browse Source
This commit is contained in:
vakrilov
2019-12-03 15:51:59 +02:00
parent ab09064345 7b78f3b0c6
commit 6c24650c86
118 changed files with 3073 additions and 1813 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
tests/app/animation-frame/animation-frame.ts Normal file
View File

@@ -0,0 +1,85 @@
import * as TKUnit from "../tk-unit";
import * as animationFrame from "@nativescript/core/animation-frame";
import * as fpsNative from "@nativescript/core/fps-meter/fps-native";
export function test_requestAnimationFrame_isDefined() {
TKUnit.assertNotEqual(animationFrame.requestAnimationFrame, undefined, "Method animationFrame.requestAnimationFrame() should be defined!");
}
export function test_cancelAnimationFrame_isDefined() {
TKUnit.assertNotEqual(animationFrame.cancelAnimationFrame, undefined, "Method animationFrame.cancelAnimationFrame() should be defined!");
}
export function test_requestAnimationFrame() {
let completed: boolean;
const id = animationFrame.requestAnimationFrame(() => {
completed = true;
});
TKUnit.waitUntilReady(() => completed, 0.5, false);
animationFrame.cancelAnimationFrame(id);
TKUnit.assert(completed, "Callback should be called!");
}
export function test_requestAnimationFrame_callbackCalledInCurrentFrame() {
let completed: boolean;
let currentFrameTime = 0;
const frameCb = new fpsNative.FPSCallback((time) => {
currentFrameTime = time;
});
frameCb.start();
TKUnit.waitUntilReady(() => currentFrameTime > 0, 0.5);
let calledTime = 0;
animationFrame.requestAnimationFrame((frameTime) => {
calledTime = frameTime;
completed = calledTime >= frameTime;
});
TKUnit.waitUntilReady(() => completed, 0.5, false);
frameCb.stop();
TKUnit.assert(completed, "Callback should be called in current frame!");
}
export function test_requestAnimationFrame_nextCallbackCalledInNextFrame() {
let completed: boolean;
let currentFrameTime = 0;
const frameCb = new fpsNative.FPSCallback((time) => {
currentFrameTime = time;
});
frameCb.start();
TKUnit.waitUntilReady(() => currentFrameTime > 0, 0.5);
animationFrame.requestAnimationFrame((firstFrameTime) => {
animationFrame.requestAnimationFrame((frameTime) => {
frameCb.stop();
completed = frameTime > firstFrameTime && frameTime === currentFrameTime;
});
});
TKUnit.waitUntilReady(() => completed, 0.5, false);
frameCb.stop();
TKUnit.assert(completed, "Callback should be called in next frame!");
}
export function test_requestAnimationFrame_shouldBeCancelled() {
let completed: boolean;
let currentFrameTime = 0;
const frameCb = new fpsNative.FPSCallback((time) => {
currentFrameTime = time;
});
frameCb.start();
TKUnit.waitUntilReady(() => currentFrameTime > 0, 0.5);
animationFrame.requestAnimationFrame((firstFrameTime) => {
const cbId = animationFrame.requestAnimationFrame((frameTime) => {
completed = true;
});
animationFrame.cancelAnimationFrame(cbId);
});
TKUnit.wait(1);
frameCb.stop();
TKUnit.assert(!completed, "Callback should not be called");
}

2
tests/app/livesync/livesync-tests.ts
View File

@@ -249,7 +249,7 @@ function _test_onLiveSync_ModalViewClosed(context: ModuleContext) {
}
function livesync(context: ModuleContext) {
const ls = (<any>global).__hmrSyncBackup || global.__onLiveSync;
const ls = (<any>global).__coreModulesLiveSync || global.__onLiveSync;
ls(context);
}

3
tests/app/test-runner.ts
View File

@@ -76,6 +76,9 @@ allTests["OBSERVABLE"] = observableTests;
import * as timerTests from "./timer/timer-tests";
allTests["TIMER"] = timerTests;
import * as animationFrameTests from "./animation-frame/animation-frame";
allTests["ANIMATION-FRAME"] = animationFrameTests;
import * as colorTests from "./color/color-tests";
allTests["COLOR"] = colorTests;

29
tests/app/ui/proxy-view-container/proxy-view-container-tests.ts
View File

@@ -43,6 +43,35 @@ export function test_children_immediately_registered_in_parent_grid_layout() {
helper.buildUIAndRunTest(outer, testAction);
}
export function test_proxy_layout_properties() {
const outer = new GridLayout();
const proxy = new ProxyViewContainer();
function testAction(views: Array<View>) {
outer.addChild(proxy);
const btn = createBtn("1");
proxy.addChild(btn);
proxy.row = 1;
TKUnit.assertEqual(proxy.row, btn.row, "Proxy row value to existing child");
const btn2 = createBtn("2");
proxy.addChild(btn2);
TKUnit.assertEqual(proxy.row, btn2.row, "Proxy row value to new child");
proxy.removeChild(btn2);
btn.row = 0;
TKUnit.assertNotEqual(proxy.row, btn.row, "Child value changed");
proxy.row = 1;
TKUnit.assertNotEqual(proxy.row, btn.row, "Changed child value not overridden");
}
helper.buildUIAndRunTest(outer, testAction);
}
export function test_children_registered_in_parent_grid_layout_on_attach() {
const outer = new GridLayout();
const proxy = new ProxyViewContainer();

566
tests/app/ui/styling/root-views-css-classes-tests.ts
View File

@@ -35,254 +35,178 @@ const UNKNOWN_ORIENTATION_CSS_CLASS = "ns-unknown";
const DARK_SYSTEM_APPEARANCE_CSS_CLASS = "ns-dark";
const LIGHT_SYSTEM_APPEARANCE_CSS_CLASS = "ns-light";
function _test_root_view_root_css_class(shouldSetClassName: boolean) {
const rootView = getRootView();
function _test_root_css_class(view: View, isModal: boolean, shouldSetClassName: boolean) {
if (shouldSetClassName) {
view.className = CLASS_NAME;
}
const cssClass = isModal ? MODAL_CSS_CLASS : ROOT_CSS_CLASS;
const viewCssClasses = view.cssClasses;
TKUnit.assertTrue(viewCssClasses.has(cssClass), `${cssClass} CSS class is missing`);
if (shouldSetClassName) {
TKUnit.assertTrue(viewCssClasses.has(CLASS_NAME), `${CLASS_NAME} CSS class is missing`);
}
}
function _test_platform_css_class(rootView: View, shouldSetClassName: boolean) {
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const rootViewCssClasses = rootView.cssClasses;
TKUnit.assertTrue(rootViewCssClasses.has(
ROOT_CSS_CLASS),
`${ROOT_CSS_CLASS} CSS class is missing`
);
const cssClasses = rootView.cssClasses;
if (isAndroid) {
TKUnit.assertTrue(cssClasses.has(ANDROID_PLATFORM_CSS_CLASS), `${ANDROID_PLATFORM_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(IOS_PLATFORM_CSS_CLASS), `${IOS_PLATFORM_CSS_CLASS} CSS class is present`);
}
else {
TKUnit.assertTrue(cssClasses.has(IOS_PLATFORM_CSS_CLASS), `${IOS_PLATFORM_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(ANDROID_PLATFORM_CSS_CLASS), `${ANDROID_PLATFORM_CSS_CLASS} CSS class is present`);
}
if (shouldSetClassName) {
TKUnit.assertTrue(rootViewCssClasses.has(
CLASS_NAME),
`${CLASS_NAME} CSS class is missing`
);
TKUnit.assertTrue(cssClasses.has(CLASS_NAME), `${CLASS_NAME} CSS class is missing`);
}
}
function _test_device_type_css_class(rootView: View, shouldSetClassName: boolean) {
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const cssClasses = rootView.cssClasses;
const deviceType = device.deviceType;
if (deviceType === DeviceType.Phone) {
TKUnit.assertTrue(cssClasses.has(PHONE_DEVICE_TYPE_CSS_CLASS), `${PHONE_DEVICE_TYPE_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(TABLET_DEVICE_TYPE_CSS_CLASS), `${TABLET_DEVICE_TYPE_CSS_CLASS} CSS class is present`);
}
else {
TKUnit.assertTrue(cssClasses.has(TABLET_DEVICE_TYPE_CSS_CLASS), `${TABLET_DEVICE_TYPE_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(PHONE_DEVICE_TYPE_CSS_CLASS), `${PHONE_DEVICE_TYPE_CSS_CLASS} CSS class is present`);
}
if (shouldSetClassName) {
TKUnit.assertTrue(cssClasses.has(CLASS_NAME), `${CLASS_NAME} CSS class is missing`);
}
}
function _test_orientation_css_class(rootView: View, shouldSetClassName: boolean) {
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const cssClasses = rootView.cssClasses;
let appOrientation;
if (isAndroid) {
appOrientation = android.orientation;
}
else {
appOrientation = ios.orientation;
}
if (appOrientation === "portrait") {
TKUnit.assertTrue(cssClasses.has(PORTRAIT_ORIENTATION_CSS_CLASS), `${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(LANDSCAPE_ORIENTATION_CSS_CLASS), `${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is present`);
TKUnit.assertFalse(cssClasses.has(UNKNOWN_ORIENTATION_CSS_CLASS), `${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is present`);
}
else if (appOrientation === "landscape") {
TKUnit.assertTrue(cssClasses.has(LANDSCAPE_ORIENTATION_CSS_CLASS), `${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(PORTRAIT_ORIENTATION_CSS_CLASS), `${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is present`);
TKUnit.assertFalse(cssClasses.has(UNKNOWN_ORIENTATION_CSS_CLASS), `${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is present`);
}
else if (appOrientation === "landscape") {
TKUnit.assertTrue(cssClasses.has(UNKNOWN_ORIENTATION_CSS_CLASS), `${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(LANDSCAPE_ORIENTATION_CSS_CLASS), `${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is present`);
TKUnit.assertFalse(cssClasses.has(PORTRAIT_ORIENTATION_CSS_CLASS), `${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is present`);
}
if (shouldSetClassName) {
TKUnit.assertTrue(cssClasses.has(CLASS_NAME), `${CLASS_NAME} CSS class is missing`);
}
}
function _test_system_appearance_css_class(rootView: View, shouldSetClassName: boolean) {
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const cssClasses = rootView.cssClasses;
let systemAppearance;
if (isAndroid) {
systemAppearance = android.systemAppearance;
}
else {
systemAppearance = ios.systemAppearance;
}
if (isIOS && iosUtils.MajorVersion <= 12) {
TKUnit.assertFalse(cssClasses.has(DARK_SYSTEM_APPEARANCE_CSS_CLASS), `${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`);
TKUnit.assertFalse(cssClasses.has(LIGHT_SYSTEM_APPEARANCE_CSS_CLASS), `${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`);
}
else if (systemAppearance === "dark") {
TKUnit.assertTrue(cssClasses.has(DARK_SYSTEM_APPEARANCE_CSS_CLASS), `${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(LIGHT_SYSTEM_APPEARANCE_CSS_CLASS), `${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`);
}
else if (systemAppearance === "light") {
TKUnit.assertTrue(cssClasses.has(LIGHT_SYSTEM_APPEARANCE_CSS_CLASS), `${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is missing`);
TKUnit.assertFalse(cssClasses.has(DARK_SYSTEM_APPEARANCE_CSS_CLASS), `${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`);
}
if (shouldSetClassName) {
TKUnit.assertTrue(cssClasses.has(CLASS_NAME), `${CLASS_NAME} CSS class is missing`);
}
}
// Application root view
export function test_root_view_root_css_class() {
_test_root_view_root_css_class(false);
const rootView = getRootView();
_test_root_css_class(rootView, false, false);
}
export function test_root_view_class_name_preserve_root_css_class() {
_test_root_view_root_css_class(true);
}
function _test_root_view_platform_css_class(shouldSetClassName: boolean) {
const rootView = getRootView();
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const rootViewCssClasses = rootView.cssClasses;
if (isAndroid) {
TKUnit.assertTrue(rootViewCssClasses.has(
ANDROID_PLATFORM_CSS_CLASS),
`${ANDROID_PLATFORM_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
IOS_PLATFORM_CSS_CLASS),
`${IOS_PLATFORM_CSS_CLASS} CSS class is present`
);
} else {
TKUnit.assertTrue(rootViewCssClasses.has(
IOS_PLATFORM_CSS_CLASS),
`${IOS_PLATFORM_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
ANDROID_PLATFORM_CSS_CLASS),
`${ANDROID_PLATFORM_CSS_CLASS} CSS class is present`
);
}
if (shouldSetClassName) {
TKUnit.assertTrue(rootViewCssClasses.has(
CLASS_NAME),
`${CLASS_NAME} CSS class is missing`
);
}
_test_root_css_class(rootView, false, true);
}
export function test_root_view_platform_css_class() {
_test_root_view_platform_css_class(false);
const rootView = getRootView();
_test_platform_css_class(rootView, false);
}
export function test_root_view_class_name_preserve_platform_css_class() {
_test_root_view_platform_css_class(true);
}
function _test_root_view_device_type_css_class(shouldSetClassName: boolean) {
const rootView = getRootView();
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const rootViewCssClasses = rootView.cssClasses;
const deviceType = device.deviceType;
if (deviceType === DeviceType.Phone) {
TKUnit.assertTrue(rootViewCssClasses.has(
PHONE_DEVICE_TYPE_CSS_CLASS),
`${PHONE_DEVICE_TYPE_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
TABLET_DEVICE_TYPE_CSS_CLASS),
`${TABLET_DEVICE_TYPE_CSS_CLASS} CSS class is present`
);
} else {
TKUnit.assertTrue(rootViewCssClasses.has(
TABLET_DEVICE_TYPE_CSS_CLASS),
`${TABLET_DEVICE_TYPE_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
PHONE_DEVICE_TYPE_CSS_CLASS),
`${PHONE_DEVICE_TYPE_CSS_CLASS} CSS class is present`
);
}
if (shouldSetClassName) {
TKUnit.assertTrue(rootViewCssClasses.has(
CLASS_NAME),
`${CLASS_NAME} CSS class is missing`
);
}
_test_platform_css_class(rootView, true);
}
export function test_root_view_device_type_css_class() {
_test_root_view_device_type_css_class(false);
const rootView = getRootView();
_test_device_type_css_class(rootView, false);
}
export function test_root_view_class_name_preserve_device_type_css_class() {
_test_root_view_device_type_css_class(true);
}
function _test_root_view_orientation_css_class(shouldSetClassName: boolean) {
const rootView = getRootView();
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const rootViewCssClasses = rootView.cssClasses;
let appOrientation;
if (isAndroid) {
appOrientation = android.orientation;
} else {
appOrientation = ios.orientation;
}
if (appOrientation === "portrait") {
TKUnit.assertTrue(rootViewCssClasses.has(
PORTRAIT_ORIENTATION_CSS_CLASS),
`${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
LANDSCAPE_ORIENTATION_CSS_CLASS),
`${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is present`
);
TKUnit.assertFalse(rootViewCssClasses.has(
UNKNOWN_ORIENTATION_CSS_CLASS),
`${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is present`
);
} else if (appOrientation === "landscape") {
TKUnit.assertTrue(rootViewCssClasses.has(
LANDSCAPE_ORIENTATION_CSS_CLASS),
`${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
PORTRAIT_ORIENTATION_CSS_CLASS),
`${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is present`
);
TKUnit.assertFalse(rootViewCssClasses.has(
UNKNOWN_ORIENTATION_CSS_CLASS),
`${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is present`
);
} else if (appOrientation === "landscape") {
TKUnit.assertTrue(rootViewCssClasses.has(
UNKNOWN_ORIENTATION_CSS_CLASS),
`${UNKNOWN_ORIENTATION_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
LANDSCAPE_ORIENTATION_CSS_CLASS),
`${LANDSCAPE_ORIENTATION_CSS_CLASS} CSS class is present`
);
TKUnit.assertFalse(rootViewCssClasses.has(
PORTRAIT_ORIENTATION_CSS_CLASS),
`${PORTRAIT_ORIENTATION_CSS_CLASS} CSS class is present`
);
}
if (shouldSetClassName) {
TKUnit.assertTrue(rootViewCssClasses.has(
CLASS_NAME),
`${CLASS_NAME} CSS class is missing`
);
}
_test_device_type_css_class(rootView, true);
}
export function test_root_view_orientation_css_class() {
_test_root_view_orientation_css_class(false);
const rootView = getRootView();
_test_orientation_css_class(rootView, false);
}
export function test_root_view_class_name_preserve_orientation_css_class() {
_test_root_view_orientation_css_class(true);
}
function _test_root_view_system_appearance_css_class(shouldSetClassName: boolean) {
const rootView = getRootView();
if (shouldSetClassName) {
rootView.className = CLASS_NAME;
}
const rootViewCssClasses = rootView.cssClasses;
let systemAppearance;
if (isAndroid) {
systemAppearance = android.systemAppearance;
} else {
systemAppearance = ios.systemAppearance;
}
if (isIOS && iosUtils.MajorVersion <= 12) {
TKUnit.assertFalse(rootViewCssClasses.has(
DARK_SYSTEM_APPEARANCE_CSS_CLASS),
`${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`
);
TKUnit.assertFalse(rootViewCssClasses.has(
LIGHT_SYSTEM_APPEARANCE_CSS_CLASS),
`${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`
);
} else if (systemAppearance === "dark") {
TKUnit.assertTrue(rootViewCssClasses.has(
DARK_SYSTEM_APPEARANCE_CSS_CLASS),
`${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
LIGHT_SYSTEM_APPEARANCE_CSS_CLASS),
`${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`
);
} else if (systemAppearance === "light") {
TKUnit.assertTrue(rootViewCssClasses.has(
LIGHT_SYSTEM_APPEARANCE_CSS_CLASS),
`${LIGHT_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is missing`
);
TKUnit.assertFalse(rootViewCssClasses.has(
DARK_SYSTEM_APPEARANCE_CSS_CLASS),
`${DARK_SYSTEM_APPEARANCE_CSS_CLASS} CSS class is present`
);
}
if (shouldSetClassName) {
TKUnit.assertTrue(rootViewCssClasses.has(
CLASS_NAME),
`${CLASS_NAME} CSS class is missing`
);
}
_test_orientation_css_class(rootView, true);
}
export function test_root_view_system_appearance_css_class() {
_test_root_view_system_appearance_css_class(false);
const rootView = getRootView();
_test_system_appearance_css_class(rootView, false);
}
export function test_root_view_class_name_preserve_system_appearance_css_class() {
_test_root_view_system_appearance_css_class(true);
const rootView = getRootView();
_test_system_appearance_css_class(rootView, true);
}
// Modal root view
function _test_modal_root_view_modal_css_class(shouldSetClassName: boolean) {
let modalClosed = false;
@@ -294,20 +218,8 @@ function _test_modal_root_view_modal_css_class(shouldSetClassName: boolean) {
const page = <Page>args.object;
page.off(View.shownModallyEvent, modalPageShownModallyEventHandler);
const rootModalView = _rootModalViews[0];
if (shouldSetClassName) {
rootModalView.className = CLASS_NAME;
}
const rootModalViewCssClasses = rootModalView.cssClasses;
TKUnit.assertTrue(rootModalViewCssClasses.has(MODAL_CSS_CLASS),
`${MODAL_CSS_CLASS} CSS class is missing`);
if (shouldSetClassName) {
TKUnit.assertTrue(rootModalViewCssClasses.has(CLASS_NAME),
`${CLASS_NAME} CSS class is missing`);
}
const rootModalView = <View>_rootModalViews[0];
_test_root_css_class(rootModalView, true, shouldSetClassName);
args.closeCallback();
};
@@ -348,3 +260,219 @@ export function test_modal_root_view_modal_css_class() {
export function test_modal_root_view_class_name_preserve_modal_css_class() {
_test_modal_root_view_modal_css_class(true);
}
function _test_root_modal_view_platform_css_class(shouldSetClassName: boolean) {
let modalClosed = false;
const modalCloseCallback = function () {
modalClosed = true;
};
const modalPageShownModallyEventHandler = function (args: ShownModallyData) {
const page = <Page>args.object;
page.off(View.shownModallyEvent, modalPageShownModallyEventHandler);
const rootModalView = <View>_rootModalViews[0];
_test_platform_css_class(rootModalView, shouldSetClassName);
args.closeCallback();
};
const hostNavigatedToEventHandler = function (args) {
const page = <Page>args.object;
page.off(Page.navigatedToEvent, hostNavigatedToEventHandler);
const modalPage = new Page();
modalPage.on(View.shownModallyEvent, modalPageShownModallyEventHandler);
const button = <Button>page.content;
const options: ShowModalOptions = {
context: {},
closeCallback: modalCloseCallback,
fullscreen: false,
animated: false
};
button.showModal(modalPage, options);
};
const hostPageFactory = function (): Page {
const hostPage = new Page();
hostPage.on(Page.navigatedToEvent, hostNavigatedToEventHandler);
const button = new Button();
hostPage.content = button;
return hostPage;
};
helper.navigate(hostPageFactory);
TKUnit.waitUntilReady(() => modalClosed);
}
export function test_modal_root_view_platform_css_class() {
_test_root_modal_view_platform_css_class(false);
}
export function test_modal_root_view_class_name_preserve_platform_css_class() {
_test_root_modal_view_platform_css_class(true);
}
function _test_root_modal_view_device_type_css_class(shouldSetClassName: boolean) {
let modalClosed = false;
const modalCloseCallback = function () {
modalClosed = true;
};
const modalPageShownModallyEventHandler = function (args: ShownModallyData) {
const page = <Page>args.object;
page.off(View.shownModallyEvent, modalPageShownModallyEventHandler);
const rootModalView = <View>_rootModalViews[0];
_test_device_type_css_class(rootModalView, shouldSetClassName);
args.closeCallback();
};
const hostNavigatedToEventHandler = function (args) {
const page = <Page>args.object;
page.off(Page.navigatedToEvent, hostNavigatedToEventHandler);
const modalPage = new Page();
modalPage.on(View.shownModallyEvent, modalPageShownModallyEventHandler);
const button = <Button>page.content;
const options: ShowModalOptions = {
context: {},
closeCallback: modalCloseCallback,
fullscreen: false,
animated: false
};
button.showModal(modalPage, options);
};
const hostPageFactory = function (): Page {
const hostPage = new Page();
hostPage.on(Page.navigatedToEvent, hostNavigatedToEventHandler);
const button = new Button();
hostPage.content = button;
return hostPage;
};
helper.navigate(hostPageFactory);
TKUnit.waitUntilReady(() => modalClosed);
}
export function test_modal_root_view_device_type_css_class() {
_test_root_modal_view_device_type_css_class(false);
}
export function test_modal_root_view_class_name_preserve_device_type_css_class() {
_test_root_modal_view_device_type_css_class(true);
}
function _test_root_modal_view_orientation_css_class(shouldSetClassName: boolean) {
let modalClosed = false;
const modalCloseCallback = function () {
modalClosed = true;
};
const modalPageShownModallyEventHandler = function (args: ShownModallyData) {
const page = <Page>args.object;
page.off(View.shownModallyEvent, modalPageShownModallyEventHandler);
const rootModalView = <View>_rootModalViews[0];
_test_orientation_css_class(rootModalView, shouldSetClassName);
args.closeCallback();
};
const hostNavigatedToEventHandler = function (args) {
const page = <Page>args.object;
page.off(Page.navigatedToEvent, hostNavigatedToEventHandler);
const modalPage = new Page();
modalPage.on(View.shownModallyEvent, modalPageShownModallyEventHandler);
const button = <Button>page.content;
const options: ShowModalOptions = {
context: {},
closeCallback: modalCloseCallback,
fullscreen: false,
animated: false
};
button.showModal(modalPage, options);
};
const hostPageFactory = function (): Page {
const hostPage = new Page();
hostPage.on(Page.navigatedToEvent, hostNavigatedToEventHandler);
const button = new Button();
hostPage.content = button;
return hostPage;
};
helper.navigate(hostPageFactory);
TKUnit.waitUntilReady(() => modalClosed);
}
export function test_modal_root_view_orientation_css_class() {
_test_root_modal_view_orientation_css_class(false);
}
export function test_modal_root_view_class_name_preserve_orientation_css_class() {
_test_root_modal_view_orientation_css_class(true);
}
function _test_root_modal_view_system_appearance_css_class(shouldSetClassName: boolean) {
let modalClosed = false;
const modalCloseCallback = function () {
modalClosed = true;
};
const modalPageShownModallyEventHandler = function (args: ShownModallyData) {
const page = <Page>args.object;
page.off(View.shownModallyEvent, modalPageShownModallyEventHandler);
const rootModalView = <View>_rootModalViews[0];
_test_system_appearance_css_class(rootModalView, shouldSetClassName);
args.closeCallback();
};
const hostNavigatedToEventHandler = function (args) {
const page = <Page>args.object;
page.off(Page.navigatedToEvent, hostNavigatedToEventHandler);
const modalPage = new Page();
modalPage.on(View.shownModallyEvent, modalPageShownModallyEventHandler);
const button = <Button>page.content;
const options: ShowModalOptions = {
context: {},
closeCallback: modalCloseCallback,
fullscreen: false,
animated: false
};
button.showModal(modalPage, options);
};
const hostPageFactory = function (): Page {
const hostPage = new Page();
hostPage.on(Page.navigatedToEvent, hostNavigatedToEventHandler);
const button = new Button();
hostPage.content = button;
return hostPage;
};
helper.navigate(hostPageFactory);
TKUnit.waitUntilReady(() => modalClosed);
}
export function test_modal_root_view_system_appearance_css_class() {
_test_root_modal_view_system_appearance_css_class(false);
}
export function test_modal_root_view_class_name_preserve_system_appearance_css_class() {
_test_root_modal_view_system_appearance_css_class(true);
}

8
tests/app/ui/styling/style-tests.ts
View File

@@ -1789,6 +1789,7 @@ export function test_nested_css_calc_and_variables() {
const cssVarName = `--my-width-factor-base-${Date.now()}`;
const cssVarName2 = `--my-width-factor-${Date.now()}`;
const undefinedCssVarName = `--my-undefined-variable-${Date.now()}`;
const stack = new stackModule.StackLayout();
stack.css = `
@@ -1809,6 +1810,10 @@ export function test_nested_css_calc_and_variables() {
StackLayout.nested {
${cssVarName2}: calc(var(${cssVarName}) * 2);
}
StackLayout.nested-fallback {
width: calc(calc(var(${undefinedCssVarName}, 16) / 2) * 2));
}
`;
const label = new labelModule.Label();
@@ -1841,6 +1846,9 @@ export function test_nested_css_calc_and_variables() {
stack.className = "nested";
TKUnit.assertDeepEqual(stack.width, { unit: "%", value: 1 }, "Stack - width === 100%");
stack.className = "nested-fallback";
TKUnit.assertDeepEqual(stack.width, 16, "Stack - width === 16");
}
export function test_css_variable_is_applied_to_normal_properties() {

2
tests/app/xml-declaration/xml-declaration-tests.ts
View File

@@ -469,7 +469,7 @@ export function test_parse_ShouldParseBindingToSpecialProperty() {
p.bindingContext = obj;
TKUnit.assertEqual(p.content.className, classProp);
TKUnit.assertEqual(p.content.cssClasses.size, 1);
TKUnit.assert(p.content.cssClasses.has(classProp));
}
export function test_parse_ShouldParseBindingsWithCommaInsideSingleQuote() {