| // Copyright 2014 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import 'package:flutter/cupertino.dart'; |
| import 'package:flutter/foundation.dart'; |
| import 'package:flutter/gestures.dart'; |
| import 'package:flutter/material.dart'; |
| import 'package:flutter/rendering.dart'; |
| import 'package:flutter/services.dart'; |
| import 'package:flutter_test/flutter_test.dart'; |
| |
| import '../rendering/mock_canvas.dart'; |
| import '../widgets/clipboard_utils.dart'; |
| import 'editable_text_utils.dart'; |
| import 'semantics_tester.dart'; |
| |
| Matcher matchesMethodCall(String method, { dynamic args }) => _MatchesMethodCall(method, arguments: args == null ? null : wrapMatcher(args)); |
| |
| class _MatchesMethodCall extends Matcher { |
| const _MatchesMethodCall(this.name, {this.arguments}); |
| |
| final String name; |
| final Matcher? arguments; |
| |
| @override |
| bool matches(dynamic item, Map<dynamic, dynamic> matchState) { |
| if (item is MethodCall && item.method == name) |
| return arguments?.matches(item.arguments, matchState) ?? true; |
| return false; |
| } |
| |
| @override |
| Description describe(Description description) { |
| final Description newDescription = description.add('has method name: ').addDescriptionOf(name); |
| if (arguments != null) |
| newDescription.add(' with arguments: ').addDescriptionOf(arguments); |
| return newDescription; |
| } |
| } |
| |
| late TextEditingController controller; |
| final FocusNode focusNode = FocusNode(debugLabel: 'EditableText Node'); |
| final FocusScopeNode focusScopeNode = FocusScopeNode(debugLabel: 'EditableText Scope Node'); |
| const TextStyle textStyle = TextStyle(); |
| const Color cursorColor = Color.fromARGB(0xFF, 0xFF, 0x00, 0x00); |
| |
| enum HandlePositionInViewport { |
| leftEdge, rightEdge, within, |
| } |
| |
| void main() { |
| final MockClipboard mockClipboard = MockClipboard(); |
| (TestWidgetsFlutterBinding.ensureInitialized() as TestWidgetsFlutterBinding) |
| .defaultBinaryMessenger.setMockMethodCallHandler(SystemChannels.platform, mockClipboard.handleMethodCall); |
| |
| setUp(() async { |
| debugResetSemanticsIdCounter(); |
| controller = TextEditingController(); |
| // Fill the clipboard so that the Paste option is available in the text |
| // selection menu. |
| await Clipboard.setData(const ClipboardData(text: 'Clipboard data')); |
| }); |
| |
| tearDown(() { |
| controller.dispose(); |
| }); |
| |
| // Tests that the desired keyboard action button is requested. |
| // |
| // More technically, when an EditableText is given a particular [action], Flutter |
| // requests [serializedActionName] when attaching to the platform's input |
| // system. |
| Future<void> _desiredKeyboardActionIsRequested({ |
| required WidgetTester tester, |
| TextInputAction? action, |
| String serializedActionName = '', |
| }) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| textInputAction: action, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals(serializedActionName)); |
| } |
| |
| // Regression test for https://github.com/flutter/flutter/issues/34538. |
| testWidgets('RTL arabic correct caret placement after trailing whitespace', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.rtl, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.blue, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| |
| final EditableTextState state = tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Simulates Gboard Persian input. |
| state.updateEditingValue(const TextEditingValue(text: 'گ', selection: TextSelection.collapsed(offset: 1))); |
| await tester.pump(); |
| double previousCaretXPosition = state.renderEditable.getLocalRectForCaret(state.textEditingValue.selection.base).left; |
| |
| state.updateEditingValue(const TextEditingValue(text: 'گی', selection: TextSelection.collapsed(offset: 2))); |
| await tester.pump(); |
| double caretXPosition = state.renderEditable.getLocalRectForCaret(state.textEditingValue.selection.base).left; |
| expect(caretXPosition, lessThan(previousCaretXPosition)); |
| previousCaretXPosition = caretXPosition; |
| |
| state.updateEditingValue(const TextEditingValue(text: 'گیگ', selection: TextSelection.collapsed(offset: 3))); |
| await tester.pump(); |
| caretXPosition = state.renderEditable.getLocalRectForCaret(state.textEditingValue.selection.base).left; |
| expect(caretXPosition, lessThan(previousCaretXPosition)); |
| previousCaretXPosition = caretXPosition; |
| |
| // Enter a whitespace in a RTL input field moves the caret to the left. |
| state.updateEditingValue(const TextEditingValue(text: 'گیگ ', selection: TextSelection.collapsed(offset: 4))); |
| await tester.pump(); |
| caretXPosition = state.renderEditable.getLocalRectForCaret(state.textEditingValue.selection.base).left; |
| expect(caretXPosition, lessThan(previousCaretXPosition)); |
| |
| expect(state.currentTextEditingValue.text, equals('گیگ ')); |
| }, skip: isBrowser); // https://github.com/flutter/flutter/issues/78550. |
| |
| testWidgets('has expected defaults', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ); |
| |
| final EditableText editableText = |
| tester.firstWidget(find.byType(EditableText)); |
| expect(editableText.maxLines, equals(1)); |
| expect(editableText.obscureText, isFalse); |
| expect(editableText.autocorrect, isTrue); |
| expect(editableText.enableSuggestions, isTrue); |
| expect(editableText.enableIMEPersonalizedLearning, isTrue); |
| expect(editableText.textAlign, TextAlign.start); |
| expect(editableText.cursorWidth, 2.0); |
| expect(editableText.cursorHeight, isNull); |
| expect(editableText.textHeightBehavior, isNull); |
| }); |
| |
| testWidgets('text keyboard is requested when maxLines is default', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| final EditableText editableText = |
| tester.firstWidget(find.byType(EditableText)); |
| expect(editableText.maxLines, equals(1)); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.text')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.done')); |
| }); |
| |
| testWidgets('Keyboard is configured for "unspecified" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.unspecified, |
| serializedActionName: 'TextInputAction.unspecified', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "none" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.none, |
| serializedActionName: 'TextInputAction.none', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "done" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.done, |
| serializedActionName: 'TextInputAction.done', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "send" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.send, |
| serializedActionName: 'TextInputAction.send', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "go" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.go, |
| serializedActionName: 'TextInputAction.go', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "search" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.search, |
| serializedActionName: 'TextInputAction.search', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "send" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.send, |
| serializedActionName: 'TextInputAction.send', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "next" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.next, |
| serializedActionName: 'TextInputAction.next', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "previous" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.previous, |
| serializedActionName: 'TextInputAction.previous', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "continue" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.continueAction, |
| serializedActionName: 'TextInputAction.continueAction', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "join" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.join, |
| serializedActionName: 'TextInputAction.join', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "route" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.route, |
| serializedActionName: 'TextInputAction.route', |
| ); |
| }); |
| |
| testWidgets('Keyboard is configured for "emergencyCall" action when explicitly requested', (WidgetTester tester) async { |
| await _desiredKeyboardActionIsRequested( |
| tester: tester, |
| action: TextInputAction.emergencyCall, |
| serializedActionName: 'TextInputAction.emergencyCall', |
| ); |
| }); |
| |
| group('Infer keyboardType from autofillHints', () { |
| testWidgets( |
| 'infer keyboard types from autofillHints: ios', |
| (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| autofillHints: const <String>[AutofillHints.streetAddressLine1], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect( |
| (tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], |
| // On web, we don't infer the keyboard type as "name". We only infer |
| // on iOS and macOS. |
| kIsWeb ? equals('TextInputType.address') : equals('TextInputType.name'), |
| ); |
| }, |
| variant: const TargetPlatformVariant(<TargetPlatform>{ TargetPlatform.iOS, TargetPlatform.macOS }), |
| ); |
| |
| testWidgets( |
| 'infer keyboard types from autofillHints: non-ios', |
| (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| autofillHints: const <String>[AutofillHints.streetAddressLine1], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.address')); |
| }, |
| ); |
| |
| testWidgets( |
| 'inferred keyboard types can be overridden: ios', |
| (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| keyboardType: TextInputType.text, |
| autofillHints: const <String>[AutofillHints.streetAddressLine1], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.text')); |
| }, |
| variant: const TargetPlatformVariant(<TargetPlatform>{ TargetPlatform.iOS, TargetPlatform.macOS }), |
| ); |
| |
| testWidgets( |
| 'inferred keyboard types can be overridden: non-ios', |
| (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| keyboardType: TextInputType.text, |
| autofillHints: const <String>[AutofillHints.streetAddressLine1], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.text')); |
| }, |
| ); |
| }); |
| |
| testWidgets('multiline keyboard is requested when set explicitly', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| keyboardType: TextInputType.multiline, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.multiline')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.newline')); |
| }); |
| |
| testWidgets('selection persists when unfocused', (WidgetTester tester) async { |
| const TextEditingValue value = TextEditingValue( |
| text: 'test test', |
| selection: TextSelection(affinity: TextAffinity.upstream, baseOffset: 5, extentOffset: 7), |
| ); |
| controller.value = value; |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| keyboardType: TextInputType.multiline, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ); |
| |
| expect(controller.value, value); |
| expect(focusNode.hasFocus, isFalse); |
| |
| focusNode.requestFocus(); |
| await tester.pump(); |
| |
| expect(controller.value, value); |
| expect(focusNode.hasFocus, isTrue); |
| |
| focusNode.unfocus(); |
| await tester.pump(); |
| |
| expect(controller.value, value); |
| expect(focusNode.hasFocus, isFalse); |
| }); |
| |
| testWidgets('visiblePassword keyboard is requested when set explicitly', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| keyboardType: TextInputType.visiblePassword, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.visiblePassword')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.done')); |
| }); |
| |
| testWidgets('enableSuggestions flag is sent to the engine properly', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| const bool enableSuggestions = false; |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| enableSuggestions: enableSuggestions, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| expect(tester.testTextInput.setClientArgs!['enableSuggestions'], enableSuggestions); |
| }); |
| |
| testWidgets('enableIMEPersonalizedLearning flag is sent to the engine properly', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| const bool enableIMEPersonalizedLearning = false; |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| enableIMEPersonalizedLearning: enableIMEPersonalizedLearning, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| expect(tester.testTextInput.setClientArgs!['enableIMEPersonalizedLearning'], enableIMEPersonalizedLearning); |
| }); |
| |
| group('smartDashesType and smartQuotesType', () { |
| testWidgets('sent to the engine properly', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| const SmartDashesType smartDashesType = SmartDashesType.disabled; |
| const SmartQuotesType smartQuotesType = SmartQuotesType.disabled; |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| smartDashesType: smartDashesType, |
| smartQuotesType: smartQuotesType, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| expect(tester.testTextInput.setClientArgs!['smartDashesType'], smartDashesType.index.toString()); |
| expect(tester.testTextInput.setClientArgs!['smartQuotesType'], smartQuotesType.index.toString()); |
| }); |
| |
| testWidgets('default to true when obscureText is false', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| expect(tester.testTextInput.setClientArgs!['smartDashesType'], '1'); |
| expect(tester.testTextInput.setClientArgs!['smartQuotesType'], '1'); |
| }); |
| |
| testWidgets('default to false when obscureText is true', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController(); |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| obscureText: true, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.idle(); |
| expect(tester.testTextInput.setClientArgs!['smartDashesType'], '0'); |
| expect(tester.testTextInput.setClientArgs!['smartQuotesType'], '0'); |
| }); |
| }); |
| |
| testWidgets('selection overlay will update when text grow bigger', (WidgetTester tester) async { |
| final TextEditingController controller = TextEditingController.fromValue( |
| const TextEditingValue( |
| text: 'initial value', |
| ), |
| ); |
| Future<void> pumpEditableTextWithTextStyle(TextStyle style) async { |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: style, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| showSelectionHandles: true, |
| ), |
| ), |
| ); |
| } |
| |
| await pumpEditableTextWithTextStyle(const TextStyle(fontSize: 18)); |
| final EditableTextState state = tester.state<EditableTextState>(find.byType(EditableText)); |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.longPress, |
| ); |
| await tester.pumpAndSettle(); |
| await tester.idle(); |
| |
| List<RenderBox> handles = List<RenderBox>.from( |
| tester.renderObjectList<RenderBox>( |
| find.descendant( |
| of: find.byType(CompositedTransformFollower), |
| matching: find.byType(Padding), |
| ), |
| ), |
| ); |
| |
| expect(handles[0].localToGlobal(Offset.zero), const Offset(-35.0, 5.0)); |
| expect(handles[1].localToGlobal(Offset.zero), const Offset(113.0, 5.0)); |
| |
| await pumpEditableTextWithTextStyle(const TextStyle(fontSize: 30)); |
| await tester.pumpAndSettle(); |
| |
| // Handles should be updated with bigger font size. |
| handles = List<RenderBox>.from( |
| tester.renderObjectList<RenderBox>( |
| find.descendant( |
| of: find.byType(CompositedTransformFollower), |
| matching: find.byType(Padding), |
| ), |
| ), |
| ); |
| // First handle should have the same dx but bigger dy. |
| expect(handles[0].localToGlobal(Offset.zero), const Offset(-35.0, 17.0)); |
| expect(handles[1].localToGlobal(Offset.zero), const Offset(197.0, 17.0)); |
| }); |
| |
| testWidgets('can update style of previous activated EditableText', (WidgetTester tester) async { |
| final Key key1 = UniqueKey(); |
| final Key key2 = UniqueKey(); |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: Column( |
| children: <Widget>[ |
| EditableText( |
| key: key1, |
| controller: TextEditingController(), |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: const TextStyle(fontSize: 9), |
| cursorColor: cursorColor, |
| ), |
| EditableText( |
| key: key2, |
| controller: TextEditingController(), |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: const TextStyle(fontSize: 9), |
| cursorColor: cursorColor, |
| ), |
| ], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byKey(key1)); |
| await tester.showKeyboard(find.byKey(key1)); |
| controller.text = 'test'; |
| await tester.idle(); |
| RenderBox renderEditable = tester.renderObject(find.byKey(key1)); |
| expect(renderEditable.size.height, 9.0); |
| // Taps the other EditableText to deactivate the first one. |
| await tester.tap(find.byKey(key2)); |
| await tester.showKeyboard(find.byKey(key2)); |
| // Updates the style. |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: Column( |
| children: <Widget>[ |
| EditableText( |
| key: key1, |
| controller: TextEditingController(), |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: const TextStyle(fontSize: 20), |
| cursorColor: cursorColor, |
| ), |
| EditableText( |
| key: key2, |
| controller: TextEditingController(), |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: const TextStyle(fontSize: 9), |
| cursorColor: cursorColor, |
| ), |
| ], |
| ), |
| ), |
| ), |
| ), |
| ); |
| renderEditable = tester.renderObject(find.byKey(key1)); |
| expect(renderEditable.size.height, 20.0); |
| expect(tester.takeException(), null); |
| }); |
| |
| testWidgets('Multiline keyboard with newline action is requested when maxLines = null', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| maxLines: null, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.multiline')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.newline')); |
| }); |
| |
| testWidgets('Text keyboard is requested when explicitly set and maxLines = null', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| maxLines: null, |
| keyboardType: TextInputType.text, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.text')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.done')); |
| }); |
| |
| testWidgets('Correct keyboard is requested when set explicitly and maxLines > 1', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| keyboardType: TextInputType.phone, |
| maxLines: 3, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.phone')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.done')); |
| }); |
| |
| testWidgets('multiline keyboard is requested when set implicitly', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| maxLines: 3, // Sets multiline keyboard implicitly. |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.multiline')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.newline')); |
| }); |
| |
| testWidgets('single line inputs have correct default keyboard', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect((tester.testTextInput.setClientArgs!['inputType'] as Map<String, dynamic>)['name'], equals('TextInputType.text')); |
| expect(tester.testTextInput.setClientArgs!['inputAction'], equals('TextInputAction.done')); |
| }); |
| |
| testWidgets('connection is closed when TextInputClient.onConnectionClosed message received', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test'; |
| await tester.idle(); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| expect(state.wantKeepAlive, true); |
| |
| tester.testTextInput.log.clear(); |
| tester.testTextInput.closeConnection(); |
| await tester.idle(); |
| |
| // Widget does not have focus anymore. |
| expect(state.wantKeepAlive, false); |
| // No method calls are sent from the framework. |
| // This makes sure hide/clearClient methods are not called after connection |
| // closed. |
| expect(tester.testTextInput.log, isEmpty); |
| }); |
| |
| testWidgets('closed connection reopened when user focused', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| controller.text = 'test3'; |
| await tester.idle(); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| expect(tester.testTextInput.editingState!['text'], equals('test3')); |
| expect(state.wantKeepAlive, true); |
| |
| tester.testTextInput.log.clear(); |
| tester.testTextInput.closeConnection(); |
| await tester.pumpAndSettle(); |
| |
| // Widget does not have focus anymore. |
| expect(state.wantKeepAlive, false); |
| // No method calls are sent from the framework. |
| // This makes sure hide/clearClient methods are not called after connection |
| // closed. |
| expect(tester.testTextInput.log, isEmpty); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.showKeyboard(find.byType(EditableText)); |
| await tester.pump(); |
| controller.text = 'test2'; |
| expect(tester.testTextInput.editingState!['text'], equals('test2')); |
| // Widget regained the focus. |
| expect(state.wantKeepAlive, true); |
| }); |
| |
| testWidgets('closed connection reopened when user focused on another field', (WidgetTester tester) async { |
| final EditableText testNameField = |
| EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| maxLines: null, |
| keyboardType: TextInputType.text, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ); |
| |
| final EditableText testPhoneField = |
| EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| keyboardType: TextInputType.phone, |
| maxLines: 3, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ); |
| |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: ListView( |
| children: <Widget>[ |
| testNameField, |
| testPhoneField, |
| ], |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| // Tap, enter text. |
| await tester.tap(find.byWidget(testNameField)); |
| await tester.showKeyboard(find.byWidget(testNameField)); |
| controller.text = 'test'; |
| await tester.idle(); |
| |
| expect(tester.testTextInput.editingState!['text'], equals('test')); |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byWidget(testNameField)); |
| expect(state.wantKeepAlive, true); |
| |
| tester.testTextInput.log.clear(); |
| tester.testTextInput.closeConnection(); |
| // A pump is needed to allow the focus change (unfocus) to be resolved. |
| await tester.pump(); |
| |
| // Widget does not have focus anymore. |
| expect(state.wantKeepAlive, false); |
| // No method calls are sent from the framework. |
| // This makes sure hide/clearClient methods are not called after connection |
| // closed. |
| expect(tester.testTextInput.log, isEmpty); |
| |
| // For the next fields, tap, enter text. |
| await tester.tap(find.byWidget(testPhoneField)); |
| await tester.showKeyboard(find.byWidget(testPhoneField)); |
| controller.text = '650123123'; |
| await tester.idle(); |
| expect(tester.testTextInput.editingState!['text'], equals('650123123')); |
| // Widget regained the focus. |
| expect(state.wantKeepAlive, true); |
| }); |
| |
| testWidgets( |
| 'kept-alive EditableText does not crash when layout is skipped', |
| (WidgetTester tester) async { |
| // Regression test for https://github.com/flutter/flutter/issues/84896. |
| EditableText.debugDeterministicCursor = true; |
| const Key key = ValueKey<String>('EditableText'); |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: ListView( |
| children: <Widget>[ |
| EditableText( |
| key: key, |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| autofocus: true, |
| maxLines: null, |
| keyboardType: TextInputType.text, |
| style: textStyle, |
| textAlign: TextAlign.left, |
| cursorColor: cursorColor, |
| showCursor: false, |
| ), |
| ], |
| ), |
| ), |
| ), |
| ); |
| |
| // Wait for autofocus. |
| await tester.pump(); |
| expect(focusNode.hasFocus, isTrue); |
| |
| // Prepend an additional item to make EditableText invisible. It's still |
| // kept in the tree via the keepalive mechanism. Change the text alignment |
| // and showCursor. The RenderEditable now needs to relayout and repaint. |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: ListView( |
| children: <Widget>[ |
| const SizedBox(height: 6000), |
| EditableText( |
| key: key, |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| autofocus: true, |
| maxLines: null, |
| keyboardType: TextInputType.text, |
| style: textStyle, |
| textAlign: TextAlign.right, |
| cursorColor: cursorColor, |
| showCursor: true, |
| ), |
| ], |
| ), |
| ), |
| ), |
| ); |
| |
| EditableText.debugDeterministicCursor = false; |
| expect(tester.takeException(), isNull); |
| }); |
| |
| /// Toolbar is not used in Flutter Web. Skip this check. |
| /// |
| /// Web is using native DOM elements (it is also used as platform input) |
| /// to enable clipboard functionality of the toolbar: copy, paste, select, |
| /// cut. It might also provide additional functionality depending on the |
| /// browser (such as translation). Due to this, in browsers, we should not |
| /// show a Flutter toolbar for the editable text elements. |
| testWidgets('can show toolbar when there is text and a selection', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Can't show the toolbar when there's no focus. |
| expect(state.showToolbar(), false); |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), findsNothing); |
| |
| // Can show the toolbar when focused even though there's no text. |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), kIsWeb ? findsNothing : findsOneWidget); |
| |
| // Hide the menu again. |
| state.hideToolbar(); |
| await tester.pump(); |
| expect(find.text('Paste'), findsNothing); |
| |
| // Can show the menu with text and a selection. |
| controller.text = 'blah'; |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), kIsWeb ? findsNothing : findsOneWidget); |
| }); |
| |
| testWidgets('Paste is shown only when there is something to paste', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Make sure the clipboard has a valid string on it. |
| await Clipboard.setData(const ClipboardData(text: 'Clipboard data')); |
| |
| // Show the toolbar. |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| |
| // The Paste button is shown (except on web, which doesn't show the Flutter |
| // toolbar). |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), kIsWeb ? findsNothing : findsOneWidget); |
| |
| // Hide the menu again. |
| state.hideToolbar(); |
| await tester.pump(); |
| expect(find.text('Paste'), findsNothing); |
| |
| // Clear the clipboard |
| await Clipboard.setData(const ClipboardData(text: '')); |
| |
| // Show the toolbar again. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pumpAndSettle(); |
| |
| // Paste is not shown. |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), findsNothing); |
| }); |
| |
| testWidgets('can show the toolbar after clearing all text', (WidgetTester tester) async { |
| // Regression test for https://github.com/flutter/flutter/issues/35998. |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Add text and an empty selection. |
| controller.text = 'blah'; |
| await tester.pump(); |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| |
| // Clear the text and selection. |
| expect(find.text('Paste'), findsNothing); |
| state.updateEditingValue(TextEditingValue.empty); |
| await tester.pump(); |
| |
| // Should be able to show the toolbar. |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pumpAndSettle(); |
| expect(find.text('Paste'), kIsWeb ? findsNothing : findsOneWidget); |
| }); |
| |
| testWidgets('can dynamically disable options in toolbar', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(text: 'blah blah'), |
| focusNode: focusNode, |
| toolbarOptions: const ToolbarOptions( |
| copy: true, |
| selectAll: true, |
| ), |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Select something. Doesn't really matter what. |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pump(); |
| expect(find.text('Select all'), kIsWeb ? findsNothing : findsOneWidget); |
| expect(find.text('Copy'), kIsWeb ? findsNothing : findsOneWidget); |
| expect(find.text('Paste'), findsNothing); |
| expect(find.text('Cut'), findsNothing); |
| }); |
| |
| testWidgets('can dynamically disable select all option in toolbar - cupertino', (WidgetTester tester) async { |
| // Regression test: https://github.com/flutter/flutter/issues/40711 |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(text: 'blah blah'), |
| focusNode: focusNode, |
| toolbarOptions: const ToolbarOptions(), |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: cupertinoTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| await tester.tap(find.byType(EditableText)); |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pump(); |
| expect(find.text('Select All'), findsNothing); |
| expect(find.text('Copy'), findsNothing); |
| expect(find.text('Paste'), findsNothing); |
| expect(find.text('Cut'), findsNothing); |
| }); |
| |
| testWidgets('can dynamically disable select all option in toolbar - material', (WidgetTester tester) async { |
| // Regression test: https://github.com/flutter/flutter/issues/40711 |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(text: 'blah blah'), |
| focusNode: focusNode, |
| toolbarOptions: const ToolbarOptions( |
| copy: true, |
| ), |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Select something. Doesn't really matter what. |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pump(); |
| expect(find.text('Select all'), findsNothing); |
| expect(find.text('Copy'), kIsWeb ? findsNothing : findsOneWidget); |
| expect(find.text('Paste'), findsNothing); |
| expect(find.text('Cut'), findsNothing); |
| }); |
| |
| testWidgets('cut and paste are disabled in read only mode even if explicit set', (WidgetTester tester) async { |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(text: 'blah blah'), |
| focusNode: focusNode, |
| readOnly: true, |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| ), |
| ), |
| ); |
| |
| final EditableTextState state = |
| tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| // Select something. Doesn't really matter what. |
| state.renderEditable.selectWordsInRange( |
| from: Offset.zero, |
| cause: SelectionChangedCause.tap, |
| ); |
| await tester.pump(); |
| // On web, we don't let Flutter show the toolbar. |
| expect(state.showToolbar(), kIsWeb ? isFalse : isTrue); |
| await tester.pump(); |
| expect(find.text('Select all'), kIsWeb ? findsNothing : findsOneWidget); |
| expect(find.text('Copy'), kIsWeb ? findsNothing : findsOneWidget); |
| expect(find.text('Paste'), findsNothing); |
| expect(find.text('Cut'), findsNothing); |
| }); |
| |
| testWidgets('Handles the read-only flag correctly', (WidgetTester tester) async { |
| final TextEditingController controller = |
| TextEditingController(text: 'Lorem ipsum dolor sit amet'); |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| readOnly: true, |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ); |
| |
| // Interact with the field to establish the input connection. |
| final Offset topLeft = tester.getTopLeft(find.byType(EditableText)); |
| await tester.tapAt(topLeft + const Offset(0.0, 5.0)); |
| await tester.pump(); |
| |
| controller.selection = const TextSelection(baseOffset: 0, extentOffset: 5); |
| await tester.pump(); |
| |
| if (kIsWeb) { |
| // On the web, a regular connection to the platform should've been made |
| // with the `readOnly` flag set to true. |
| expect(tester.testTextInput.hasAnyClients, isTrue); |
| expect(tester.testTextInput.setClientArgs!['readOnly'], isTrue); |
| expect( |
| tester.testTextInput.editingState!['text'], |
| 'Lorem ipsum dolor sit amet', |
| ); |
| expect(tester.testTextInput.editingState!['selectionBase'], 0); |
| expect(tester.testTextInput.editingState!['selectionExtent'], 5); |
| } else { |
| // On non-web platforms, a read-only field doesn't need a connection with |
| // the platform. |
| expect(tester.testTextInput.hasAnyClients, isFalse); |
| } |
| }); |
| |
| testWidgets('Does not accept updates when read-only', (WidgetTester tester) async { |
| final TextEditingController controller = |
| TextEditingController(text: 'Lorem ipsum dolor sit amet'); |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| readOnly: true, |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ); |
| |
| // Interact with the field to establish the input connection. |
| final Offset topLeft = tester.getTopLeft(find.byType(EditableText)); |
| await tester.tapAt(topLeft + const Offset(0.0, 5.0)); |
| await tester.pump(); |
| |
| expect(tester.testTextInput.hasAnyClients, kIsWeb ? isTrue : isFalse); |
| if (kIsWeb) { |
| // On the web, the input connection exists, but text updates should be |
| // ignored. |
| tester.testTextInput.updateEditingValue(const TextEditingValue( |
| text: 'Foo bar', |
| selection: TextSelection(baseOffset: 0, extentOffset: 3), |
| composing: TextRange(start: 3, end: 4), |
| )); |
| // Only selection should change. |
| expect( |
| controller.value, |
| const TextEditingValue( |
| text: 'Lorem ipsum dolor sit amet', |
| selection: TextSelection(baseOffset: 0, extentOffset: 3), |
| ), |
| ); |
| } |
| }); |
| |
| testWidgets('Read-only fields do not format text', (WidgetTester tester) async { |
| late SelectionChangedCause selectionCause; |
| |
| final TextEditingController controller = |
| TextEditingController(text: 'Lorem ipsum dolor sit amet'); |
| |
| await tester.pumpWidget( |
| MaterialApp( |
| home: EditableText( |
| readOnly: true, |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| selectionControls: materialTextSelectionControls, |
| onSelectionChanged: (TextSelection selection, SelectionChangedCause? cause) { |
| selectionCause = cause!; |
| }, |
| ), |
| ), |
| ); |
| |
| // Interact with the field to establish the input connection. |
| final Offset topLeft = tester.getTopLeft(find.byType(EditableText)); |
| await tester.tapAt(topLeft + const Offset(0.0, 5.0)); |
| await tester.pump(); |
| |
| expect(tester.testTextInput.hasAnyClients, kIsWeb ? isTrue : isFalse); |
| if (kIsWeb) { |
| tester.testTextInput.updateEditingValue(const TextEditingValue( |
| text: 'Foo bar', |
| selection: TextSelection(baseOffset: 0, extentOffset: 3), |
| )); |
| // On web, the only way a text field can be updated from the engine is if |
| // a keyboard is used. |
| expect(selectionCause, SelectionChangedCause.keyboard); |
| } |
| }); |
| |
| testWidgets('Sends "updateConfig" when read-only flag is flipped', (WidgetTester tester) async { |
| bool readOnly = true; |
| late StateSetter setState; |
| final TextEditingController controller = TextEditingController(text: 'Lorem ipsum dolor sit amet'); |
| |
| await tester.pumpWidget( |
| MaterialApp( |
| home: StatefulBuilder(builder: (BuildContext context, StateSetter stateSetter) { |
| setState = stateSetter; |
| return EditableText( |
| readOnly: readOnly, |
| controller: controller, |
| backgroundCursorColor: Colors.grey, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ); |
| }), |
| ), |
| ); |
| |
| // Interact with the field to establish the input connection. |
| final Offset topLeft = tester.getTopLeft(find.byType(EditableText)); |
| await tester.tapAt(topLeft + const Offset(0.0, 5.0)); |
| await tester.pump(); |
| |
| expect(tester.testTextInput.hasAnyClients, kIsWeb ? isTrue : isFalse); |
| if (kIsWeb) { |
| expect(tester.testTextInput.setClientArgs!['readOnly'], isTrue); |
| } |
| |
| setState(() { readOnly = false; }); |
| await tester.pump(); |
| |
| expect(tester.testTextInput.hasAnyClients, isTrue); |
| expect(tester.testTextInput.setClientArgs!['readOnly'], isFalse); |
| }); |
| |
| testWidgets('Fires onChanged when text changes via TextSelectionOverlay', (WidgetTester tester) async { |
| late String changedValue; |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: FocusNode(), |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| selectionControls: materialTextSelectionControls, |
| keyboardType: TextInputType.text, |
| onChanged: (String value) { |
| changedValue = value; |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Populate a fake clipboard. |
| const String clipboardContent = 'Dobunezumi mitai ni utsukushiku naritai'; |
| Clipboard.setData(const ClipboardData(text: clipboardContent)); |
| |
| // Long-press to bring up the text editing controls. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.longPress(textFinder); |
| tester.state<EditableTextState>(textFinder).showToolbar(); |
| await tester.pumpAndSettle(); |
| |
| await tester.tap(find.text('Paste')); |
| await tester.pump(); |
| |
| expect(changedValue, clipboardContent); |
| |
| // On web, we don't show the Flutter toolbar and instead rely on the browser |
| // toolbar. Until we change that, this test should remain skipped. |
| }, skip: kIsWeb); // [intended] |
| |
| // The variants to test in the focus handling test. |
| final ValueVariant<TextInputAction> focusVariants = ValueVariant< |
| TextInputAction>( |
| TextInputAction.values.toSet(), |
| ); |
| |
| testWidgets('Handles focus correctly when action is invoked', (WidgetTester tester) async { |
| // The expectations for each of the types of TextInputAction. |
| const Map<TextInputAction, bool> actionShouldLoseFocus = <TextInputAction, bool>{ |
| TextInputAction.none: false, |
| TextInputAction.unspecified: false, |
| TextInputAction.done: true, |
| TextInputAction.go: true, |
| TextInputAction.search: true, |
| TextInputAction.send: true, |
| TextInputAction.continueAction: false, |
| TextInputAction.join: false, |
| TextInputAction.route: false, |
| TextInputAction.emergencyCall: false, |
| TextInputAction.newline: true, |
| TextInputAction.next: true, |
| TextInputAction.previous: true, |
| }; |
| |
| final TextInputAction action = focusVariants.currentValue!; |
| expect(actionShouldLoseFocus.containsKey(action), isTrue); |
| |
| Future<void> _ensureCorrectFocusHandlingForAction( |
| TextInputAction action, { |
| required bool shouldLoseFocus, |
| bool shouldFocusNext = false, |
| bool shouldFocusPrevious = false, |
| }) async { |
| final FocusNode focusNode = FocusNode(); |
| final GlobalKey previousKey = GlobalKey(); |
| final GlobalKey nextKey = GlobalKey(); |
| |
| final Widget widget = MaterialApp( |
| home: Column( |
| children: <Widget>[ |
| TextButton( |
| child: Text('Previous Widget', key: previousKey), |
| onPressed: () {}, |
| ), |
| EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| selectionControls: materialTextSelectionControls, |
| keyboardType: TextInputType.text, |
| autofocus: true, |
| ), |
| TextButton( |
| child: Text('Next Widget', key: nextKey), |
| onPressed: () {}, |
| ), |
| ], |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| assert(focusNode.hasFocus); |
| |
| await tester.testTextInput.receiveAction(action); |
| await tester.pump(); |
| |
| expect(Focus.of(nextKey.currentContext!).hasFocus, equals(shouldFocusNext)); |
| expect(Focus.of(previousKey.currentContext!).hasFocus, equals(shouldFocusPrevious)); |
| expect(focusNode.hasFocus, equals(!shouldLoseFocus)); |
| } |
| |
| try { |
| await _ensureCorrectFocusHandlingForAction( |
| action, |
| shouldLoseFocus: actionShouldLoseFocus[action]!, |
| shouldFocusNext: action == TextInputAction.next, |
| shouldFocusPrevious: action == TextInputAction.previous, |
| ); |
| } on PlatformException { |
| // on Android, continueAction isn't supported. |
| expect(action, equals(TextInputAction.continueAction)); |
| } |
| }, variant: focusVariants); |
| |
| testWidgets('Does not lose focus by default when "done" action is pressed and onEditingComplete is provided', (WidgetTester tester) async { |
| final FocusNode focusNode = FocusNode(); |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| selectionControls: materialTextSelectionControls, |
| keyboardType: TextInputType.text, |
| onEditingComplete: () { |
| // This prevents the default focus change behavior on submission. |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Select EditableText to give it focus. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.tap(textFinder); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| |
| await tester.testTextInput.receiveAction(TextInputAction.done); |
| await tester.pump(); |
| |
| // Still has focus even though "done" was pressed because onEditingComplete |
| // was provided and it overrides the default behavior. |
| expect(focusNode.hasFocus, true); |
| }); |
| |
| testWidgets('When "done" is pressed callbacks are invoked: onEditingComplete > onSubmitted', (WidgetTester tester) async { |
| final FocusNode focusNode = FocusNode(); |
| |
| bool onEditingCompleteCalled = false; |
| bool onSubmittedCalled = false; |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| onEditingComplete: () { |
| onEditingCompleteCalled = true; |
| expect(onSubmittedCalled, false); |
| }, |
| onSubmitted: (String value) { |
| onSubmittedCalled = true; |
| expect(onEditingCompleteCalled, true); |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Select EditableText to give it focus. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.tap(textFinder); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| |
| // The execution path starting with receiveAction() will trigger the |
| // onEditingComplete and onSubmission callbacks. |
| await tester.testTextInput.receiveAction(TextInputAction.done); |
| |
| // The expectations we care about are up above in the onEditingComplete |
| // and onSubmission callbacks. |
| }); |
| |
| testWidgets('When "next" is pressed callbacks are invoked: onEditingComplete > onSubmitted', (WidgetTester tester) async { |
| final FocusNode focusNode = FocusNode(); |
| |
| bool onEditingCompleteCalled = false; |
| bool onSubmittedCalled = false; |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| onEditingComplete: () { |
| onEditingCompleteCalled = true; |
| assert(!onSubmittedCalled); |
| }, |
| onSubmitted: (String value) { |
| onSubmittedCalled = true; |
| assert(onEditingCompleteCalled); |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Select EditableText to give it focus. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.tap(textFinder); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| |
| // The execution path starting with receiveAction() will trigger the |
| // onEditingComplete and onSubmission callbacks. |
| await tester.testTextInput.receiveAction(TextInputAction.done); |
| |
| // The expectations we care about are up above in the onEditingComplete |
| // and onSubmission callbacks. |
| }); |
| |
| testWidgets('When "newline" action is called on a Editable text with maxLines == 1 callbacks are invoked: onEditingComplete > onSubmitted', (WidgetTester tester) async { |
| final FocusNode focusNode = FocusNode(); |
| |
| bool onEditingCompleteCalled = false; |
| bool onSubmittedCalled = false; |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| onEditingComplete: () { |
| onEditingCompleteCalled = true; |
| assert(!onSubmittedCalled); |
| }, |
| onSubmitted: (String value) { |
| onSubmittedCalled = true; |
| assert(onEditingCompleteCalled); |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Select EditableText to give it focus. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.tap(textFinder); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| |
| // The execution path starting with receiveAction() will trigger the |
| // onEditingComplete and onSubmission callbacks. |
| await tester.testTextInput.receiveAction(TextInputAction.newline); |
| // The expectations we care about are up above in the onEditingComplete |
| // and onSubmission callbacks. |
| }); |
| |
| testWidgets('When "newline" action is called on a Editable text with maxLines != 1, onEditingComplete and onSubmitted callbacks are not invoked.', (WidgetTester tester) async { |
| final FocusNode focusNode = FocusNode(); |
| |
| bool onEditingCompleteCalled = false; |
| bool onSubmittedCalled = false; |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: TextEditingController(), |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| maxLines: 3, |
| onEditingComplete: () { |
| onEditingCompleteCalled = true; |
| }, |
| onSubmitted: (String value) { |
| onSubmittedCalled = true; |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| // Select EditableText to give it focus. |
| final Finder textFinder = find.byType(EditableText); |
| await tester.tap(textFinder); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| |
| // The execution path starting with receiveAction() will trigger the |
| // onEditingComplete and onSubmission callbacks. |
| await tester.testTextInput.receiveAction(TextInputAction.newline); |
| |
| // These callbacks shouldn't have been triggered. |
| assert(!onSubmittedCalled); |
| assert(!onEditingCompleteCalled); |
| }); |
| |
| testWidgets( |
| 'finalizeEditing should reset the input connection when shouldUnfocus is true but the unfocus is cancelled', |
| (WidgetTester tester) async { |
| // Regression test for https://github.com/flutter/flutter/issues/84240 . |
| Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| focusNode: focusNode, |
| controller: controller, |
| onSubmitted: (String value) {}, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| focusNode.requestFocus(); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| tester.testTextInput.log.clear(); |
| |
| // This should unfocus the field. Don't restart the input. |
| await tester.testTextInput.receiveAction(TextInputAction.done); |
| expect(tester.testTextInput.log, isNot(containsAllInOrder(<Matcher>[ |
| matchesMethodCall('TextInput.clearClient'), |
| matchesMethodCall('TextInput.setClient'), |
| ]))); |
| |
| widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| focusNode: focusNode, |
| controller: controller, |
| onSubmitted: (String value) { |
| focusNode.requestFocus(); |
| }, |
| ), |
| ); |
| await tester.pumpWidget(widget); |
| |
| focusNode.requestFocus(); |
| await tester.pump(); |
| |
| assert(focusNode.hasFocus); |
| tester.testTextInput.log.clear(); |
| |
| // This will attempt to unfocus the field but the onSubmitted callback |
| // will cancel that. Restart the input connection in this case. |
| await tester.testTextInput.receiveAction(TextInputAction.done); |
| expect(tester.testTextInput.log, containsAllInOrder(<Matcher>[ |
| matchesMethodCall('TextInput.clearClient'), |
| matchesMethodCall('TextInput.setClient'), |
| ])); |
| |
| tester.testTextInput.log.clear(); |
| // TextInputAction.unspecified does not unfocus the input field by default. |
| await tester.testTextInput.receiveAction(TextInputAction.unspecified); |
| expect(tester.testTextInput.log, isNot(containsAllInOrder(<Matcher>[ |
| matchesMethodCall('TextInput.clearClient'), |
| matchesMethodCall('TextInput.setClient'), |
| ]))); |
| }); |
| |
| testWidgets( |
| 'iOS autocorrection rectangle should appear on demand and dismiss when the text changes or when focus is lost', |
| (WidgetTester tester) async { |
| const Color rectColor = Color(0xFFFF0000); |
| |
| void verifyAutocorrectionRectVisibility({ required bool expectVisible }) { |
| PaintPattern evaluate() { |
| if (expectVisible) { |
| return paints..something(((Symbol method, List<dynamic> arguments) { |
| if (method != #drawRect) |
| return false; |
| final Paint paint = arguments[1] as Paint; |
| return paint.color == rectColor; |
| })); |
| } else { |
| return paints..everything(((Symbol method, List<dynamic> arguments) { |
| if (method != #drawRect) |
| return true; |
| final Paint paint = arguments[1] as Paint; |
| if (paint.color != rectColor) |
| return true; |
| throw 'Expected: autocorrection rect not visible, found: ${arguments[0]}'; |
| })); |
| } |
| } |
| |
| expect(findRenderEditable(tester), evaluate()); |
| } |
| |
| final FocusNode focusNode = FocusNode(); |
| final TextEditingController controller = TextEditingController(text: 'ABCDEFG'); |
| |
| final Widget widget = MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: Typography.material2018().black.subtitle1!, |
| cursorColor: Colors.blue, |
| autocorrectionTextRectColor: rectColor, |
| showCursor: false, |
| onEditingComplete: () { }, |
| ), |
| ); |
| |
| await tester.pumpWidget(widget); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.pump(); |
| final EditableTextState state = tester.state<EditableTextState>(find.byType(EditableText)); |
| |
| assert(focusNode.hasFocus); |
| |
| // The prompt rect should be invisible initially. |
| verifyAutocorrectionRectVisibility(expectVisible: false); |
| |
| state.showAutocorrectionPromptRect(0, 1); |
| await tester.pump(); |
| |
| // Show prompt rect when told to. |
| verifyAutocorrectionRectVisibility(expectVisible: true); |
| |
| // Text changed, prompt rect goes away. |
| controller.text = '12345'; |
| await tester.pump(); |
| verifyAutocorrectionRectVisibility(expectVisible: false); |
| |
| state.showAutocorrectionPromptRect(0, 1); |
| await tester.pump(); |
| |
| verifyAutocorrectionRectVisibility(expectVisible: true); |
| |
| // Unfocus, prompt rect should go away. |
| focusNode.unfocus(); |
| await tester.pump(); |
| verifyAutocorrectionRectVisibility(expectVisible: false); |
| }, |
| ); |
| |
| testWidgets('Changing controller updates EditableText', (WidgetTester tester) async { |
| final TextEditingController controller1 = |
| TextEditingController(text: 'Wibble'); |
| final TextEditingController controller2 = |
| TextEditingController(text: 'Wobble'); |
| TextEditingController currentController = controller1; |
| late StateSetter setState; |
| |
| final FocusNode focusNode = FocusNode(debugLabel: 'EditableText Focus Node'); |
| Widget builder() { |
| return StatefulBuilder( |
| builder: (BuildContext context, StateSetter setter) { |
| setState = setter; |
| return MaterialApp( |
| home: MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: Center( |
| child: Material( |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: currentController, |
| focusNode: focusNode, |
| style: Typography.material2018() |
| .black |
| .subtitle1!, |
| cursorColor: Colors.blue, |
| selectionControls: materialTextSelectionControls, |
| keyboardType: TextInputType.text, |
| onChanged: (String value) { }, |
| ), |
| ), |
| ), |
| ), |
| ), |
| ); |
| }, |
| ); |
| } |
| |
| await tester.pumpWidget(builder()); |
| await tester.pump(); // An extra pump to allow focus request to go through. |
| |
| final List<MethodCall> log = <MethodCall>[]; |
| tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(SystemChannels.textInput, (MethodCall methodCall) async { |
| log.add(methodCall); |
| }); |
| |
| await tester.showKeyboard(find.byType(EditableText)); |
| |
| // Verify TextInput.setEditingState and TextInput.setEditableSizeAndTransform are |
| // both fired with updated text when controller is replaced. |
| setState(() { |
| currentController = controller2; |
| }); |
| await tester.pump(); |
| |
| expect( |
| log.lastWhere((MethodCall m) => m.method == 'TextInput.setEditingState'), |
| isMethodCall( |
| 'TextInput.setEditingState', |
| arguments: const <String, dynamic>{ |
| 'text': 'Wobble', |
| 'selectionBase': -1, |
| 'selectionExtent': -1, |
| 'selectionAffinity': 'TextAffinity.downstream', |
| 'selectionIsDirectional': false, |
| 'composingBase': -1, |
| 'composingExtent': -1, |
| }, |
| ), |
| ); |
| expect( |
| log.lastWhere((MethodCall m) => m.method == 'TextInput.setEditableSizeAndTransform'), |
| isMethodCall( |
| 'TextInput.setEditableSizeAndTransform', |
| arguments: <String, dynamic>{ |
| 'width': 800, |
| 'height': 14, |
| 'transform': Matrix4.translationValues(0.0, 293.0, 0.0).storage.toList(), |
| }, |
| ), |
| ); |
| }); |
| |
| testWidgets('EditableText identifies as text field (w/ focus) in semantics', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| expect(semantics, includesNodeWith(flags: <SemanticsFlag>[SemanticsFlag.isTextField])); |
| |
| await tester.tap(find.byType(EditableText)); |
| await tester.idle(); |
| await tester.pump(); |
| |
| expect( |
| semantics, |
| includesNodeWith(flags: <SemanticsFlag>[ |
| SemanticsFlag.isTextField, |
| SemanticsFlag.isFocused, |
| ]), |
| ); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('EditableText sets multi-line flag in semantics', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| expect( |
| semantics, |
| includesNodeWith(flags: <SemanticsFlag>[SemanticsFlag.isTextField]), |
| ); |
| |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| autofocus: true, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| maxLines: 3, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| expect( |
| semantics, |
| includesNodeWith(flags: <SemanticsFlag>[ |
| SemanticsFlag.isTextField, |
| SemanticsFlag.isMultiline, |
| ]), |
| ); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('EditableText includes text as value in semantics', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| const String value1 = 'EditableText content'; |
| |
| controller.text = value1; |
| |
| await tester.pumpWidget( |
| MediaQuery( |
| data: const MediaQueryData(), |
| child: Directionality( |
| textDirection: TextDirection.ltr, |
| child: FocusScope( |
| node: focusScopeNode, |
| child: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| ), |
| ), |
| ), |
| ); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| flags: <SemanticsFlag>[SemanticsFlag.isTextField], |
| value: value1, |
| ), |
| ); |
| |
| const String value2 = 'Changed the EditableText content'; |
| controller.text = value2; |
| await tester.idle(); |
| await tester.pump(); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| flags: <SemanticsFlag>[SemanticsFlag.isTextField], |
| value: value2, |
| ), |
| ); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('exposes correct cursor movement semantics', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| controller.text = 'test'; |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| focusNode.requestFocus(); |
| await tester.pump(); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| ), |
| ); |
| |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length); |
| await tester.pumpAndSettle(); |
| |
| // At end, can only go backwards. |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length - 2); |
| await tester.pumpAndSettle(); |
| |
| // Somewhere in the middle, can go in both directions. |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| controller.selection = const TextSelection.collapsed(offset: 0); |
| await tester.pumpAndSettle(); |
| |
| // At beginning, can only go forward. |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('can move cursor with a11y means - character', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| const bool doNotExtendSelection = false; |
| |
| controller.text = 'test'; |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length); |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| ], |
| ), |
| ); |
| |
| final RenderEditable render = tester.allRenderObjects.whereType<RenderEditable>().first; |
| final int semanticsId = render.debugSemantics!.id; |
| |
| expect(controller.selection.baseOffset, 4); |
| expect(controller.selection.extentOffset, 4); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 3); |
| expect(controller.selection.extentOffset, 3); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 0); |
| expect(controller.selection.extentOffset, 0); |
| |
| await tester.pumpAndSettle(); |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 1); |
| expect(controller.selection.extentOffset, 1); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('can move cursor with a11y means - word', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| const bool doNotExtendSelection = false; |
| |
| controller.text = 'test for words'; |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length); |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| ], |
| ), |
| ); |
| |
| final RenderEditable render = tester.allRenderObjects.whereType<RenderEditable>().first; |
| final int semanticsId = render.debugSemantics!.id; |
| |
| expect(controller.selection.baseOffset, 14); |
| expect(controller.selection.extentOffset, 14); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 9); |
| expect(controller.selection.extentOffset, 9); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 5); |
| expect(controller.selection.extentOffset, 5); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 0); |
| expect(controller.selection.extentOffset, 0); |
| |
| await tester.pumpAndSettle(); |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 5); |
| expect(controller.selection.extentOffset, 5); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 9); |
| expect(controller.selection.extentOffset, 9); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('can extend selection with a11y means - character', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| const bool extendSelection = true; |
| const bool doNotExtendSelection = false; |
| |
| controller.text = 'test'; |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length); |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| ], |
| ), |
| ); |
| |
| final RenderEditable render = tester.allRenderObjects.whereType<RenderEditable>().first; |
| final int semanticsId = render.debugSemantics!.id; |
| |
| expect(controller.selection.baseOffset, 4); |
| expect(controller.selection.extentOffset, 4); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 4); |
| expect(controller.selection.extentOffset, 3); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByCharacter, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 4); |
| expect(controller.selection.extentOffset, 0); |
| |
| await tester.pumpAndSettle(); |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByCharacter, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 1); |
| expect(controller.selection.extentOffset, 1); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByCharacter, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 1); |
| expect(controller.selection.extentOffset, 2); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('can extend selection with a11y means - word', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| const bool extendSelection = true; |
| const bool doNotExtendSelection = false; |
| |
| controller.text = 'test for words'; |
| controller.selection = |
| TextSelection.collapsed(offset:controller.text.length); |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| ], |
| ), |
| ); |
| |
| final RenderEditable render = tester.allRenderObjects.whereType<RenderEditable>().first; |
| final int semanticsId = render.debugSemantics!.id; |
| |
| expect(controller.selection.baseOffset, 14); |
| expect(controller.selection.extentOffset, 14); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 14); |
| expect(controller.selection.extentOffset, 9); |
| |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorBackwardByWord, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 14); |
| expect(controller.selection.extentOffset, 5); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorBackwardByWord, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 14); |
| expect(controller.selection.extentOffset, 0); |
| |
| await tester.pumpAndSettle(); |
| expect( |
| semantics, |
| includesNodeWith( |
| value: 'test for words', |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorForwardByCharacter, |
| SemanticsAction.moveCursorForwardByWord, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| ], |
| ), |
| ); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByWord, |
| doNotExtendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 5); |
| expect(controller.selection.extentOffset, 5); |
| |
| tester.binding.pipelineOwner.semanticsOwner!.performAction( |
| semanticsId, |
| SemanticsAction.moveCursorForwardByWord, |
| extendSelection, |
| ); |
| await tester.pumpAndSettle(); |
| |
| expect(controller.selection.baseOffset, 5); |
| expect(controller.selection.extentOffset, 9); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('password fields have correct semantics', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| controller.text = 'super-secret-password!!1'; |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| obscureText: true, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| final String expectedValue = '•' *controller.text.length; |
| |
| expect( |
| semantics, |
| hasSemantics( |
| TestSemantics( |
| children: <TestSemantics>[ |
| TestSemantics.rootChild( |
| children: <TestSemantics>[ |
| TestSemantics( |
| children: <TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[SemanticsFlag.scopesRoute], |
| children: <TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[ |
| SemanticsFlag.isTextField, |
| SemanticsFlag.isObscured, |
| ], |
| value: expectedValue, |
| textDirection: TextDirection.ltr, |
| ), |
| ], |
| ), |
| ], |
| ), |
| ], |
| ), |
| ], |
| ), |
| ignoreTransform: true, |
| ignoreRect: true, |
| ignoreId: true, |
| ), |
| ); |
| |
| semantics.dispose(); |
| }); |
| |
| testWidgets('password fields become obscured with the right semantics when set', (WidgetTester tester) async { |
| final SemanticsTester semantics = SemanticsTester(tester); |
| |
| const String originalText = 'super-secret-password!!1'; |
| controller.text = originalText; |
| |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| final String expectedValue = '•' * originalText.length; |
| |
| expect( |
| semantics, |
| hasSemantics( |
| TestSemantics( |
| children: <TestSemantics>[ |
| TestSemantics.rootChild( |
| children: <TestSemantics>[ |
| TestSemantics( |
| children:<TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[SemanticsFlag.scopesRoute], |
| children: <TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[ |
| SemanticsFlag.isTextField, |
| ], |
| value: originalText, |
| textDirection: TextDirection.ltr, |
| ), |
| ], |
| ), |
| ], |
| ), |
| ], |
| ), |
| ], |
| ), |
| ignoreTransform: true, |
| ignoreRect: true, |
| ignoreId: true, |
| ), |
| ); |
| |
| focusNode.requestFocus(); |
| |
| // Now change it to make it obscure text. |
| await tester.pumpWidget(MaterialApp( |
| home: EditableText( |
| backgroundCursorColor: Colors.grey, |
| controller: controller, |
| obscureText: true, |
| focusNode: focusNode, |
| style: textStyle, |
| cursorColor: cursorColor, |
| ), |
| )); |
| |
| expect((findRenderEditable(tester).text! as TextSpan).text, expectedValue); |
| |
| expect( |
| semantics, |
| hasSemantics( |
| TestSemantics( |
| children: <TestSemantics>[ |
| TestSemantics.rootChild( |
| children: <TestSemantics>[ |
| TestSemantics( |
| children:<TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[SemanticsFlag.scopesRoute], |
| children: <TestSemantics>[ |
| TestSemantics( |
| flags: <SemanticsFlag>[ |
| SemanticsFlag.isTextField, |
| SemanticsFlag.isObscured, |
| SemanticsFlag.isFocused, |
| ], |
| actions: <SemanticsAction>[ |
| SemanticsAction.moveCursorBackwardByCharacter, |
| SemanticsAction.setSelection, |
| SemanticsAction.setText, |
| SemanticsAction.moveCursorBackwardByWord, |
| ], |
| value: expectedValue, |
| textDirection: TextDirection.ltr, |
| textSelection: const TextSelection.collapsed(offset: 24), |
| ), |
| ], |
|
|
