mirror of
https://github.com/NativeScript/NativeScript.git
synced 2025-11-05 13:26:48 +08:00
808 lines
28 KiB
TypeScript
808 lines
28 KiB
TypeScript
import * as TKUnit from '../../tk-unit';
|
|
import * as helper from '../../ui-helper';
|
|
import { View, isIOS, StackLayout, Page, Color, Span, FormattedString } from '@nativescript/core';
|
|
import { getNativeText, getNativeHint, typeTextNatively, typeTextNativelyWithReturn, getNativeSecure, getNativeFontSize, getNativeColor, getNativeBackgroundColor, getNativeTextAlignment, getNativePlaceholderColor, getNativeFocus } from './text-field-tests-native';
|
|
|
|
// >> require-textfield
|
|
import { TextField } from '@nativescript/core/ui/text-field';
|
|
// << require-textfield
|
|
// Other frequently used modules when working with buttons include:
|
|
// >> require-observable-binding-options-textfield
|
|
import { BindingOptions } from '@nativescript/core/ui/core/bindable';
|
|
|
|
import { Observable } from '@nativescript/core/data/observable';
|
|
// << require-observable-binding-options-textfield
|
|
|
|
// ### Binding two TextFields text property to observable view-model property.
|
|
// >> binding-text-property-textfield
|
|
function pageLoaded(args) {
|
|
var page = args.object;
|
|
var obj = new Observable();
|
|
obj.set('someProperty', 'Please change this text!');
|
|
page.bindingContext = obj;
|
|
}
|
|
exports.pageLoaded = pageLoaded;
|
|
// << binding-text-property-textfield
|
|
|
|
export function test_recycling() {
|
|
helper.nativeView_recycling_test(_createTextFieldFunc);
|
|
}
|
|
|
|
var _createTextFieldFunc = function (): TextField {
|
|
// >> creating-textfield
|
|
var textField = new TextField();
|
|
// << creating-textfield
|
|
textField.text = 'textField';
|
|
|
|
return textField;
|
|
};
|
|
|
|
export var testSetText = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> setting-text-property
|
|
textField.text = 'Hello, world!';
|
|
// << setting-text-property
|
|
|
|
var expectedValue = 'Hello, world!';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextNull = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.text = null;
|
|
|
|
var expectedValue = '';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextUndefined = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.text = undefined;
|
|
|
|
var expectedValue = '';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextToZero = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
(<any>textField).text = 0;
|
|
|
|
var expectedValue = '0';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
function createFormattedString(value: any): FormattedString {
|
|
var span = new Span();
|
|
span.text = value;
|
|
var result = new FormattedString();
|
|
result.spans.push(span);
|
|
|
|
return result;
|
|
}
|
|
|
|
export var testSetTextWithSpan = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.formattedText = createFormattedString('Hello, world!');
|
|
|
|
var expectedValue = 'Hello, world!';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextNullWithSpan = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.formattedText = createFormattedString(null);
|
|
|
|
var expectedValue = '';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextUndefinedWithSpan = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.formattedText = createFormattedString(undefined);
|
|
|
|
var expectedValue = '';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
export var testSetTextToZeroWithSpan = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.formattedText = createFormattedString(0);
|
|
|
|
var expectedValue = '0';
|
|
var actualValue = getNativeText(textField);
|
|
TKUnit.assertEqual(actualValue, expectedValue, 'TextField native text');
|
|
});
|
|
};
|
|
|
|
/* tslint:disable */
|
|
export var testSetHintToNumber = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var expectedValue = 1;
|
|
|
|
// >> setting-hint-property
|
|
textField.hint = <any>expectedValue;
|
|
// << setting-hint-property
|
|
|
|
var actualValue = getNativeHint(textField);
|
|
TKUnit.assert(<any>actualValue == expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
/* tslint:enable */
|
|
export var testBindTextDirectlyToModel = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> binding-text-property-second
|
|
var model = new Observable();
|
|
model.set('username', 'john');
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'username',
|
|
targetProperty: 'text',
|
|
};
|
|
textField.bind(options, model);
|
|
// textField.text is now "john"
|
|
// >> (hide)
|
|
TKUnit.assert(textField.text === 'john', 'Actual: ' + textField.text + '; Expected: ' + 'john');
|
|
TKUnit.assert(getNativeText(textField) === 'john', 'Actual: ' + getNativeText(textField) + '; Expected: ' + 'john');
|
|
// << (hide)
|
|
model.set('username', 'mary');
|
|
// textField.text is now "mary"
|
|
// >> (hide)
|
|
TKUnit.assert(textField.text === 'mary', 'Actual: ' + textField.text + '; Expected: ' + 'mary');
|
|
TKUnit.assert(getNativeText(textField) === 'mary', 'Actual: ' + getNativeText(textField) + '; Expected: ' + 'mary');
|
|
// << (hide)
|
|
// << binding-text-property-second
|
|
});
|
|
};
|
|
|
|
// Supported for ios only.
|
|
if (isIOS) {
|
|
exports.test_set_color = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
textField.color = new Color('red');
|
|
TKUnit.assert(textField.color.ios.CGColor.isEqual(textField.ios.textColor.CGColor), 'textField.color');
|
|
});
|
|
};
|
|
}
|
|
|
|
export var testBindTextToBindingContext = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
|
|
var model = new Observable();
|
|
model.set('username', 'john');
|
|
page.bindingContext = model;
|
|
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'username',
|
|
targetProperty: 'text',
|
|
};
|
|
|
|
textField.bind(options);
|
|
TKUnit.assert(textField.text === 'john', 'Actual: ' + textField.text + '; Expected: ' + 'john');
|
|
TKUnit.assert(getNativeText(textField) === 'john', 'Actual: ' + getNativeText(textField) + '; Expected: ' + 'john');
|
|
|
|
model.set('username', 'mary');
|
|
TKUnit.assert(textField.text === 'mary', 'Actual: ' + textField.text + '; Expected: ' + 'mary');
|
|
TKUnit.assert(getNativeText(textField) === 'mary', 'Actual: ' + getNativeText(textField) + '; Expected: ' + 'mary');
|
|
});
|
|
};
|
|
|
|
export var testTextIsUpdatedWhenUserTypes = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
textField.updateTextTrigger = 'focusLost';
|
|
|
|
var expectedValue = 'Hello, world!';
|
|
typeTextNatively(textField, expectedValue);
|
|
|
|
var actualValue = textField.text;
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testSetHint = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> setting-hint-text
|
|
textField.hint = 'type your username here';
|
|
// << setting-hint-text
|
|
|
|
var expectedValue = 'type your username here';
|
|
var actualValue = getNativeHint(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testBindHintDirectlyToModel = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> binding-hint-property-textfield
|
|
var model = new Observable();
|
|
model.set('hint', 'type your username here');
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'hint',
|
|
targetProperty: 'hint',
|
|
};
|
|
textField.bind(options, model);
|
|
// textField.hint is now "type your username here"
|
|
// >> (hide)
|
|
TKUnit.assert(textField.hint === 'type your username here', 'Actual: ' + textField.text + '; Expected: ' + 'type your username here');
|
|
TKUnit.assert(getNativeHint(textField) === 'type your username here', 'Actual: ' + getNativeHint(textField) + '; Expected: ' + 'type your username here');
|
|
// << (hide)
|
|
model.set('hint', 'type your password here');
|
|
// textField.hint is now "type your password here"
|
|
// >> (hide)
|
|
TKUnit.assert(textField.hint === 'type your password here', 'Actual: ' + textField.text + '; Expected: ' + 'type your password here');
|
|
TKUnit.assert(getNativeHint(textField) === 'type your password here', 'Actual: ' + getNativeHint(textField) + '; Expected: ' + 'type your password here');
|
|
// << (hide)
|
|
// << binding-hint-property-textfield
|
|
});
|
|
};
|
|
|
|
export var testBindHintToBindingConext = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
|
|
var model = new Observable();
|
|
model.set('hint', 'type your username here');
|
|
page.bindingContext = model;
|
|
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'hint',
|
|
targetProperty: 'hint',
|
|
};
|
|
|
|
textField.bind(options);
|
|
TKUnit.assert(textField.hint === 'type your username here', 'Actual: ' + textField.hint + '; Expected: ' + 'type your username here');
|
|
TKUnit.assert(getNativeHint(textField) === 'type your username here', 'Actual: ' + getNativeHint(textField) + '; Expected: ' + 'type your username here');
|
|
|
|
model.set('hint', 'type your password here');
|
|
TKUnit.assert(textField.hint === 'type your password here', 'Actual: ' + textField.text + '; Expected: ' + 'type your password here');
|
|
TKUnit.assert(getNativeHint(textField) === 'type your password here', 'Actual: ' + getNativeHint(textField) + '; Expected: ' + 'type your password here');
|
|
});
|
|
};
|
|
|
|
export var testSetSecure = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> setting-secure-property
|
|
textField.secure = true;
|
|
// << setting-secure-property
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeSecure(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testSetSecureAndKeyboardTypeNumber = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.secure = true;
|
|
textField.keyboardType = 'number';
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeSecure(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testSetKeyboardTypeNumberAndSecure = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.keyboardType = 'number';
|
|
textField.secure = true;
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeSecure(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testSetSecureAndKeyboardTypeDecimal = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.secure = true;
|
|
textField.keyboardType = 'decimal';
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeSecure(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testSetKeyboardTypeDecimalAndSecure = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
textField.keyboardType = 'decimal';
|
|
textField.secure = true;
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeSecure(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
export var testBindSecureDirectlyToModel = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> binding-secure-property
|
|
var model = new Observable();
|
|
model.set('secure', true);
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'secure',
|
|
targetProperty: 'secure',
|
|
};
|
|
textField.bind(options, model);
|
|
// textField.secure is now true
|
|
// >> (hide)
|
|
TKUnit.assert(textField.secure === true, 'Actual: ' + textField.secure + '; Expected: ' + true);
|
|
TKUnit.assert(getNativeSecure(textField) === true, 'Actual: ' + getNativeSecure(textField) + '; Expected: ' + true);
|
|
// << (hide)
|
|
model.set('secure', false);
|
|
// textField.secure is now false
|
|
// >> (hide)
|
|
TKUnit.assert(textField.secure === false, 'Actual: ' + textField.secure + '; Expected: ' + false);
|
|
TKUnit.assert(getNativeSecure(textField) === false, 'Actual: ' + getNativeSecure(textField) + '; Expected: ' + false);
|
|
// << (hide)
|
|
// << binding-secure-property
|
|
});
|
|
};
|
|
|
|
export var testBindSecureToBindingConext = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
|
|
var model = new Observable();
|
|
model.set('secure', true);
|
|
page.bindingContext = model;
|
|
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'secure',
|
|
targetProperty: 'secure',
|
|
};
|
|
|
|
textField.bind(options);
|
|
TKUnit.assert(textField.secure === true, 'Actual: ' + textField.secure + '; Expected: ' + true);
|
|
TKUnit.assert(getNativeSecure(textField) === true, 'Actual: ' + getNativeSecure(textField) + '; Expected: ' + true);
|
|
|
|
model.set('secure', false);
|
|
TKUnit.assert(textField.secure === false, 'Actual: ' + textField.secure + '; Expected: ' + false);
|
|
TKUnit.assert(getNativeSecure(textField) === false, 'Actual: ' + getNativeSecure(textField) + '; Expected: ' + false);
|
|
});
|
|
};
|
|
|
|
// iOS only
|
|
export var testBindCloseOnReturnToBindingConext = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
if (!isIOS) {
|
|
TKUnit.assert(true === true);
|
|
|
|
return;
|
|
}
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
|
|
var model = new Observable();
|
|
model.set('closeOnReturn', false);
|
|
page.bindingContext = model;
|
|
|
|
var options: BindingOptions = {
|
|
sourceProperty: 'closeOnReturn',
|
|
targetProperty: 'closeOnReturn',
|
|
};
|
|
|
|
textField.bind(options);
|
|
TKUnit.assert(textField.closeOnReturn === false, 'Actual: ' + textField.closeOnReturn + '; Expected: ' + false);
|
|
typeTextNativelyWithReturn(textField, 'Should not close textfield');
|
|
TKUnit.assert(getNativeFocus(textField) === true, 'Actual: ' + getNativeFocus(textField) + '; Expected: ' + true);
|
|
|
|
model.set('closeOnReturn', true);
|
|
TKUnit.assert(textField.closeOnReturn === true, 'Actual: ' + textField.closeOnReturn + '; Expected: ' + true);
|
|
typeTextNativelyWithReturn(textField, 'Should close textfield');
|
|
TKUnit.assert(getNativeFocus(textField) === false, 'Actual: ' + getNativeFocus(textField) + '; Expected: ' + false);
|
|
});
|
|
};
|
|
|
|
// iOS only
|
|
export var testDontCloseOnReturn = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
if (!isIOS) {
|
|
TKUnit.assert(true === true);
|
|
|
|
return;
|
|
}
|
|
var textField = <TextField>views[0];
|
|
|
|
// >> setting-closeOnReturn-property
|
|
textField.closeOnReturn = false;
|
|
// << setting-closeOnReturn-property
|
|
|
|
typeTextNativelyWithReturn(textField, 'Should not close textfield');
|
|
|
|
var expectedValue = true;
|
|
var actualValue = getNativeFocus(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
// iOS only
|
|
export var testCloseOnReturn = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
if (!isIOS) {
|
|
TKUnit.assert(true === true);
|
|
|
|
return;
|
|
}
|
|
var textField = <TextField>views[0];
|
|
textField.closeOnReturn = true;
|
|
|
|
typeTextNativelyWithReturn(textField, 'Should close textfield');
|
|
|
|
var expectedValue = false;
|
|
var actualValue = getNativeFocus(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
// iOS only
|
|
export var testCloseOnReturnByDefault = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
if (!isIOS) {
|
|
TKUnit.assert(true === true);
|
|
|
|
return;
|
|
}
|
|
var textField = <TextField>views[0];
|
|
|
|
typeTextNativelyWithReturn(textField, 'Should close textfield by default');
|
|
|
|
var expectedValue = false;
|
|
var actualValue = getNativeFocus(textField);
|
|
TKUnit.assert(actualValue === expectedValue, 'Actual: ' + actualValue + '; Expected: ' + expectedValue);
|
|
});
|
|
};
|
|
|
|
var expectedFontSize = 42;
|
|
export var testLocalFontSizeFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
|
|
page.css = 'textfield { font-size: ' + expectedFontSize + '; }';
|
|
var actualResult = textField.style.fontSize;
|
|
TKUnit.assert(actualResult === expectedFontSize, 'Actual: ' + actualResult + '; Expected: ' + expectedFontSize);
|
|
});
|
|
};
|
|
|
|
export var testNativeFontSizeFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { font-size: ' + expectedFontSize + '; }';
|
|
|
|
var actualResult = getNativeFontSize(textField);
|
|
helper.assertAreClose(actualResult, expectedFontSize, 'FontSizeFromCss');
|
|
});
|
|
};
|
|
|
|
export var testNativeFontSizeFromLocal = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
textField.style.fontSize = expectedFontSize;
|
|
|
|
var actualResult = getNativeFontSize(textField);
|
|
helper.assertAreClose(actualResult, expectedFontSize, 'FontSizeFromLocal');
|
|
});
|
|
};
|
|
|
|
var expectedColorHex = '#FF0000FF';
|
|
var expectedNormalizedColorHex = '#FF0000';
|
|
export var testLocalColorFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { color: ' + expectedColorHex + '; }';
|
|
|
|
var actualResult = textField.style.color.hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedColorHex);
|
|
});
|
|
};
|
|
|
|
export var testNativeColorFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { color: ' + expectedColorHex + '; }';
|
|
|
|
var actualResult = getNativeColor(textField).hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedColorHex);
|
|
});
|
|
};
|
|
|
|
export var testNativeColorFromLocal = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
textField.style.color = new Color(expectedColorHex);
|
|
|
|
var actualResult = getNativeColor(textField).hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedColorHex);
|
|
});
|
|
};
|
|
|
|
var expectedBackgroundColorHex = '#00FF00FF';
|
|
var expectedNormalizedBackgroundColorHex = '#00FF00';
|
|
export var testLocalBackgroundColorFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { background-color: ' + expectedBackgroundColorHex + '; }';
|
|
|
|
var actualResult = textField.style.backgroundColor.hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedBackgroundColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedBackgroundColorHex);
|
|
});
|
|
};
|
|
|
|
export var testNativeBackgroundColorFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { background-color: ' + expectedBackgroundColorHex + '; }';
|
|
|
|
helper.waitUntilLayoutReady(textField);
|
|
|
|
var actualResult = getNativeBackgroundColor(textField).hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedBackgroundColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedBackgroundColorHex);
|
|
});
|
|
};
|
|
|
|
export var testNativeBackgroundColorFromLocal = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var textField = <TextField>views[0];
|
|
textField.style.backgroundColor = new Color(expectedBackgroundColorHex);
|
|
|
|
helper.waitUntilLayoutReady(textField);
|
|
|
|
var actualResult = getNativeBackgroundColor(textField).hex;
|
|
TKUnit.assert(actualResult === expectedNormalizedBackgroundColorHex, 'Actual: ' + actualResult + '; Expected: ' + expectedNormalizedBackgroundColorHex);
|
|
});
|
|
};
|
|
|
|
var expectedTextAlignment: 'right' = 'right';
|
|
export var testLocalTextAlignmentFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var view = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { text-align: ' + expectedTextAlignment + '; }';
|
|
|
|
var actualResult = view.style.textAlignment;
|
|
TKUnit.assert(actualResult === expectedTextAlignment, 'Actual: ' + actualResult + '; Expected: ' + expectedTextAlignment);
|
|
});
|
|
};
|
|
|
|
export var testNativeTextAlignmentFromCss = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var view = <TextField>views[0];
|
|
var page = <Page>views[1];
|
|
page.css = 'textfield { text-align: ' + expectedTextAlignment + '; }';
|
|
|
|
var actualResult = getNativeTextAlignment(view);
|
|
TKUnit.assert(actualResult === expectedTextAlignment, 'Actual: ' + actualResult + '; Expected: ' + expectedTextAlignment);
|
|
});
|
|
};
|
|
|
|
export var testNativeTextAlignmentFromLocal = function () {
|
|
helper.buildUIAndRunTest(_createTextFieldFunc(), function (views: Array<View>) {
|
|
var view = <TextField>views[0];
|
|
view.style.textAlignment = expectedTextAlignment;
|
|
|
|
var actualResult = getNativeTextAlignment(view);
|
|
TKUnit.assert(actualResult === expectedTextAlignment, 'Actual: ' + actualResult + '; Expected: ' + expectedTextAlignment);
|
|
});
|
|
};
|
|
|
|
// export var testMemoryLeak = function (done) {
|
|
// helper.buildUIWithWeakRefAndInteract(
|
|
// _createTextFieldFunc,
|
|
// function (textField) {
|
|
// typeTextNatively(textField, 'Hello, world!');
|
|
// },
|
|
// done
|
|
// );
|
|
// };
|
|
|
|
export var test_WhenFormattedTextPropertyChanges_TextIsUpdated_TextBase = function () {
|
|
var firstSpan = new Span();
|
|
firstSpan.fontSize = 10;
|
|
firstSpan.text = 'First';
|
|
var secondSpan = new Span();
|
|
secondSpan.fontSize = 15;
|
|
secondSpan.text = 'Second';
|
|
var thirdSpan = new Span();
|
|
thirdSpan.fontSize = 20;
|
|
thirdSpan.text = 'Third';
|
|
var formattedString1 = new FormattedString();
|
|
formattedString1.spans.push(firstSpan);
|
|
var formattedString2 = new FormattedString();
|
|
formattedString2.spans.push(secondSpan);
|
|
formattedString2.spans.push(thirdSpan);
|
|
|
|
var view = new TextField();
|
|
helper.buildUIAndRunTest(view, function (views: Array<View>) {
|
|
TKUnit.assertEqual(view.text, '');
|
|
|
|
view.formattedText = formattedString1;
|
|
TKUnit.assertEqual(view.text, 'First');
|
|
|
|
view.formattedText = formattedString2;
|
|
TKUnit.assertEqual(view.text, 'SecondThird');
|
|
|
|
formattedString2.spans.getItem(0).text = 'Mecond';
|
|
TKUnit.assertEqual(view.text, 'MecondThird');
|
|
|
|
view.formattedText = null;
|
|
TKUnit.assertEqual(view.text, '');
|
|
});
|
|
};
|
|
|
|
export function test_IntegrationTest_Transform_Decoration_Spacing_WithoutFormattedText_DoesNotCrash() {
|
|
const view = new TextField();
|
|
helper.buildUIAndRunTest(view, function (views: Array<View>) {
|
|
TKUnit.assertEqual(view.text, '', 'Text');
|
|
TKUnit.assertEqual(view.style.textTransform, 'initial', 'TextTransform default value');
|
|
TKUnit.assertEqual(view.style.textDecoration, 'none', 'TextDecoration default value');
|
|
TKUnit.assertTrue(view.style.letterSpacing === 0, 'LetterSpacing default value');
|
|
|
|
view.text = 'NormalText';
|
|
view.setInlineStyle('text-transform: uppercase; text-decoration: underline; letter-spacing: 1;');
|
|
|
|
TKUnit.assertEqual(view.style.textTransform, 'uppercase', 'TextTransform');
|
|
TKUnit.assertEqual(view.style.textDecoration, 'underline', 'TextDecoration');
|
|
TKUnit.assertEqual(view.style.letterSpacing, 1, 'LetterSpacing');
|
|
});
|
|
}
|
|
|
|
export function test_IntegrationTest_Transform_Decoration_Spacing_WithFormattedText_DoesNotCrash() {
|
|
const view = new TextField();
|
|
const formattedString = helper._generateFormattedString();
|
|
helper.buildUIAndRunTest(view, function (views: Array<View>) {
|
|
view.formattedText = formattedString;
|
|
view.setInlineStyle('text-transform: uppercase; text-decoration: underline; letter-spacing: 1;');
|
|
|
|
TKUnit.assertEqual(view.style.textTransform, 'uppercase', 'TextTransform');
|
|
TKUnit.assertEqual(view.style.textDecoration, 'underline', 'TextDecoration');
|
|
TKUnit.assertEqual(view.style.letterSpacing, 1, 'LetterSpacing');
|
|
});
|
|
}
|
|
|
|
export function test_set_placeholder_color() {
|
|
const view = new TextField();
|
|
const expectedColorHex = '#FF0000FF';
|
|
const expectedNormalizedColorHex = '#FF0000';
|
|
helper.buildUIAndRunTest(view, function (views: Array<View>) {
|
|
view.hint = 'Some text for hint';
|
|
view.setInlineStyle('placeholder-color: ' + expectedColorHex + ';');
|
|
const actualColorHex = getNativePlaceholderColor(view).hex;
|
|
TKUnit.assertEqual(actualColorHex, expectedNormalizedColorHex);
|
|
});
|
|
}
|
|
|
|
export function test_set_placeholder_color_when_hint_is_not_set() {
|
|
const view = new TextField();
|
|
const expectedColorHex = '#FF0000FF';
|
|
const expectedNormalizedColorHex = '#FF0000';
|
|
helper.buildUIAndRunTest(view, function (views: Array<View>) {
|
|
view.setInlineStyle('placeholder-color: ' + expectedColorHex + ';');
|
|
const actualColorHex = getNativePlaceholderColor(view).hex;
|
|
TKUnit.assertEqual(actualColorHex, expectedNormalizedColorHex);
|
|
});
|
|
}
|
|
|
|
export function test_android_ime_actions_move_focus() {
|
|
if (isIOS) {
|
|
return;
|
|
}
|
|
|
|
const stack = new StackLayout();
|
|
const addTextField = () => {
|
|
const tf = new TextField();
|
|
(<any>tf).returnPress = 0;
|
|
tf.on('returnPress', (args) => (<any>args.object).returnPress++);
|
|
stack.addChild(tf);
|
|
};
|
|
|
|
addTextField();
|
|
addTextField();
|
|
addTextField();
|
|
|
|
const assert = (index, count) => {
|
|
const view: any = stack.getChildAt(index);
|
|
TKUnit.assertEqual(view.returnPress, count, `TextField at ${index}, has incorrect returnPress.`);
|
|
};
|
|
helper.buildUIAndRunTest(stack, (views: Array<View>) => {
|
|
(stack.getChildAt(0) as TextField).focus();
|
|
|
|
let edittext = stack._context.getCurrentFocus();
|
|
TKUnit.assertNotNull(edittext, 'TextField not focused.');
|
|
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_NEXT);
|
|
assert(0, 1);
|
|
assert(1, 0);
|
|
assert(2, 0);
|
|
|
|
edittext = stack._context.getCurrentFocus();
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_NEXT);
|
|
assert(0, 1);
|
|
assert(1, 1);
|
|
assert(2, 0);
|
|
|
|
edittext = stack._context.getCurrentFocus();
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_NEXT);
|
|
assert(0, 1);
|
|
assert(1, 1);
|
|
assert(2, 1);
|
|
|
|
edittext = stack._context.getCurrentFocus();
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_PREVIOUS);
|
|
assert(0, 2);
|
|
assert(1, 1);
|
|
assert(2, 1);
|
|
|
|
edittext = stack._context.getCurrentFocus();
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_PREVIOUS);
|
|
assert(0, 2);
|
|
assert(1, 1);
|
|
assert(2, 2);
|
|
|
|
edittext = stack._context.getCurrentFocus();
|
|
edittext.onEditorAction(android.view.inputmethod.EditorInfo.IME_ACTION_PREVIOUS);
|
|
assert(0, 2);
|
|
assert(1, 2);
|
|
assert(2, 2);
|
|
});
|
|
}
|