2937 lines
88 KiB
Dart
2937 lines
88 KiB
Dart
// 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:math';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/rendering.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
|
|
import 'semantics_tester.dart';
|
|
|
|
void main() {
|
|
group('SliverSemantics', () {
|
|
setUp(() {
|
|
debugResetSemanticsIdCounter();
|
|
});
|
|
|
|
_tests();
|
|
});
|
|
}
|
|
|
|
Widget boilerPlate({required List<Widget> slivers, bool wrapWithDirectionality = true}) {
|
|
Widget child = MediaQuery(
|
|
data: const MediaQueryData(),
|
|
child: CustomScrollView(slivers: slivers),
|
|
);
|
|
if (wrapWithDirectionality) {
|
|
child = Directionality(textDirection: TextDirection.ltr, child: child);
|
|
}
|
|
return child;
|
|
}
|
|
|
|
void _tests() {
|
|
testWidgets('Semantics shutdown and restart', (WidgetTester tester) async {
|
|
SemanticsTester? semantics = SemanticsTester(tester);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
textDirection: TextDirection.ltr,
|
|
label: 'test1',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
semantics.dispose();
|
|
semantics = null;
|
|
await tester.pump();
|
|
|
|
expect(tester.binding.hasScheduledFrame, isFalse);
|
|
semantics = SemanticsTester(tester);
|
|
expect(tester.binding.hasScheduledFrame, isTrue);
|
|
await tester.pump();
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
}, semanticsEnabled: false);
|
|
|
|
testWidgets('tag only applies to immediate child', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverToBoxAdapter(child: Container(padding: const EdgeInsets.only(top: 20.0))),
|
|
const SliverToBoxAdapter(child: Text('label')),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
isNot(
|
|
includesNodeWith(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
tags: <SemanticsTag>{RenderViewport.useTwoPaneSemantics},
|
|
),
|
|
),
|
|
);
|
|
|
|
await tester.pump();
|
|
// Semantics should stay the same after a frame update.
|
|
expect(
|
|
semantics,
|
|
isNot(
|
|
includesNodeWith(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
tags: <SemanticsTag>{RenderViewport.useTwoPaneSemantics},
|
|
),
|
|
),
|
|
);
|
|
|
|
semantics.dispose();
|
|
}, semanticsEnabled: false);
|
|
|
|
testWidgets('Detach and reattach assert', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
final GlobalKey key = GlobalKey();
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
sliver: SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
label: 'test2a',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
var expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
label: 'test1',
|
|
children: <TestSemantics>[TestSemantics(label: 'test2a')],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
sliver: SliverSemantics(
|
|
container: true,
|
|
label: 'middle',
|
|
sliver: SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
label: 'test2b',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
label: 'test1',
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
label: 'middle',
|
|
children: <TestSemantics>[TestSemantics(label: 'test2b')],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Semantics and Directionality - RTL', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.rtl,
|
|
child: boilerPlate(
|
|
wrapWithDirectionality: false,
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(semantics, includesNodeWith(label: 'test1', textDirection: TextDirection.rtl));
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Semantics and Directionality - LTR', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
// Wraps with a default Directionality widget with TextDirection.ltr.
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(semantics, includesNodeWith(label: 'test1', textDirection: TextDirection.ltr));
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Semantics and Directionality - cannot override RTL with LTR', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.rtl,
|
|
child: boilerPlate(
|
|
wrapWithDirectionality: false,
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
textDirection: TextDirection.ltr,
|
|
label: 'test1',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Semantics and Directionality - cannot override LTR with RTL', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
// Wraps with a default Directionality widget with TextDirection.ltr.
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'test1',
|
|
textDirection: TextDirection.rtl,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
textDirection: TextDirection.rtl,
|
|
label: 'test1',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('label and hint', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'label',
|
|
hint: 'hint',
|
|
value: 'value',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
label: 'label',
|
|
hint: 'hint',
|
|
value: 'value',
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('hints can merge', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
hint: 'hint one',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
hint: 'hint two',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
textDirection: TextDirection.ltr,
|
|
hint: 'hint one\nhint two',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('hints can merge with Semantics widget', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(hint: 'hint one', child: const SizedBox(height: 10.0)),
|
|
Semantics(hint: 'hint two', child: const SizedBox(height: 10.0)),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
textDirection: TextDirection.ltr,
|
|
hint: 'hint one\nhint two',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('values do not merge', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
value: 'value one',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
value: 'value two',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
children: <TestSemantics>[
|
|
TestSemantics(value: 'value one', textDirection: TextDirection.ltr),
|
|
TestSemantics(value: 'value two', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('values do not merge with Semantics widget', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(value: 'value one', child: const SizedBox(height: 10.0)),
|
|
Semantics(value: 'value two', child: const SizedBox(height: 10.0)),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
children: <TestSemantics>[
|
|
TestSemantics(value: 'value one', textDirection: TextDirection.ltr),
|
|
TestSemantics(value: 'value two', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('value and hint can merge', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
hint: 'hint',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
value: 'value',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
hint: 'hint',
|
|
value: 'value',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('value and hint can merge with Semantics widget', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(hint: 'hint', child: const SizedBox(height: 10.0)),
|
|
Semantics(value: 'value', child: const SizedBox(height: 10.0)),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
hint: 'hint',
|
|
value: 'value',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('tagForChildren works', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: const SliverToBoxAdapter(child: Text('child 1')),
|
|
),
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: const SliverToBoxAdapter(child: Text('child 2')),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'child 1', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'child 2', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('tagForChildren works with Semantics widget', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(container: true, child: const Text('child 1')),
|
|
Semantics(container: true, child: const Text('child 2')),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'child 1', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'child 2', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('supports all actions', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
final performedActions = <SemanticsAction>[];
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onDismiss: () => performedActions.add(SemanticsAction.dismiss),
|
|
onTap: () => performedActions.add(SemanticsAction.tap),
|
|
onLongPress: () => performedActions.add(SemanticsAction.longPress),
|
|
onScrollLeft: () => performedActions.add(SemanticsAction.scrollLeft),
|
|
onScrollRight: () => performedActions.add(SemanticsAction.scrollRight),
|
|
onScrollUp: () => performedActions.add(SemanticsAction.scrollUp),
|
|
onScrollDown: () => performedActions.add(SemanticsAction.scrollDown),
|
|
onIncrease: () => performedActions.add(SemanticsAction.increase),
|
|
onDecrease: () => performedActions.add(SemanticsAction.decrease),
|
|
onCopy: () => performedActions.add(SemanticsAction.copy),
|
|
onCut: () => performedActions.add(SemanticsAction.cut),
|
|
onPaste: () => performedActions.add(SemanticsAction.paste),
|
|
onMoveCursorForwardByCharacter: (bool _) =>
|
|
performedActions.add(SemanticsAction.moveCursorForwardByCharacter),
|
|
onMoveCursorBackwardByCharacter: (bool _) =>
|
|
performedActions.add(SemanticsAction.moveCursorBackwardByCharacter),
|
|
onSetSelection: (TextSelection _) => performedActions.add(SemanticsAction.setSelection),
|
|
onSetText: (String _) => performedActions.add(SemanticsAction.setText),
|
|
onDidGainAccessibilityFocus: () =>
|
|
performedActions.add(SemanticsAction.didGainAccessibilityFocus),
|
|
onDidLoseAccessibilityFocus: () =>
|
|
performedActions.add(SemanticsAction.didLoseAccessibilityFocus),
|
|
onFocus: () => performedActions.add(SemanticsAction.focus),
|
|
onExpand: () => performedActions.add(SemanticsAction.expand),
|
|
onCollapse: () => performedActions.add(SemanticsAction.collapse),
|
|
sliver: SliverList(
|
|
delegate: SliverChildBuilderDelegate((BuildContext context, int index) {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text('Lorem Ipsum $index'),
|
|
),
|
|
);
|
|
}, childCount: 1),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final Set<SemanticsAction> allActions = SemanticsAction.values.toSet()
|
|
..remove(SemanticsAction.moveCursorForwardByWord)
|
|
..remove(SemanticsAction.moveCursorBackwardByWord)
|
|
..remove(SemanticsAction.customAction) // customAction is not user-exposed.
|
|
..remove(SemanticsAction.showOnScreen) // showOnScreen is not user-exposed.
|
|
..remove(SemanticsAction.scrollToOffset); // scrollToOffset is not user-exposed.
|
|
|
|
const expectedId = 2;
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: expectedId,
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
actions: <SemanticsAction>[
|
|
SemanticsAction.tap,
|
|
SemanticsAction.longPress,
|
|
SemanticsAction.scrollLeft,
|
|
SemanticsAction.scrollRight,
|
|
SemanticsAction.scrollUp,
|
|
SemanticsAction.scrollDown,
|
|
SemanticsAction.increase,
|
|
SemanticsAction.decrease,
|
|
SemanticsAction.moveCursorForwardByCharacter,
|
|
SemanticsAction.moveCursorBackwardByCharacter,
|
|
SemanticsAction.setSelection,
|
|
SemanticsAction.copy,
|
|
SemanticsAction.cut,
|
|
SemanticsAction.paste,
|
|
SemanticsAction.didGainAccessibilityFocus,
|
|
SemanticsAction.didLoseAccessibilityFocus,
|
|
SemanticsAction.dismiss,
|
|
SemanticsAction.setText,
|
|
SemanticsAction.focus,
|
|
SemanticsAction.expand,
|
|
SemanticsAction.collapse,
|
|
],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Lorem Ipsum 0', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
// Do the actions work?
|
|
final SemanticsOwner semanticsOwner = tester.binding.pipelineOwner.semanticsOwner!;
|
|
var expectedLength = 1;
|
|
for (final action in allActions) {
|
|
switch (action) {
|
|
case SemanticsAction.moveCursorBackwardByCharacter:
|
|
case SemanticsAction.moveCursorForwardByCharacter:
|
|
semanticsOwner.performAction(expectedId, action, true);
|
|
case SemanticsAction.setSelection:
|
|
semanticsOwner.performAction(expectedId, action, <dynamic, dynamic>{
|
|
'base': 4,
|
|
'extent': 5,
|
|
});
|
|
case SemanticsAction.setText:
|
|
semanticsOwner.performAction(expectedId, action, 'text');
|
|
case SemanticsAction.copy:
|
|
case SemanticsAction.customAction:
|
|
case SemanticsAction.cut:
|
|
case SemanticsAction.decrease:
|
|
case SemanticsAction.didGainAccessibilityFocus:
|
|
case SemanticsAction.didLoseAccessibilityFocus:
|
|
case SemanticsAction.dismiss:
|
|
case SemanticsAction.increase:
|
|
case SemanticsAction.longPress:
|
|
case SemanticsAction.moveCursorBackwardByWord:
|
|
case SemanticsAction.moveCursorForwardByWord:
|
|
case SemanticsAction.paste:
|
|
case SemanticsAction.scrollDown:
|
|
case SemanticsAction.scrollLeft:
|
|
case SemanticsAction.scrollRight:
|
|
case SemanticsAction.scrollUp:
|
|
case SemanticsAction.scrollToOffset:
|
|
case SemanticsAction.showOnScreen:
|
|
case SemanticsAction.tap:
|
|
case SemanticsAction.focus:
|
|
case SemanticsAction.expand:
|
|
case SemanticsAction.collapse:
|
|
semanticsOwner.performAction(expectedId, action);
|
|
}
|
|
expect(performedActions.length, expectedLength);
|
|
expect(performedActions.last, action);
|
|
expectedLength += 1;
|
|
}
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('supports all flags', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
// Checked state and toggled state are mutually exclusive.
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: const Key('a'),
|
|
container: true,
|
|
explicitChildNodes: true,
|
|
// flags.
|
|
enabled: true,
|
|
hidden: true,
|
|
checked: true,
|
|
selected: true,
|
|
button: true,
|
|
slider: true,
|
|
keyboardKey: true,
|
|
link: true,
|
|
textField: true,
|
|
readOnly: true,
|
|
focused: true,
|
|
focusable: true,
|
|
inMutuallyExclusiveGroup: true,
|
|
header: true,
|
|
obscured: true,
|
|
multiline: true,
|
|
scopesRoute: true,
|
|
namesRoute: true,
|
|
image: true,
|
|
liveRegion: true,
|
|
expanded: true,
|
|
isRequired: true,
|
|
sliver: SliverList(
|
|
delegate: SliverChildBuilderDelegate((BuildContext context, int index) {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text('Lorem Ipsum $index'),
|
|
),
|
|
);
|
|
}, childCount: 1),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final List<SemanticsFlag> flags = SemanticsFlag.values.toList();
|
|
flags
|
|
..remove(SemanticsFlag.hasToggledState)
|
|
..remove(SemanticsFlag.isToggled)
|
|
..remove(SemanticsFlag.hasImplicitScrolling)
|
|
..remove(SemanticsFlag.isCheckStateMixed);
|
|
|
|
var expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
flags: flags,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Lorem Ipsum 0', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: const Key('b'),
|
|
container: true,
|
|
scopesRoute: false,
|
|
sliver: SliverList(
|
|
delegate: SliverChildBuilderDelegate((BuildContext context, int index) {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text('Lorem Ipsum $index'),
|
|
),
|
|
);
|
|
}, childCount: 1),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
flags: <SemanticsFlag>[],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Lorem Ipsum 0', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: const Key('c'),
|
|
toggled: true,
|
|
sliver: SliverList(
|
|
delegate: SliverChildBuilderDelegate((BuildContext context, int index) {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text('Lorem Ipsum $index'),
|
|
),
|
|
);
|
|
}, childCount: 1),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasToggledState, SemanticsFlag.isToggled],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Lorem Ipsum 0', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: const Key('a'),
|
|
container: true,
|
|
explicitChildNodes: true,
|
|
// flags.
|
|
enabled: true,
|
|
hidden: true,
|
|
checked: false,
|
|
mixed: true,
|
|
selected: true,
|
|
button: true,
|
|
slider: true,
|
|
keyboardKey: true,
|
|
link: true,
|
|
textField: true,
|
|
readOnly: true,
|
|
focused: true,
|
|
focusable: true,
|
|
inMutuallyExclusiveGroup: true,
|
|
header: true,
|
|
obscured: true,
|
|
multiline: true,
|
|
scopesRoute: true,
|
|
namesRoute: true,
|
|
image: true,
|
|
liveRegion: true,
|
|
expanded: true,
|
|
isRequired: true,
|
|
sliver: SliverList(
|
|
delegate: SliverChildBuilderDelegate((BuildContext context, int index) {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text('Lorem Ipsum $index'),
|
|
),
|
|
);
|
|
}, childCount: 1),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
flags
|
|
..remove(SemanticsFlag.isChecked)
|
|
..add(SemanticsFlag.isCheckStateMixed);
|
|
semantics.dispose();
|
|
expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
flags: flags,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Lorem Ipsum 0', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
});
|
|
|
|
testWidgets('supports tooltip', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
tooltip: 'test1',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
tooltip: 'test1',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('actions can be replaced without triggering semantics update', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
var semanticsUpdateCount = 0;
|
|
tester.binding.pipelineOwner.semanticsOwner!.addListener(() {
|
|
semanticsUpdateCount += 1;
|
|
});
|
|
|
|
final performedActions = <String>[];
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onTap: () => performedActions.add('first'),
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
const expectedId = 2;
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 1,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 3,
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: expectedId,
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
actions: SemanticsAction.tap.index,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
final SemanticsOwner semanticsOwner = tester.binding.pipelineOwner.semanticsOwner!;
|
|
|
|
expect(semantics, hasSemantics(expectedSemantics, ignoreRect: true, ignoreTransform: true));
|
|
semanticsOwner.performAction(expectedId, SemanticsAction.tap);
|
|
expect(semanticsUpdateCount, 1);
|
|
expect(performedActions, <String>['first']);
|
|
|
|
semanticsUpdateCount = 0;
|
|
performedActions.clear();
|
|
|
|
// Updating existing handler should not trigger semantics update.
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onTap: () => performedActions.add('second'),
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(semantics, hasSemantics(expectedSemantics, ignoreRect: true, ignoreTransform: true));
|
|
semanticsOwner.performAction(expectedId, SemanticsAction.tap);
|
|
expect(semanticsUpdateCount, 0);
|
|
expect(performedActions, <String>['second']);
|
|
|
|
semanticsUpdateCount = 0;
|
|
performedActions.clear();
|
|
|
|
// Adding a handler works.
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onTap: () => performedActions.add('second'),
|
|
onLongPress: () => performedActions.add('longPress'),
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemanticsWithLongPress = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 1,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 3,
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: expectedId,
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
actions: SemanticsAction.tap.index | SemanticsAction.longPress.index,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemanticsWithLongPress, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semanticsOwner.performAction(expectedId, SemanticsAction.longPress);
|
|
expect(semanticsUpdateCount, 1);
|
|
expect(performedActions, <String>['longPress']);
|
|
|
|
semanticsUpdateCount = 0;
|
|
performedActions.clear();
|
|
|
|
// Removing a handler works.
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onTap: () => performedActions.add('second'),
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(semantics, hasSemantics(expectedSemantics, ignoreRect: true, ignoreTransform: true));
|
|
expect(semanticsUpdateCount, 1);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('onTapHint and onLongPressHint create custom actions', (WidgetTester tester) async {
|
|
final SemanticsHandle semantics = tester.ensureSemantics();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onTap: () {},
|
|
onTapHint: 'test',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.byType(SliverSemantics)),
|
|
matchesSemantics(hasTapAction: true, onTapHint: 'test'),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
onLongPress: () {},
|
|
onLongPressHint: 'foo',
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.byType(SliverSemantics)),
|
|
matchesSemantics(hasLongPressAction: true, onLongPressHint: 'foo'),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('supports CustomSemanticsActions', (WidgetTester tester) async {
|
|
final SemanticsHandle semantics = tester.ensureSemantics();
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
customSemanticsActions: <CustomSemanticsAction, VoidCallback>{
|
|
const CustomSemanticsAction(label: 'foo'): () {},
|
|
const CustomSemanticsAction(label: 'bar'): () {},
|
|
},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.byType(SliverSemantics)),
|
|
matchesSemantics(
|
|
customActions: <CustomSemanticsAction>[
|
|
const CustomSemanticsAction(label: 'bar'),
|
|
const CustomSemanticsAction(label: 'foo'),
|
|
],
|
|
),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('increased/decreased values are annotated', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
value: '10s',
|
|
increasedValue: '11s',
|
|
decreasedValue: '9s',
|
|
onIncrease: () => () {},
|
|
onDecrease: () => () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
actions: SemanticsAction.increase.index | SemanticsAction.decrease.index,
|
|
textDirection: TextDirection.ltr,
|
|
value: '10s',
|
|
increasedValue: '11s',
|
|
decreasedValue: '9s',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('excludeSemantics ignores children', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
label: 'label',
|
|
excludeSemantics: true,
|
|
textDirection: TextDirection.ltr,
|
|
sliver: SliverSemantics(
|
|
label: 'other label',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
label: 'label',
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('slivers built in a widget tree are sorted properly', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
var semanticsUpdateCount = 0;
|
|
tester.binding.pipelineOwner.semanticsOwner!.addListener(() {
|
|
semanticsUpdateCount += 1;
|
|
});
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(0.0),
|
|
explicitChildNodes: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(3.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 1')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(2.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 2')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(1.0),
|
|
explicitChildNodes: true,
|
|
sliver: SliverCrossAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
sortKey: const OrdinalSortKey(3.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 3')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const OrdinalSortKey(2.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 4')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const OrdinalSortKey(1.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 5')),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(semanticsUpdateCount, 1);
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 1,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 9,
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 2,
|
|
tags: <SemanticsTag>[const SemanticsTag('RenderViewport.twoPane')],
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 5,
|
|
children: <TestSemantics>[
|
|
TestSemantics(id: 8, label: 'Label 5', textDirection: TextDirection.ltr),
|
|
TestSemantics(id: 7, label: 'Label 4', textDirection: TextDirection.ltr),
|
|
TestSemantics(id: 6, label: 'Label 3', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
TestSemantics(id: 4, label: 'Label 2', textDirection: TextDirection.ltr),
|
|
TestSemantics(id: 3, label: 'Label 1', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(semantics, hasSemantics(expectedSemantics, ignoreRect: true, ignoreTransform: true));
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Semantics widgets built with explicit sort orders are sorted properly', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
var semanticsUpdateCount = 0;
|
|
tester.binding.pipelineOwner.semanticsOwner!.addListener(() {
|
|
semanticsUpdateCount += 1;
|
|
});
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverCrossAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(3.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 1')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(1.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 2')),
|
|
),
|
|
SliverSemantics(
|
|
sortKey: const CustomSortKey(2.0),
|
|
sliver: const SliverToBoxAdapter(child: Text('Label 3')),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(semanticsUpdateCount, 1);
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 1,
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
id: 5,
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(id: 3, label: 'Label 2', textDirection: TextDirection.ltr),
|
|
TestSemantics(id: 4, label: 'Label 3', textDirection: TextDirection.ltr),
|
|
TestSemantics(id: 2, label: 'Label 1', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(semantics, hasSemantics(expectedSemantics, ignoreTransform: true, ignoreRect: true));
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('slivers without sort orders are sorted properly', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
var semanticsUpdateCount = 0;
|
|
tester.binding.pipelineOwner.semanticsOwner!.addListener(() {
|
|
semanticsUpdateCount += 1;
|
|
});
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: const <Widget>[
|
|
SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverToBoxAdapter(child: Text('Label 1')),
|
|
SliverToBoxAdapter(child: Text('Label 2')),
|
|
SliverCrossAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverToBoxAdapter(child: Text('Label 3')),
|
|
SliverToBoxAdapter(child: Text('Label 4')),
|
|
SliverToBoxAdapter(child: Text('Label 5')),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(semanticsUpdateCount, 1);
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Label 1', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'Label 2', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'Label 3', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'Label 4', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'Label 5', textDirection: TextDirection.ltr),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('Can change handlers', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasTapAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onDismiss: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasDismissAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onLongPress: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasLongPressAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onScrollLeft: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasScrollLeftAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onScrollRight: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasScrollRightAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onScrollUp: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasScrollUpAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onScrollDown: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasScrollDownAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onIncrease: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasIncreaseAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onDecrease: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasDecreaseAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onCopy: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasCopyAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onCut: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasCutAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onPaste: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasPasteAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onSetSelection: (TextSelection _) {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', hasSetSelectionAction: true, textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onDidGainAccessibilityFocus: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(
|
|
label: 'foo',
|
|
hasDidGainAccessibilityFocusAction: true,
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
onDidLoseAccessibilityFocus: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(
|
|
label: 'foo',
|
|
hasDidLoseAccessibilityFocusAction: true,
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
container: true,
|
|
label: 'foo',
|
|
textDirection: TextDirection.ltr,
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
tester.getSemantics(find.bySemanticsLabel('foo')),
|
|
matchesSemantics(label: 'foo', textDirection: TextDirection.ltr),
|
|
);
|
|
});
|
|
|
|
testWidgets('blocking user interaction works on explicit child node', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final key1 = UniqueKey();
|
|
final key2 = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
blockUserActions: true,
|
|
explicitChildNodes: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key1,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
key: key2,
|
|
label: 'label2',
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key1)),
|
|
// Tap action is blocked.
|
|
matchesSemantics(label: 'label1'),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key2)),
|
|
// Tap action is blocked.
|
|
matchesSemantics(label: 'label2'),
|
|
);
|
|
});
|
|
|
|
testWidgets('blocking user interaction works on explicit child node with Semantics widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final key1 = UniqueKey();
|
|
final key2 = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
blockUserActions: true,
|
|
explicitChildNodes: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(
|
|
key: key1,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
child: const SizedBox(height: 10),
|
|
),
|
|
Semantics(
|
|
key: key2,
|
|
label: 'label2',
|
|
onTap: () {},
|
|
child: const SizedBox(height: 10),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key1)),
|
|
// Tap action is blocked.
|
|
matchesSemantics(label: 'label1'),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key2)),
|
|
// Tap action is blocked.
|
|
matchesSemantics(label: 'label2'),
|
|
);
|
|
});
|
|
|
|
testWidgets('blocking user interaction on a merged child', (WidgetTester tester) async {
|
|
final key = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
blockUserActions: true,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
label: 'label2',
|
|
onLongPress: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key)),
|
|
// Tap action in label1 is blocked.
|
|
matchesSemantics(label: 'label1\nlabel2', hasLongPressAction: true),
|
|
);
|
|
});
|
|
|
|
testWidgets('blocking user interaction on a merged child with Semantics widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final key = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
sliver: SliverList.list(
|
|
children: <Widget>[
|
|
Semantics(
|
|
blockUserActions: true,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
child: const SizedBox(height: 10),
|
|
),
|
|
Semantics(label: 'label2', onLongPress: () {}, child: const SizedBox(height: 10)),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(
|
|
tester.getSemantics(find.byKey(key)),
|
|
// Tap action in label1 is blocked.
|
|
matchesSemantics(label: 'label1\nlabel2', hasLongPressAction: true),
|
|
);
|
|
});
|
|
|
|
testWidgets('does not merge conflicting actions even if one of them is blocked', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final key = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
sliver: SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
blockUserActions: true,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
SliverSemantics(
|
|
label: 'label2',
|
|
onTap: () {},
|
|
sliver: const SliverToBoxAdapter(child: SizedBox(height: 10.0)),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final SemanticsNode node = tester.getSemantics(find.byKey(key));
|
|
expect(
|
|
node,
|
|
matchesSemantics(
|
|
children: <Matcher>[
|
|
isSemantics(label: 'label1'),
|
|
isSemantics(label: 'label2'),
|
|
],
|
|
),
|
|
);
|
|
});
|
|
|
|
testWidgets(
|
|
'does not merge conflicting actions even if one of them is blocked with Semantics widget',
|
|
(WidgetTester tester) async {
|
|
final key = UniqueKey();
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
container: true,
|
|
sliver: SliverToBoxAdapter(
|
|
child: Column(
|
|
children: <Widget>[
|
|
Semantics(
|
|
blockUserActions: true,
|
|
label: 'label1',
|
|
onTap: () {},
|
|
child: const SizedBox(width: 10, height: 10),
|
|
),
|
|
Semantics(
|
|
label: 'label2',
|
|
onTap: () {},
|
|
child: const SizedBox(width: 10, height: 10),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final SemanticsNode node = tester.getSemantics(find.byKey(key));
|
|
expect(
|
|
node,
|
|
matchesSemantics(
|
|
children: <Matcher>[
|
|
isSemantics(label: 'label1'),
|
|
isSemantics(label: 'label2'),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
);
|
|
|
|
testWidgets('RenderSliverSemanticsAnnotations provides validation result', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
Future<SemanticsConfiguration> pumpValidationResult(SemanticsValidationResult result) async {
|
|
final key = ValueKey<String>('validation-$result');
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
validationResult: result,
|
|
sliver: SliverToBoxAdapter(
|
|
child: Text('Validation result $result', textDirection: TextDirection.ltr),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final RenderSliverSemanticsAnnotations object = tester
|
|
.renderObject<RenderSliverSemanticsAnnotations>(find.byKey(key));
|
|
final config = SemanticsConfiguration();
|
|
object.describeSemanticsConfiguration(config);
|
|
return config;
|
|
}
|
|
|
|
final SemanticsConfiguration noneResult = await pumpValidationResult(
|
|
SemanticsValidationResult.none,
|
|
);
|
|
expect(noneResult.validationResult, SemanticsValidationResult.none);
|
|
|
|
final SemanticsConfiguration validResult = await pumpValidationResult(
|
|
SemanticsValidationResult.valid,
|
|
);
|
|
expect(validResult.validationResult, SemanticsValidationResult.valid);
|
|
|
|
final SemanticsConfiguration invalidResult = await pumpValidationResult(
|
|
SemanticsValidationResult.invalid,
|
|
);
|
|
expect(invalidResult.validationResult, SemanticsValidationResult.invalid);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('validation result precedence', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
Future<void> expectValidationResult({
|
|
required SemanticsValidationResult outer,
|
|
required SemanticsValidationResult inner,
|
|
required SemanticsValidationResult expected,
|
|
}) async {
|
|
const key = ValueKey<String>('validated-widget');
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
validationResult: outer,
|
|
sliver: SliverSemantics(
|
|
validationResult: inner,
|
|
sliver: SliverToBoxAdapter(
|
|
child: Text(
|
|
key: key,
|
|
'Outer = $outer; inner = $inner',
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final SemanticsNode result = tester.getSemantics(find.byKey(key));
|
|
expect(
|
|
result,
|
|
isSemantics(label: 'Outer = $outer; inner = $inner', validationResult: expected),
|
|
);
|
|
}
|
|
|
|
// Outer is none.
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.none,
|
|
inner: SemanticsValidationResult.none,
|
|
expected: SemanticsValidationResult.none,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.none,
|
|
inner: SemanticsValidationResult.valid,
|
|
expected: SemanticsValidationResult.valid,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.none,
|
|
inner: SemanticsValidationResult.invalid,
|
|
expected: SemanticsValidationResult.invalid,
|
|
);
|
|
|
|
// Outer is valid.
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.valid,
|
|
inner: SemanticsValidationResult.none,
|
|
expected: SemanticsValidationResult.valid,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.valid,
|
|
inner: SemanticsValidationResult.valid,
|
|
expected: SemanticsValidationResult.valid,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.valid,
|
|
inner: SemanticsValidationResult.invalid,
|
|
expected: SemanticsValidationResult.invalid,
|
|
);
|
|
|
|
// Outer is invalid.
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.invalid,
|
|
inner: SemanticsValidationResult.none,
|
|
expected: SemanticsValidationResult.invalid,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.invalid,
|
|
inner: SemanticsValidationResult.valid,
|
|
expected: SemanticsValidationResult.invalid,
|
|
);
|
|
await expectValidationResult(
|
|
outer: SemanticsValidationResult.invalid,
|
|
inner: SemanticsValidationResult.invalid,
|
|
expected: SemanticsValidationResult.invalid,
|
|
);
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('supports heading levels', (WidgetTester tester) async {
|
|
// Default: not a heading.
|
|
expect(
|
|
SliverSemantics(
|
|
sliver: const SliverToBoxAdapter(child: Text('dummy text')),
|
|
).properties.headingLevel,
|
|
isNull,
|
|
);
|
|
|
|
// Headings level 1-6.
|
|
for (var level = 1; level <= 6; level++) {
|
|
final semantics = SliverSemantics(
|
|
headingLevel: level,
|
|
sliver: const SliverToBoxAdapter(child: Text('dummy text')),
|
|
);
|
|
expect(semantics.properties.headingLevel, level);
|
|
}
|
|
|
|
// Invalid heading levels.
|
|
for (final badLevel in const <int>[-1, 0, 7, 8, 9]) {
|
|
expect(
|
|
() => SliverSemantics(
|
|
headingLevel: badLevel,
|
|
sliver: const SliverToBoxAdapter(child: Text('dummy text')),
|
|
),
|
|
throwsAssertionError,
|
|
);
|
|
}
|
|
});
|
|
|
|
testWidgets('parent heading level takes precedence when it absorbs a child', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
Future<SemanticsConfiguration> pumpHeading(int? level) async {
|
|
final key = ValueKey<String>('heading-$level');
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverSemantics(
|
|
key: key,
|
|
headingLevel: level,
|
|
sliver: SliverToBoxAdapter(
|
|
child: Text('Heading level $level', textDirection: TextDirection.ltr),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
final RenderSliverSemanticsAnnotations object = tester
|
|
.renderObject<RenderSliverSemanticsAnnotations>(find.byKey(key));
|
|
final config = SemanticsConfiguration();
|
|
object.describeSemanticsConfiguration(config);
|
|
return config;
|
|
}
|
|
|
|
// Tuples contain (parent level, child level, expected combined level).
|
|
final scenarios = <(int, int, int)>[
|
|
// Case: neither are headings
|
|
(0, 0, 0), // expect not a heading
|
|
// Case: parent not a heading, child always wins.
|
|
(0, 1, 1),
|
|
(0, 2, 2),
|
|
|
|
// Case: child not a heading, parent always wins.
|
|
(1, 0, 1),
|
|
(2, 0, 2),
|
|
|
|
// Case: child heading level higher, parent still wins.
|
|
(3, 2, 3),
|
|
(4, 1, 4),
|
|
|
|
// Case: parent heading level higher, parent still wins.
|
|
(2, 3, 2),
|
|
(1, 5, 1),
|
|
];
|
|
|
|
for (final scenario in scenarios) {
|
|
final int parentLevel = scenario.$1;
|
|
final int childLevel = scenario.$2;
|
|
final int resultLevel = scenario.$3;
|
|
|
|
final SemanticsConfiguration parent = await pumpHeading(
|
|
parentLevel == 0 ? null : parentLevel,
|
|
);
|
|
final child = SemanticsConfiguration()..headingLevel = childLevel;
|
|
parent.absorb(child);
|
|
expect(
|
|
reason:
|
|
'parent heading level is $parentLevel, '
|
|
'child heading level is $childLevel, '
|
|
'expecting $resultLevel.',
|
|
parent.headingLevel,
|
|
resultLevel,
|
|
);
|
|
}
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('applies heading semantics to semantics tree', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
for (int level = 1; level <= 6; level++)
|
|
SliverSemantics(
|
|
key: ValueKey<String>('heading-$level'),
|
|
headingLevel: level,
|
|
sliver: SliverToBoxAdapter(child: Text('Heading level $level')),
|
|
),
|
|
const SliverToBoxAdapter(child: Text('This is not a heading')),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
for (var level = 1; level <= 6; level++) {
|
|
final key = ValueKey<String>('heading-$level');
|
|
final SemanticsNode node = tester.getSemantics(find.byKey(key));
|
|
expect('$node', contains('headingLevel: $level'));
|
|
}
|
|
|
|
final SemanticsNode notHeading = tester.getSemantics(find.text('This is not a heading'));
|
|
expect(notHeading, isNot(contains('headingLevel')));
|
|
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('sliver with zero transform gets dropped', (WidgetTester tester) async {
|
|
// Regression test for https://github.com/flutter/flutter/issues/110671.
|
|
// Construct a widget tree that will end up with a fitted box that applies
|
|
// a zero transform because it does not actually draw its children.
|
|
// Assert that this subtree gets dropped (the root node has no children).
|
|
final semantics = SemanticsTester(tester);
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
const SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
SliverToBoxAdapter(
|
|
child: SizedBox(
|
|
height: 0,
|
|
width: 500,
|
|
child: FittedBox(
|
|
child: SizedBox(
|
|
height: 55,
|
|
width: 266,
|
|
child: SingleChildScrollView(child: Column()),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling]),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
final SemanticsNode node = RendererBinding.instance.renderView.debugSemantics!;
|
|
|
|
expect(node.transform, null); // Make sure the zero transform didn't end up on the root somehow.
|
|
expect(node.childrenCount, 1);
|
|
semantics.dispose();
|
|
});
|
|
|
|
testWidgets('slivers that are transformed are sorted properly', (WidgetTester tester) async {
|
|
final semantics = SemanticsTester(tester);
|
|
var semanticsUpdateCount = 0;
|
|
tester.binding.pipelineOwner.semanticsOwner!.addListener(() {
|
|
semanticsUpdateCount += 1;
|
|
});
|
|
await tester.pumpWidget(
|
|
boilerPlate(
|
|
slivers: <Widget>[
|
|
SliverMainAxisGroup(
|
|
slivers: <Widget>[
|
|
const SliverToBoxAdapter(child: Text('Label 1')),
|
|
const SliverToBoxAdapter(child: Text('Label 2')),
|
|
SliverToBoxAdapter(
|
|
child: Transform.rotate(
|
|
angle: pi / 2.0,
|
|
child: const Row(
|
|
children: <Widget>[Text('Label 3'), Text('Label 4'), Text('Label 5')],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
expect(semanticsUpdateCount, 1);
|
|
// Label 3 is off-screen so it gets dropped.
|
|
final expectedSemantics = TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
children: <TestSemantics>[
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.hasImplicitScrolling],
|
|
children: <TestSemantics>[
|
|
TestSemantics(label: 'Label 1', textDirection: TextDirection.ltr),
|
|
TestSemantics(label: 'Label 2', textDirection: TextDirection.ltr),
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.isHidden],
|
|
label: 'Label 4',
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
TestSemantics(
|
|
flags: <SemanticsFlag>[SemanticsFlag.isHidden],
|
|
label: 'Label 5',
|
|
textDirection: TextDirection.ltr,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
expect(
|
|
semantics,
|
|
hasSemantics(expectedSemantics, ignoreId: true, ignoreRect: true, ignoreTransform: true),
|
|
);
|
|
|
|
semantics.dispose();
|
|
});
|
|
}
|
|
|
|
class CustomSortKey extends OrdinalSortKey {
|
|
const CustomSortKey(super.order, {super.name});
|
|
}
|