| // 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 'dart:ui'; |
| |
| import 'package:flutter/rendering.dart'; |
| import 'package:flutter_test/flutter_test.dart'; |
| import 'package:leak_tracker_flutter_testing/leak_tracker_flutter_testing.dart'; |
| import 'package:vector_math/vector_math_64.dart'; |
| |
| import '../rendering/rendering_tester.dart'; |
| |
| const int kMaxFrameworkAccessibilityIdentifier = (1 << 16) - 1; |
| |
| void main() { |
| TestRenderingFlutterBinding.ensureInitialized(); |
| |
| setUp(() { |
| debugResetSemanticsIdCounter(); |
| }); |
| |
| group('SemanticsNode', () { |
| const tag1 = SemanticsTag('Tag One'); |
| const tag2 = SemanticsTag('Tag Two'); |
| const tag3 = SemanticsTag('Tag Three'); |
| |
| test('tagging', () { |
| final node = SemanticsNode(); |
| |
| expect(node.isTagged(tag1), isFalse); |
| expect(node.isTagged(tag2), isFalse); |
| |
| node.tags = <SemanticsTag>{tag1}; |
| expect(node.isTagged(tag1), isTrue); |
| expect(node.isTagged(tag2), isFalse); |
| |
| node.tags!.add(tag2); |
| expect(node.isTagged(tag1), isTrue); |
| expect(node.isTagged(tag2), isTrue); |
| }); |
| |
| test('getSemanticsData includes tags', () { |
| final tags = <SemanticsTag>{tag1, tag2}; |
| |
| final node = SemanticsNode() |
| ..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 10.0) |
| ..tags = tags; |
| |
| expect(node.getSemanticsData().tags, tags); |
| |
| tags.add(tag3); |
| |
| final config = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true; |
| |
| node.updateWith( |
| config: config, |
| childrenInInversePaintOrder: <SemanticsNode>[ |
| SemanticsNode() |
| ..rect = const Rect.fromLTRB(5.0, 5.0, 10.0, 10.0) |
| ..tags = tags, |
| ], |
| ); |
| |
| expect(node.getSemanticsData().tags, tags); |
| }); |
| |
| test('SemanticsConfiguration can set both string label/value/hint and attributed version', () { |
| final config = SemanticsConfiguration(); |
| config.label = 'label1'; |
| expect(config.label, 'label1'); |
| expect(config.attributedLabel.string, 'label1'); |
| expect(config.attributedLabel.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#1(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label1")', |
| ); |
| |
| config.attributedLabel = AttributedString( |
| 'label2', |
| attributes: <StringAttribute>[ |
| SpellOutStringAttribute(range: const TextRange(start: 0, end: 1)), |
| ], |
| ); |
| expect(config.label, 'label2'); |
| expect(config.attributedLabel.string, 'label2'); |
| expect(config.attributedLabel.attributes.length, 1); |
| expect(config.attributedLabel.attributes[0] is SpellOutStringAttribute, isTrue); |
| expect(config.attributedLabel.attributes[0].range, const TextRange(start: 0, end: 1)); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#2(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label2" [SpellOutStringAttribute(TextRange(start: 0, end: 1))])', |
| ); |
| |
| config.label = 'label3'; |
| expect(config.label, 'label3'); |
| expect(config.attributedLabel.string, 'label3'); |
| expect(config.attributedLabel.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#3(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3")', |
| ); |
| |
| config.value = 'value1'; |
| expect(config.value, 'value1'); |
| expect(config.attributedValue.string, 'value1'); |
| expect(config.attributedValue.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#4(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value1")', |
| ); |
| |
| config.attributedValue = AttributedString( |
| 'value2', |
| attributes: <StringAttribute>[ |
| SpellOutStringAttribute(range: const TextRange(start: 0, end: 1)), |
| ], |
| ); |
| expect(config.value, 'value2'); |
| expect(config.attributedValue.string, 'value2'); |
| expect(config.attributedValue.attributes.length, 1); |
| expect(config.attributedValue.attributes[0] is SpellOutStringAttribute, isTrue); |
| expect(config.attributedValue.attributes[0].range, const TextRange(start: 0, end: 1)); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#5(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value2" [SpellOutStringAttribute(TextRange(start: 0, end: 1))])', |
| ); |
| |
| config.value = 'value3'; |
| expect(config.value, 'value3'); |
| expect(config.attributedValue.string, 'value3'); |
| expect(config.attributedValue.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#6(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value3")', |
| ); |
| |
| config.hint = 'hint1'; |
| expect(config.hint, 'hint1'); |
| expect(config.attributedHint.string, 'hint1'); |
| expect(config.attributedHint.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#7(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value3", hint: "hint1")', |
| ); |
| |
| config.attributedHint = AttributedString( |
| 'hint2', |
| attributes: <StringAttribute>[ |
| SpellOutStringAttribute(range: const TextRange(start: 0, end: 1)), |
| ], |
| ); |
| expect(config.hint, 'hint2'); |
| expect(config.attributedHint.string, 'hint2'); |
| expect(config.attributedHint.attributes.length, 1); |
| expect(config.attributedHint.attributes[0] is SpellOutStringAttribute, isTrue); |
| expect(config.attributedHint.attributes[0].range, const TextRange(start: 0, end: 1)); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#8(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value3", hint: "hint2" [SpellOutStringAttribute(TextRange(start: 0, end: 1))])', |
| ); |
| |
| config.hint = 'hint3'; |
| expect(config.hint, 'hint3'); |
| expect(config.attributedHint.string, 'hint3'); |
| expect(config.attributedHint.attributes.isEmpty, isTrue); |
| expect( |
| (SemanticsNode()..updateWith(config: config)).toString(), |
| 'SemanticsNode#9(STALE, owner: null, Rect.fromLTRB(0.0, 0.0, 0.0, 0.0), invisible, label: "label3", value: "value3", hint: "hint3")', |
| ); |
| }); |
| |
| test('provides the correct isMergedIntoParent value', () { |
| final root = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 10.0); |
| final node1 = SemanticsNode()..rect = const Rect.fromLTRB(1.0, 0.0, 10.0, 10.0); |
| final node11 = SemanticsNode()..rect = const Rect.fromLTRB(2.0, 0.0, 10.0, 10.0); |
| final node12 = SemanticsNode()..rect = const Rect.fromLTRB(3.0, 0.0, 10.0, 10.0); |
| |
| final noMergeConfig = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = false; |
| |
| final mergeConfig = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true; |
| |
| node1.updateWith( |
| config: noMergeConfig, |
| childrenInInversePaintOrder: <SemanticsNode>[node11, node12], |
| ); |
| |
| expect(node1.isMergedIntoParent, false); |
| expect(node1.mergeAllDescendantsIntoThisNode, false); |
| expect(node11.isMergedIntoParent, false); |
| expect(node12.isMergedIntoParent, false); |
| expect(root.isMergedIntoParent, false); |
| |
| root.updateWith(config: mergeConfig, childrenInInversePaintOrder: <SemanticsNode>[node1]); |
| expect(node1.isMergedIntoParent, true); |
| expect(node1.mergeAllDescendantsIntoThisNode, false); |
| expect(node11.isMergedIntoParent, true); |
| expect(node12.isMergedIntoParent, true); |
| expect(root.isMergedIntoParent, false); |
| expect(root.mergeAllDescendantsIntoThisNode, true); |
| |
| // Change config |
| node1.updateWith( |
| config: mergeConfig, |
| childrenInInversePaintOrder: <SemanticsNode>[node11, node12], |
| ); |
| expect(node1.isMergedIntoParent, true); |
| expect(node1.mergeAllDescendantsIntoThisNode, true); |
| expect(node11.isMergedIntoParent, true); |
| expect(node12.isMergedIntoParent, true); |
| expect(root.isMergedIntoParent, false); |
| expect(root.mergeAllDescendantsIntoThisNode, true); |
| |
| root.updateWith(config: noMergeConfig, childrenInInversePaintOrder: <SemanticsNode>[node1]); |
| expect(node1.isMergedIntoParent, false); |
| expect(node1.mergeAllDescendantsIntoThisNode, true); |
| expect(node11.isMergedIntoParent, true); |
| expect(node12.isMergedIntoParent, true); |
| expect(root.isMergedIntoParent, false); |
| expect(root.mergeAllDescendantsIntoThisNode, false); |
| }); |
| |
| test('sendSemanticsUpdate verifies no invisible nodes', () { |
| const invisibleRect = Rect.fromLTRB(0.0, 0.0, 0.0, 10.0); |
| const visibleRect = Rect.fromLTRB(0.0, 0.0, 10.0, 10.0); |
| |
| final owner = SemanticsOwner(onSemanticsUpdate: (SemanticsUpdate update) {}); |
| final root = SemanticsNode.root(owner: owner)..rect = invisibleRect; |
| final child = SemanticsNode(); |
| |
| // It's ok to have an invisible root. |
| expect(owner.sendSemanticsUpdate, returnsNormally); |
| |
| // It's ok to have an invisible child if it's merged to an ancestor. |
| root |
| ..rect = visibleRect |
| ..updateWith( |
| config: SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true, |
| childrenInInversePaintOrder: <SemanticsNode>[child..rect = invisibleRect], |
| ); |
| expect(owner.sendSemanticsUpdate, returnsNormally); |
| |
| // It's ok if all nodes are visible. |
| root |
| ..rect = visibleRect |
| ..updateWith( |
| config: SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = false, |
| childrenInInversePaintOrder: <SemanticsNode>[child..rect = visibleRect], |
| ); |
| expect(owner.sendSemanticsUpdate, returnsNormally); |
| |
| // Invisible root with children bad. |
| root |
| ..rect = invisibleRect |
| ..updateWith( |
| config: SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true, |
| childrenInInversePaintOrder: <SemanticsNode>[child..rect = invisibleRect], |
| ); |
| expect( |
| owner.sendSemanticsUpdate, |
| throwsA( |
| isA<FlutterError>().having( |
| (FlutterError error) => error.message, |
| 'message', |
| equals( |
| 'Invisible SemanticsNodes should not be added to the tree.\n' |
| 'The following invisible SemanticsNodes were added to the tree:\n' |
| 'SemanticsNode#0(dirty, merge boundary ⛔️, Rect.fromLTRB(0.0, 0.0, 0.0, 10.0), invisible)\n' |
| 'which was added as the root SemanticsNode\n' |
| 'An invisible SemanticsNode is one whose rect is not on screen hence not reachable for users, and its semantic information is not merged into a visible parent.\n' |
| 'An invisible SemanticsNode makes the accessibility experience confusing, as it does not provide any visual indication when the user selects it via accessibility technologies.\n' |
| 'Consider removing the above invisible SemanticsNodes if they were added by your RenderObject.assembleSemanticsNode implementation, or filing a bug on GitHub:\n' |
| ' https://github.com/flutter/flutter/issues/new?template=02_bug.yml', |
| ), |
| ), |
| ), |
| ); |
| |
| // Invisible children bad. |
| root |
| ..rect = visibleRect |
| ..updateWith( |
| config: SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = false, |
| childrenInInversePaintOrder: <SemanticsNode>[child..rect = invisibleRect], |
| ); |
| expect( |
| owner.sendSemanticsUpdate, |
| throwsA( |
| isA<FlutterError>().having( |
| (FlutterError error) => error.message, |
| 'message', |
| equals( |
| 'Invisible SemanticsNodes should not be added to the tree.\n' |
| 'The following invisible SemanticsNodes were added to the tree:\n' |
| 'SemanticsNode#1(dirty, Rect.fromLTRB(0.0, 0.0, 0.0, 10.0), invisible)\n' |
| 'which was added as a child of:\n' |
| ' SemanticsNode#0(dirty, Rect.fromLTRB(0.0, 0.0, 10.0, 10.0))\n' |
| 'An invisible SemanticsNode is one whose rect is not on screen hence not reachable for users, and its semantic information is not merged into a visible parent.\n' |
| 'An invisible SemanticsNode makes the accessibility experience confusing, as it does not provide any visual indication when the user selects it via accessibility technologies.\n' |
| 'Consider removing the above invisible SemanticsNodes if they were added by your RenderObject.assembleSemanticsNode implementation, or filing a bug on GitHub:\n' |
| ' https://github.com/flutter/flutter/issues/new?template=02_bug.yml', |
| ), |
| ), |
| ), |
| ); |
| }); |
| |
| test('mutate existing semantic node list errors', () { |
| final node = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 10.0); |
| |
| final config = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true; |
| |
| final children = <SemanticsNode>[ |
| SemanticsNode()..rect = const Rect.fromLTRB(5.0, 5.0, 10.0, 10.0), |
| ]; |
| |
| node.updateWith(config: config, childrenInInversePaintOrder: children); |
| |
| children.add(SemanticsNode()..rect = const Rect.fromLTRB(42.0, 42.0, 52.0, 52.0)); |
| |
| { |
| late FlutterError error; |
| try { |
| node.updateWith(config: config, childrenInInversePaintOrder: children); |
| } on FlutterError catch (e) { |
| error = e; |
| } |
| expect( |
| error.toString(), |
| equalsIgnoringHashCodes( |
| 'Failed to replace child semantics nodes because the list of `SemanticsNode`s was mutated.\n' |
| 'Instead of mutating the existing list, create a new list containing the desired `SemanticsNode`s.\n' |
| 'Error details:\n' |
| "The list's length has changed from 1 to 2.", |
| ), |
| ); |
| expect( |
| error.diagnostics |
| .singleWhere((DiagnosticsNode node) => node.level == DiagnosticLevel.hint) |
| .toString(), |
| 'Instead of mutating the existing list, create a new list containing the desired `SemanticsNode`s.', |
| ); |
| } |
| |
| { |
| late FlutterError error; |
| final modifiedChildren = <SemanticsNode>[ |
| SemanticsNode()..rect = const Rect.fromLTRB(5.0, 5.0, 10.0, 10.0), |
| SemanticsNode()..rect = const Rect.fromLTRB(10.0, 10.0, 20.0, 20.0), |
| ]; |
| node.updateWith(config: config, childrenInInversePaintOrder: modifiedChildren); |
| try { |
| modifiedChildren[0] = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 20.0, 20.0); |
| modifiedChildren[1] = SemanticsNode()..rect = const Rect.fromLTRB(40.0, 14.0, 60.0, 60.0); |
| node.updateWith(config: config, childrenInInversePaintOrder: modifiedChildren); |
| } on FlutterError catch (e) { |
| error = e; |
| } |
| expect( |
| error.toStringDeep(), |
| equalsIgnoringHashCodes( |
| 'FlutterError\n' |
| ' Failed to replace child semantics nodes because the list of\n' |
| ' `SemanticsNode`s was mutated.\n' |
| ' Instead of mutating the existing list, create a new list\n' |
| ' containing the desired `SemanticsNode`s.\n' |
| ' Error details:\n' |
| ' Child node at position 0 was replaced:\n' |
| ' Previous child: SemanticsNode#4(STALE, owner: null, merged up ⬆️, Rect.fromLTRB(5.0, 5.0, 10.0, 10.0))\n' |
| ' New child: SemanticsNode#6(STALE, owner: null, merged up ⬆️, Rect.fromLTRB(0.0, 0.0, 20.0, 20.0))\n' |
| '\n' |
| ' Child node at position 1 was replaced:\n' |
| ' Previous child: SemanticsNode#5(STALE, owner: null, merged up ⬆️, Rect.fromLTRB(10.0, 10.0, 20.0, 20.0))\n' |
| ' New child: SemanticsNode#7(STALE, owner: null, merged up ⬆️, Rect.fromLTRB(40.0, 14.0, 60.0, 60.0))\n', |
| ), |
| ); |
| |
| expect( |
| error.diagnostics |
| .singleWhere((DiagnosticsNode node) => node.level == DiagnosticLevel.hint) |
| .toString(), |
| 'Instead of mutating the existing list, create a new list containing the desired `SemanticsNode`s.', |
| ); |
| // Two previous children and two new children. |
| expect( |
| error.diagnostics.where((DiagnosticsNode node) => node.value is SemanticsNode).length, |
| 4, |
| ); |
| } |
| }); |
| |
| test( |
| 'after markNeedsSemanticsUpdate() all render objects between two semantic boundaries are asked for annotations', |
| () { |
| final SemanticsHandle handle = TestRenderingFlutterBinding.instance.ensureSemantics(); |
| addTearDown(handle.dispose); |
| |
| TestRender middle; |
| final root = TestRender( |
| hasTapAction: true, |
| isSemanticBoundary: true, |
| child: TestRender( |
| hasLongPressAction: true, |
| child: middle = TestRender( |
| hasScrollLeftAction: true, |
| child: TestRender( |
| hasScrollRightAction: true, |
| child: TestRender(hasScrollUpAction: true, isSemanticBoundary: true), |
| ), |
| ), |
| ), |
| ); |
| |
| layout(root); |
| pumpFrame(phase: EnginePhase.flushSemantics); |
| |
| int expectedActions = |
| SemanticsAction.tap.index | |
| SemanticsAction.longPress.index | |
| SemanticsAction.scrollLeft.index | |
| SemanticsAction.scrollRight.index; |
| expect(root.debugSemantics!.getSemanticsData().actions, expectedActions); |
| |
| middle |
| ..hasScrollLeftAction = false |
| ..hasScrollDownAction = true; |
| middle.markNeedsSemanticsUpdate(); |
| |
| pumpFrame(phase: EnginePhase.flushSemantics); |
| |
| expectedActions = |
| SemanticsAction.tap.index | |
| SemanticsAction.longPress.index | |
| SemanticsAction.scrollDown.index | |
| SemanticsAction.scrollRight.index; |
| expect(root.debugSemantics!.getSemanticsData().actions, expectedActions); |
| }, |
| ); |
| |
| test('updateWith marks node as dirty when role changes', () { |
| final node = SemanticsNode(); |
| |
| expect(node.role, SemanticsRole.none); |
| expect(node.debugIsDirty, isFalse); |
| |
| final config = SemanticsConfiguration()..role = SemanticsRole.tab; |
| node.updateWith(config: config); |
| |
| expect(node.role, config.role); |
| expect(node.debugIsDirty, isTrue); |
| }); |
| }); |
| |
| test('toStringDeep() does not throw with transform == null', () { |
| final child1 = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 5.0, 5.0); |
| final child2 = SemanticsNode()..rect = const Rect.fromLTRB(5.0, 0.0, 10.0, 5.0); |
| final root = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 5.0); |
| root.updateWith(config: null, childrenInInversePaintOrder: <SemanticsNode>[child1, child2]); |
| |
| expect(root.transform, isNull); |
| expect(child1.transform, isNull); |
| expect(child2.transform, isNull); |
| |
| expect( |
| root.toStringDeep(), |
| 'SemanticsNode#3\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 10.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#1\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 5.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#2\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(5.0, 0.0, 10.0, 5.0)\n', |
| ); |
| }); |
| |
| test('Incompatible OrdinalSortKey throw AssertionError when compared', () { |
| // Different types. |
| expect(() { |
| const OrdinalSortKey(0.0).compareTo(const CustomSortKey(0.0)); |
| }, throwsAssertionError); |
| }); |
| |
| test('OrdinalSortKey compares correctly when names are the same', () { |
| const tests = <List<SemanticsSortKey>>[ |
| <SemanticsSortKey>[OrdinalSortKey(0.0), OrdinalSortKey(0.0)], |
| <SemanticsSortKey>[OrdinalSortKey(0.0), OrdinalSortKey(1.0)], |
| <SemanticsSortKey>[OrdinalSortKey(1.0), OrdinalSortKey(0.0)], |
| <SemanticsSortKey>[OrdinalSortKey(1.0), OrdinalSortKey(1.0)], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'a'), OrdinalSortKey(0.0, name: 'a')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'a'), OrdinalSortKey(1.0, name: 'a')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'a'), OrdinalSortKey(0.0, name: 'a')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'a'), OrdinalSortKey(1.0, name: 'a')], |
| ]; |
| final expectedResults = <int>[0, -1, 1, 0, 0, -1, 1, 0]; |
| assert(tests.length == expectedResults.length); |
| final results = <int>[ |
| for (final List<SemanticsSortKey> tuple in tests) tuple[0].compareTo(tuple[1]), |
| ]; |
| expect(results, orderedEquals(expectedResults)); |
| |
| // Differing types should throw an assertion. |
| expect( |
| () => const OrdinalSortKey(0.0).compareTo(const CustomSortKey(0.0)), |
| throwsAssertionError, |
| ); |
| }); |
| |
| test('OrdinalSortKey compares correctly when the names are different', () { |
| const tests = <List<SemanticsSortKey>>[ |
| <SemanticsSortKey>[OrdinalSortKey(0.0), OrdinalSortKey(0.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0), OrdinalSortKey(1.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0), OrdinalSortKey(0.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0), OrdinalSortKey(1.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'foo'), OrdinalSortKey(0.0)], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'foo'), OrdinalSortKey(1.0)], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'foo'), OrdinalSortKey(0.0)], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'foo'), OrdinalSortKey(1.0)], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'foo'), OrdinalSortKey(0.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'foo'), OrdinalSortKey(1.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'foo'), OrdinalSortKey(0.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'foo'), OrdinalSortKey(1.0, name: 'bar')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'bar'), OrdinalSortKey(0.0, name: 'foo')], |
| <SemanticsSortKey>[OrdinalSortKey(0.0, name: 'bar'), OrdinalSortKey(1.0, name: 'foo')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'bar'), OrdinalSortKey(0.0, name: 'foo')], |
| <SemanticsSortKey>[OrdinalSortKey(1.0, name: 'bar'), OrdinalSortKey(1.0, name: 'foo')], |
| ]; |
| final expectedResults = <int>[-1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1]; |
| assert(tests.length == expectedResults.length); |
| final results = <int>[ |
| for (final List<SemanticsSortKey> tuple in tests) tuple[0].compareTo(tuple[1]), |
| ]; |
| expect(results, orderedEquals(expectedResults)); |
| }); |
| |
| test('toStringDeep respects childOrder parameter', () { |
| final child1 = SemanticsNode()..rect = const Rect.fromLTRB(15.0, 0.0, 20.0, 5.0); |
| final child2 = SemanticsNode()..rect = const Rect.fromLTRB(10.0, 0.0, 15.0, 5.0); |
| final root = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 20.0, 5.0); |
| root.updateWith(config: null, childrenInInversePaintOrder: <SemanticsNode>[child1, child2]); |
| expect( |
| root.toStringDeep(), |
| 'SemanticsNode#3\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#1\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(15.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#2\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(10.0, 0.0, 15.0, 5.0)\n', |
| ); |
| |
| expect( |
| root.toStringDeep(childOrder: DebugSemanticsDumpOrder.inverseHitTest), |
| 'SemanticsNode#3\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#1\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(15.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#2\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(10.0, 0.0, 15.0, 5.0)\n', |
| ); |
| |
| final child3 = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 5.0); |
| child3.updateWith( |
| config: null, |
| childrenInInversePaintOrder: <SemanticsNode>[ |
| SemanticsNode()..rect = const Rect.fromLTRB(5.0, 0.0, 10.0, 5.0), |
| SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 5.0, 5.0), |
| ], |
| ); |
| |
| final rootComplex = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 25.0, 5.0); |
| rootComplex.updateWith( |
| config: null, |
| childrenInInversePaintOrder: <SemanticsNode>[child1, child2, child3], |
| ); |
| |
| expect( |
| rootComplex.toStringDeep(), |
| 'SemanticsNode#7\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 25.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#1\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(15.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#2\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(10.0, 0.0, 15.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#4\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 10.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#5\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(5.0, 0.0, 10.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#6\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(0.0, 0.0, 5.0, 5.0)\n', |
| ); |
| |
| expect( |
| rootComplex.toStringDeep(childOrder: DebugSemanticsDumpOrder.inverseHitTest), |
| 'SemanticsNode#7\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 25.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#1\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(15.0, 0.0, 20.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#2\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(10.0, 0.0, 15.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#4\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(0.0, 0.0, 10.0, 5.0)\n' |
| ' │\n' |
| ' ├─SemanticsNode#5\n' |
| ' │ STALE\n' |
| ' │ owner: null\n' |
| ' │ Rect.fromLTRB(5.0, 0.0, 10.0, 5.0)\n' |
| ' │\n' |
| ' └─SemanticsNode#6\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(0.0, 0.0, 5.0, 5.0)\n', |
| ); |
| }); |
| |
| test('debug properties', () { |
| final minimalProperties = SemanticsNode(); |
| expect( |
| minimalProperties.toStringDeep(), |
| 'SemanticsNode#1\n' |
| ' Rect.fromLTRB(0.0, 0.0, 0.0, 0.0)\n' |
| ' invisible\n', |
| ); |
| |
| expect( |
| minimalProperties.toStringDeep(minLevel: DiagnosticLevel.hidden), |
| 'SemanticsNode#1\n' |
| ' owner: null\n' |
| ' isMergedIntoParent: false\n' |
| ' mergeAllDescendantsIntoThisNode: false\n' |
| ' Rect.fromLTRB(0.0, 0.0, 0.0, 0.0)\n' |
| ' tags: null\n' |
| ' actions: []\n' |
| ' customActions: []\n' |
| ' flags: []\n' |
| ' invisible\n' |
| ' isHidden: false\n' |
| ' identifier: ""\n' |
| ' traversalParentIdentifier: null\n' |
| ' traversalChildIdentifier: null\n' |
| ' label: ""\n' |
| ' value: ""\n' |
| ' increasedValue: ""\n' |
| ' decreasedValue: ""\n' |
| ' hint: ""\n' |
| ' tooltip: ""\n' |
| ' textDirection: null\n' |
| ' sortKey: null\n' |
| ' platformViewId: null\n' |
| ' maxValueLength: null\n' |
| ' currentValueLength: null\n' |
| ' scrollChildren: null\n' |
| ' scrollIndex: null\n' |
| ' scrollExtentMin: null\n' |
| ' scrollPosition: null\n' |
| ' scrollExtentMax: null\n' |
| ' indexInParent: null\n' |
| ' headingLevel: 0\n' |
| ' minValue: null\n' |
| ' maxValue: null\n', |
| ); |
| |
| final config = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true |
| ..onScrollUp = () {} |
| ..onLongPress = () {} |
| ..onShowOnScreen = () {} |
| ..isChecked = false |
| ..isSelected = true |
| ..isButton = true |
| ..label = 'Use all the properties' |
| ..textDirection = TextDirection.rtl |
| ..sortKey = const OrdinalSortKey(1.0); |
| final allProperties = SemanticsNode() |
| ..rect = const Rect.fromLTWH(50.0, 10.0, 20.0, 30.0) |
| ..transform = Matrix4.translation(Vector3(10.0, 10.0, 0.0)) |
| ..updateWith(config: config); |
| expect( |
| allProperties.toStringDeep(), |
| equalsIgnoringHashCodes( |
| 'SemanticsNode#2\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' merge boundary ⛔️\n' |
| ' Rect.fromLTRB(60.0, 20.0, 80.0, 50.0)\n' |
| ' actions: longPress, scrollUp, showOnScreen\n' |
| ' flags: hasCheckedState, isSelected, isButton, hasSelectedState\n' |
| ' label: "Use all the properties"\n' |
| ' textDirection: rtl\n' |
| ' sortKey: OrdinalSortKey#19df5(order: 1.0)\n', |
| ), |
| ); |
| expect( |
| allProperties.getSemanticsData().toString(), |
| 'SemanticsData(' |
| 'Rect.fromLTRB(50.0, 10.0, 70.0, 40.0), ' |
| '[1.0,0.0,0.0,10.0; 0.0,1.0,0.0,10.0; 0.0,0.0,1.0,0.0; 0.0,0.0,0.0,1.0], ' |
| 'actions: [longPress, scrollUp, showOnScreen], ' |
| 'flags: [hasCheckedState, isSelected, isButton, hasSelectedState], ' |
| 'label: "Use all the properties", textDirection: rtl)', |
| ); |
| |
| final scaled = SemanticsNode() |
| ..rect = const Rect.fromLTWH(50.0, 10.0, 20.0, 30.0) |
| ..transform = Matrix4.diagonal3(Vector3(10.0, 10.0, 1.0)); |
| expect( |
| scaled.toStringDeep(), |
| 'SemanticsNode#3\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(50.0, 10.0, 70.0, 40.0) scaled by 10.0x\n', |
| ); |
| expect( |
| scaled.getSemanticsData().toString(), |
| 'SemanticsData(Rect.fromLTRB(50.0, 10.0, 70.0, 40.0), [10.0,0.0,0.0,0.0; 0.0,10.0,0.0,0.0; 0.0,0.0,1.0,0.0; 0.0,0.0,0.0,1.0])', |
| ); |
| }); |
| |
| test('blocked actions debug properties', () { |
| final config = SemanticsConfiguration() |
| ..isBlockingUserActions = true |
| ..onScrollUp = () {} |
| ..onLongPress = () {} |
| ..onShowOnScreen = () {} |
| ..onDidGainAccessibilityFocus = () {}; |
| final blocked = SemanticsNode() |
| ..rect = const Rect.fromLTWH(50.0, 10.0, 20.0, 30.0) |
| ..transform = Matrix4.translation(Vector3(10.0, 10.0, 0.0)) |
| ..updateWith(config: config); |
| expect( |
| blocked.toStringDeep(), |
| equalsIgnoringHashCodes( |
| 'SemanticsNode#1\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(60.0, 20.0, 80.0, 50.0)\n' |
| ' actions: didGainAccessibilityFocus, longPress🚫️, scrollUp🚫️,\n' |
| ' showOnScreen🚫️\n', |
| ), |
| ); |
| }); |
| |
| test('validation result debug properties', () { |
| final nodeWithValidationResult = SemanticsNode() |
| ..updateWith( |
| config: SemanticsConfiguration()..validationResult = SemanticsValidationResult.valid, |
| ); |
| |
| expect( |
| nodeWithValidationResult.toStringDeep(), |
| 'SemanticsNode#1\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' Rect.fromLTRB(0.0, 0.0, 0.0, 0.0)\n' |
| ' invisible\n' |
| ' validationResult: valid\n', |
| ); |
| }); |
| |
| test('Custom actions debug properties', () { |
| final configuration = SemanticsConfiguration(); |
| const action1 = CustomSemanticsAction(label: 'action1'); |
| const action2 = CustomSemanticsAction(label: 'action2'); |
| const action3 = CustomSemanticsAction(label: 'action3'); |
| configuration.customSemanticsActions = <CustomSemanticsAction, VoidCallback>{ |
| action1: () {}, |
| action2: () {}, |
| action3: () {}, |
| }; |
| final actionNode = SemanticsNode(); |
| actionNode.updateWith(config: configuration); |
| |
| expect( |
| actionNode.toStringDeep(minLevel: DiagnosticLevel.hidden), |
| 'SemanticsNode#1\n' |
| ' STALE\n' |
| ' owner: null\n' |
| ' isMergedIntoParent: false\n' |
| ' mergeAllDescendantsIntoThisNode: false\n' |
| ' Rect.fromLTRB(0.0, 0.0, 0.0, 0.0)\n' |
| ' tags: null\n' |
| ' actions: customAction\n' |
| ' customActions: action1, action2, action3\n' |
| ' flags: []\n' |
| ' invisible\n' |
| ' isHidden: false\n' |
| ' identifier: ""\n' |
| ' traversalParentIdentifier: null\n' |
| ' traversalChildIdentifier: null\n' |
| ' label: ""\n' |
| ' value: ""\n' |
| ' increasedValue: ""\n' |
| ' decreasedValue: ""\n' |
| ' hint: ""\n' |
| ' tooltip: ""\n' |
| ' textDirection: null\n' |
| ' sortKey: null\n' |
| ' platformViewId: null\n' |
| ' maxValueLength: null\n' |
| ' currentValueLength: null\n' |
| ' scrollChildren: null\n' |
| ' scrollIndex: null\n' |
| ' scrollExtentMin: null\n' |
| ' scrollPosition: null\n' |
| ' scrollExtentMax: null\n' |
| ' indexInParent: null\n' |
| ' headingLevel: 0\n' |
| ' minValue: null\n' |
| ' maxValue: null\n', |
| ); |
| }); |
| |
| test('Attributed String can concat', () { |
| final string1 = AttributedString( |
| 'string1', |
| attributes: <StringAttribute>[ |
| SpellOutStringAttribute(range: const TextRange(start: 0, end: 4)), |
| ], |
| ); |
| final string2 = AttributedString( |
| 'string2', |
| attributes: <StringAttribute>[ |
| LocaleStringAttribute( |
| locale: const Locale('es', 'MX'), |
| range: const TextRange(start: 0, end: 4), |
| ), |
| ], |
| ); |
| final AttributedString result = string1 + string2; |
| expect(result.string, 'string1string2'); |
| expect(result.attributes.length, 2); |
| expect(result.attributes[0].range, const TextRange(start: 0, end: 4)); |
| expect(result.attributes[0] is SpellOutStringAttribute, isTrue); |
| expect( |
| result.toString(), |
| "AttributedString('string1string2', attributes: [SpellOutStringAttribute(TextRange(start: 0, end: 4)), LocaleStringAttribute(TextRange(start: 7, end: 11), es-MX)])", |
| ); |
| }); |
| |
| test('Semantics id does not repeat', () { |
| final owner = SemanticsOwner(onSemanticsUpdate: (SemanticsUpdate update) {}); |
| const expectId = 1400; |
| SemanticsNode? nodeToRemove; |
| for (var i = 0; i < kMaxFrameworkAccessibilityIdentifier; i++) { |
| final node = SemanticsNode(); |
| node.attach(owner); |
| if (node.id == expectId) { |
| nodeToRemove = node; |
| } |
| } |
| nodeToRemove!.detach(); |
| final newNode = SemanticsNode(); |
| newNode.attach(owner); |
| // Id is reused. |
| expect(newNode.id, expectId); |
| }); |
| |
| test('performActionAt can hit test on merged semantics node', () { |
| var tapped = false; |
| final owner = SemanticsOwner(onSemanticsUpdate: (SemanticsUpdate update) {}); |
| final root = SemanticsNode.root(owner: owner)..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 10.0); |
| final merged = SemanticsNode()..rect = const Rect.fromLTRB(0.0, 0.0, 10.0, 10.0); |
| final mergeConfig = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..isMergingSemanticsOfDescendants = true |
| ..onTap = () => tapped = true; |
| final rootConfig = SemanticsConfiguration()..isSemanticBoundary = true; |
| |
| merged.updateWith(config: mergeConfig, childrenInInversePaintOrder: <SemanticsNode>[]); |
| root.updateWith(config: rootConfig, childrenInInversePaintOrder: <SemanticsNode>[merged]); |
| |
| owner.performActionAt(const Offset(5, 5), SemanticsAction.tap); |
| expect(tapped, isTrue); |
| }); |
| |
| test('Tags show up in debug properties', () { |
| final actionNode = SemanticsNode()..tags = <SemanticsTag>{RenderViewport.useTwoPaneSemantics}; |
| |
| expect(actionNode.toStringDeep(), contains('\n tags: RenderViewport.twoPane\n')); |
| }); |
| |
| test('SemanticsConfiguration getter/setter', () { |
| final config = SemanticsConfiguration(); |
| const customAction = CustomSemanticsAction(label: 'test'); |
| |
| expect(config.isSemanticBoundary, isFalse); |
| expect(config.isButton, isFalse); |
| expect(config.isLink, isFalse); |
| expect(config.isMergingSemanticsOfDescendants, isFalse); |
| expect(config.isEnabled, null); |
| expect(config.isChecked, null); |
| expect(config.isSelected, isFalse); |
| expect(config.isBlockingSemanticsOfPreviouslyPaintedNodes, isFalse); |
| expect(config.isFocused, null); |
| expect(config.isTextField, isFalse); |
| |
| expect(config.onShowOnScreen, isNull); |
| expect(config.onScrollDown, isNull); |
| expect(config.onScrollUp, isNull); |
| expect(config.onScrollLeft, isNull); |
| expect(config.onScrollRight, isNull); |
| expect(config.onScrollToOffset, isNull); |
| expect(config.onLongPress, isNull); |
| expect(config.onDecrease, isNull); |
| expect(config.onIncrease, isNull); |
| expect(config.onMoveCursorForwardByCharacter, isNull); |
| expect(config.onMoveCursorBackwardByCharacter, isNull); |
| expect(config.onTap, isNull); |
| expect(config.customSemanticsActions[customAction], isNull); |
| |
| config.isSemanticBoundary = true; |
| config.isButton = true; |
| config.isLink = true; |
| config.isMergingSemanticsOfDescendants = true; |
| config.isEnabled = true; |
| config.isChecked = true; |
| config.isSelected = true; |
| config.isBlockingSemanticsOfPreviouslyPaintedNodes = true; |
| config.isFocused = true; |
| config.isTextField = true; |
| |
| void onShowOnScreen() {} |
| void onScrollDown() {} |
| void onScrollUp() {} |
| void onScrollLeft() {} |
| void onScrollRight() {} |
| void onScrollToOffset(Offset _) {} |
| void onLongPress() {} |
| void onDecrease() {} |
| void onIncrease() {} |
| void onMoveCursorForwardByCharacter(bool _) {} |
| void onMoveCursorBackwardByCharacter(bool _) {} |
| void onTap() {} |
| void onCustomAction() {} |
| |
| config.onShowOnScreen = onShowOnScreen; |
| config.onScrollDown = onScrollDown; |
| config.onScrollUp = onScrollUp; |
| config.onScrollLeft = onScrollLeft; |
| config.onScrollRight = onScrollRight; |
| config.onScrollToOffset = onScrollToOffset; |
| config.onLongPress = onLongPress; |
| config.onDecrease = onDecrease; |
| config.onIncrease = onIncrease; |
| config.onMoveCursorForwardByCharacter = onMoveCursorForwardByCharacter; |
| config.onMoveCursorBackwardByCharacter = onMoveCursorBackwardByCharacter; |
| config.onTap = onTap; |
| config.customSemanticsActions[customAction] = onCustomAction; |
| |
| expect(config.isSemanticBoundary, isTrue); |
| expect(config.isButton, isTrue); |
| expect(config.isLink, isTrue); |
| expect(config.isMergingSemanticsOfDescendants, isTrue); |
| expect(config.isEnabled, isTrue); |
| expect(config.isChecked, isTrue); |
| expect(config.isSelected, isTrue); |
| expect(config.isBlockingSemanticsOfPreviouslyPaintedNodes, isTrue); |
| expect(config.isFocused, isTrue); |
| expect(config.isTextField, isTrue); |
| |
| expect(config.onShowOnScreen, same(onShowOnScreen)); |
| expect(config.onScrollDown, same(onScrollDown)); |
| expect(config.onScrollUp, same(onScrollUp)); |
| expect(config.onScrollLeft, same(onScrollLeft)); |
| expect(config.onScrollRight, same(onScrollRight)); |
| expect(config.onScrollToOffset, same(onScrollToOffset)); |
| expect(config.onLongPress, same(onLongPress)); |
| expect(config.onDecrease, same(onDecrease)); |
| expect(config.onIncrease, same(onIncrease)); |
| expect(config.onMoveCursorForwardByCharacter, same(onMoveCursorForwardByCharacter)); |
| expect(config.onMoveCursorBackwardByCharacter, same(onMoveCursorBackwardByCharacter)); |
| expect(config.onTap, same(onTap)); |
| expect(config.customSemanticsActions[customAction], same(onCustomAction)); |
| }); |
| |
| test('SemanticsConfiguration.copy() preserves hitTestBehavior', () { |
| final config = SemanticsConfiguration() |
| ..isSemanticBoundary = true |
| ..label = 'test' |
| ..hitTestBehavior = SemanticsHitTestBehavior.opaque; |
| |
| expect(config.hitTestBehavior, SemanticsHitTestBehavior.opaque); |
| |
| final SemanticsConfiguration copy = config.copy(); |
| |
| expect(copy.hitTestBehavior, SemanticsHitTestBehavior.opaque); |
| expect(copy.isSemanticBoundary, isTrue); |
| expect(copy.label, 'test'); |
| }); |
| |
| test('SemanticsConfiguration.copy() preserves all hitTestBehavior values', () { |
| final deferConfig = SemanticsConfiguration(); |
| expect(deferConfig.copy().hitTestBehavior, SemanticsHitTestBehavior.defer); |
| |
| final opaqueConfig = SemanticsConfiguration() |
| ..hitTestBehavior = SemanticsHitTestBehavior.opaque; |
| expect(opaqueConfig.copy().hitTestBehavior, SemanticsHitTestBehavior.opaque); |
| |
| final transparentConfig = SemanticsConfiguration() |
| ..hitTestBehavior = SemanticsHitTestBehavior.transparent; |
| expect(transparentConfig.copy().hitTestBehavior, SemanticsHitTestBehavior.transparent); |
| }); |
| |
| test('SemanticsOwner dispatches memory events', () async { |
| await expectLater( |
| await memoryEvents( |
| () => SemanticsOwner(onSemanticsUpdate: (SemanticsUpdate update) {}).dispose(), |
| SemanticsOwner, |
| ), |
| areCreateAndDispose, |
| ); |
| }); |
| |
| test('SemanticsNode.indexInParent appears in string output', () async { |
| final node = SemanticsNode()..indexInParent = 10; |
| expect(node.toString(), contains('indexInParent: 10')); |
| }); |
| |
| group('SemanticsLabelBuilder', () { |
| test('basic functionality with default separator', () { |
| final builder = SemanticsLabelBuilder(); |
| expect(builder.isEmpty, isTrue); |
| expect(builder.length, 0); |
| |
| builder.addPart('Hello'); |
| expect(builder.isEmpty, isFalse); |
| expect(builder.length, 1); |
| |
| builder.addPart('world'); |
| expect(builder.length, 2); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello world'); |
| }); |
| |
| test('custom separator', () { |
| final builder = SemanticsLabelBuilder(separator: ', '); |
| builder |
| ..addPart('One') |
| ..addPart('Two') |
| ..addPart('Three'); |
| |
| final String label = builder.build(); |
| expect(label, 'One, Two, Three'); |
| }); |
| |
| test('empty separator', () { |
| final builder = SemanticsLabelBuilder(separator: ''); |
| builder |
| ..addPart('Hello') |
| ..addPart('World'); |
| |
| final String label = builder.build(); |
| expect(label, 'HelloWorld'); |
| }); |
| |
| test('ignores empty parts', () { |
| final builder = SemanticsLabelBuilder(); |
| builder |
| ..addPart('Hello') |
| ..addPart('') |
| ..addPart('world'); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello world'); |
| expect(builder.length, 2); |
| }); |
| |
| test('single part', () { |
| final builder = SemanticsLabelBuilder(); |
| builder.addPart('Single'); |
| |
| final String label = builder.build(); |
| expect(label, 'Single'); |
| }); |
| |
| test('empty builder', () { |
| final builder = SemanticsLabelBuilder(); |
| final String label = builder.build(); |
| expect(label, ''); |
| }); |
| |
| test('clear functionality', () { |
| final builder = SemanticsLabelBuilder(); |
| builder |
| ..addPart('Hello') |
| ..addPart('world'); |
| |
| expect(builder.length, 2); |
| |
| builder.clear(); |
| expect(builder.isEmpty, isTrue); |
| expect(builder.length, 0); |
| |
| final String label = builder.build(); |
| expect(label, ''); |
| }); |
| |
| test('reusable builder', () { |
| final builder = SemanticsLabelBuilder(); |
| |
| // First use |
| builder |
| ..addPart('First') |
| ..addPart('use'); |
| expect(builder.build(), 'First use'); |
| |
| // Clear and reuse |
| builder.clear(); |
| builder |
| ..addPart('Second') |
| ..addPart('use'); |
| expect(builder.build(), 'Second use'); |
| }); |
| |
| test('reuse without clearing', () { |
| final builder = SemanticsLabelBuilder(); |
| |
| // First use |
| builder |
| ..addPart('First') |
| ..addPart('batch'); |
| expect(builder.build(), 'First batch'); |
| expect(builder.length, 2); |
| |
| // Add more parts without clearing - should accumulate |
| builder |
| ..addPart('Second') |
| ..addPart('batch'); |
| expect(builder.build(), 'First batch Second batch'); |
| expect(builder.length, 4); |
| |
| // Add even more parts - should continue accumulating |
| builder.addPart('Final'); |
| expect(builder.build(), 'First batch Second batch Final'); |
| expect(builder.length, 5); |
| }); |
| }); |
| |
| group('SemanticsLabelBuilder text direction', () { |
| test('no text direction embedding when overall direction is null', () { |
| final builder = SemanticsLabelBuilder(); |
| builder |
| ..addPart('Hello', textDirection: TextDirection.ltr) |
| ..addPart('مرحبا', textDirection: TextDirection.rtl); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello مرحبا'); |
| }); |
| |
| test('text direction embedding with LTR overall direction', () { |
| final builder = SemanticsLabelBuilder(textDirection: TextDirection.ltr); |
| builder |
| ..addPart('Hello', textDirection: TextDirection.ltr) |
| ..addPart('مرحبا', textDirection: TextDirection.rtl) |
| ..addPart('world', textDirection: TextDirection.ltr); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello \u202Bمرحبا\u202C world'); |
| }); |
| |
| test('text direction embedding with RTL overall direction', () { |
| final builder = SemanticsLabelBuilder(textDirection: TextDirection.rtl); |
| builder |
| ..addPart('مرحبا', textDirection: TextDirection.rtl) |
| ..addPart('Hello', textDirection: TextDirection.ltr); |
| |
| final String label = builder.build(); |
| expect(label, 'مرحبا \u202AHello\u202C'); |
| }); |
| |
| test('no embedding when all parts have same direction', () { |
| final builder = SemanticsLabelBuilder(textDirection: TextDirection.ltr); |
| builder |
| ..addPart('Hello', textDirection: TextDirection.ltr) |
| ..addPart('world', textDirection: TextDirection.ltr); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello world'); |
| }); |
| |
| test('part direction falls back to overall direction', () { |
| final builder = SemanticsLabelBuilder(textDirection: TextDirection.ltr); |
| builder |
| ..addPart('Hello') |
| ..addPart('world'); |
| |
| final String label = builder.build(); |
| expect(label, 'Hello world'); |
| }); |
| |
| test('complex multilingual example', () { |
| final builder = SemanticsLabelBuilder(textDirection: TextDirection.ltr, separator: ', '); |
| builder |
| ..addPart('Welcome', textDirection: TextDirection.ltr) |
| ..addPart('مرحبا', textDirection: TextDirection.rtl) // Arabic |
| ..addPart('שלום', textDirection: TextDirection.rtl) // Hebrew |
| ..addPart('to our app', textDirection: TextDirection.ltr); |
| |
| expect(builder.build(), 'Welcome, \u202Bمرحبا\u202C, \u202Bשלום\u202C, to our app'); |
| }); |
| }); |
| |
| group('Edge cases and error handling', () { |
| test('very long labels', () { |
| final builder = SemanticsLabelBuilder(); |
| final String longText = 'A' * 1000; |
| |
| builder |
| ..addPart(longText) |
| ..addPart('short'); |
| |
| final String label = builder.build(); |
| expect(label.length, 1006); // 1000 + 1 (space) + 5 |
| expect(label, startsWith('AAAA')); |
| expect(label, endsWith(' short')); |
| }); |
| |
| test('many parts', () { |
| final builder = SemanticsLabelBuilder(); |
| |
| for (var i = 0; i < 100; i++) { |
| builder.addPart('part$i'); |
| } |
| |
| final String label = builder.build(); |
| expect(label, startsWith('part0 part1')); |
| expect(label, endsWith('part98 part99')); |
| expect(builder.length, 100); |
| }); |
| |
| test('special characters in separators', () { |
| final builder = SemanticsLabelBuilder(separator: ' | '); |
| builder |
| ..addPart('first') |
| ..addPart('second') |
| ..addPart('third'); |
| |
| final String label = builder.build(); |
| expect(label, 'first | second | third'); |
| }); |
| |
| test('Unicode characters in content', () { |
| final builder = SemanticsLabelBuilder(); |
| builder |
| ..addPart('Emoji: 😀🎉') |
| ..addPart('Math: ∑∆π') |
| ..addPart('Currency: €£¥'); |
| |
| final String label = builder.build(); |
| expect(label, 'Emoji: 😀🎉 Math: ∑∆π Currency: €£¥'); |
| }); |
| }); |
| } |
| |
| class TestRender extends RenderProxyBox { |
| TestRender({ |
| this.hasTapAction = false, |
| this.hasLongPressAction = false, |
| this.hasScrollLeftAction = false, |
| this.hasScrollRightAction = false, |
| this.hasScrollUpAction = false, |
| this.hasScrollDownAction = false, |
| this.isSemanticBoundary = false, |
| RenderBox? child, |
| }) : super(child); |
| |
| bool hasTapAction; |
| bool hasLongPressAction; |
| bool hasScrollLeftAction; |
| bool hasScrollRightAction; |
| bool hasScrollUpAction; |
| bool hasScrollDownAction; |
| bool isSemanticBoundary; |
| |
| @override |
| void describeSemanticsConfiguration(SemanticsConfiguration config) { |
| super.describeSemanticsConfiguration(config); |
| |
| config.isSemanticBoundary = isSemanticBoundary; |
| if (hasTapAction) { |
| config.onTap = () {}; |
| } |
| if (hasLongPressAction) { |
| config.onLongPress = () {}; |
| } |
| if (hasScrollLeftAction) { |
| config.onScrollLeft = () {}; |
| } |
| if (hasScrollRightAction) { |
| config.onScrollRight = () {}; |
| } |
| if (hasScrollUpAction) { |
| config.onScrollUp = () {}; |
| } |
| if (hasScrollDownAction) { |
| config.onScrollDown = () {}; |
| } |
| } |
| } |
| |
| class CustomSortKey extends OrdinalSortKey { |
| const CustomSortKey(super.order, {super.name}); |
| } |
