blob: d94447521a0005bb6984c11da6c89e330ed113d8 [file] [log] [blame]
// 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' show SemanticsFlag;
import 'package:flutter/foundation.dart';
import 'package:flutter/physics.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:meta/meta.dart';
export 'dart:ui' show SemanticsFlag, SemanticsAction;
export 'package:flutter/rendering.dart' show SemanticsData;
const String _matcherHelp = 'Try dumping the semantics with debugDumpSemanticsTree(DebugSemanticsDumpOrder.inverseHitTest) from the package:flutter/rendering.dart library to see what the semantics tree looks like.';
/// Test semantics data that is compared against real semantics tree.
///
/// Useful with [hasSemantics] and [SemanticsTester] to test the contents of the
/// semantics tree.
class TestSemantics {
/// Creates an object with some test semantics data.
///
/// The [id] field is required. The root node has an id of zero. Other nodes
/// are given a unique id when they are created, in a predictable fashion, and
/// so these values can be hard-coded.
///
/// The [rect] field is required and has no default. Convenient values are
/// available:
///
/// * [TestSemantics.rootRect]: 2400x1600, the test screen's size in physical
/// pixels, useful for the node with id zero.
///
/// * [TestSemantics.fullScreen] 800x600, the test screen's size in logical
/// pixels, useful for other full-screen widgets.
TestSemantics({
this.id,
this.flags = 0,
this.actions = 0,
this.label = '',
this.value = '',
this.increasedValue = '',
this.decreasedValue = '',
this.hint = '',
this.textDirection,
this.rect,
this.transform,
this.elevation,
this.thickness,
this.textSelection,
this.children = const <TestSemantics>[],
this.scrollIndex,
this.scrollChildren,
Iterable<SemanticsTag> tags,
}) : assert(flags is int || flags is List<SemanticsFlag>),
assert(actions is int || actions is List<SemanticsAction>),
assert(label != null),
assert(value != null),
assert(increasedValue != null),
assert(decreasedValue != null),
assert(hint != null),
assert(children != null),
tags = tags?.toSet() ?? <SemanticsTag>{};
/// Creates an object with some test semantics data, with the [id] and [rect]
/// set to the appropriate values for the root node.
TestSemantics.root({
this.flags = 0,
this.actions = 0,
this.label = '',
this.value = '',
this.increasedValue = '',
this.decreasedValue = '',
this.hint = '',
this.textDirection,
this.transform,
this.textSelection,
this.children = const <TestSemantics>[],
this.scrollIndex,
this.scrollChildren,
Iterable<SemanticsTag> tags,
}) : id = 0,
assert(flags is int || flags is List<SemanticsFlag>),
assert(actions is int || actions is List<SemanticsAction>),
assert(label != null),
assert(increasedValue != null),
assert(decreasedValue != null),
assert(value != null),
assert(hint != null),
rect = TestSemantics.rootRect,
elevation = 0.0,
thickness = 0.0,
assert(children != null),
tags = tags?.toSet() ?? <SemanticsTag>{};
/// Creates an object with some test semantics data, with the [id] and [rect]
/// set to the appropriate values for direct children of the root node.
///
/// The [transform] is set to a 3.0 scale (to account for the
/// [Window.devicePixelRatio] being 3.0 on the test pseudo-device).
///
/// The [rect] field is required and has no default. The
/// [TestSemantics.fullScreen] property may be useful as a value; it describes
/// an 800x600 rectangle, which is the test screen's size in logical pixels.
TestSemantics.rootChild({
this.id,
this.flags = 0,
this.actions = 0,
this.label = '',
this.hint = '',
this.value = '',
this.increasedValue = '',
this.decreasedValue = '',
this.textDirection,
this.rect,
Matrix4 transform,
this.elevation,
this.thickness,
this.textSelection,
this.children = const <TestSemantics>[],
this.scrollIndex,
this.scrollChildren,
Iterable<SemanticsTag> tags,
}) : assert(flags is int || flags is List<SemanticsFlag>),
assert(actions is int || actions is List<SemanticsAction>),
assert(label != null),
assert(value != null),
assert(increasedValue != null),
assert(decreasedValue != null),
assert(hint != null),
transform = _applyRootChildScale(transform),
assert(children != null),
tags = tags?.toSet() ?? <SemanticsTag>{};
/// The unique identifier for this node.
///
/// The root node has an id of zero. Other nodes are given a unique id when
/// they are created.
final int id;
/// The [SemanticsFlag]s set on this node.
///
/// There are two ways to specify this property: as an `int` that encodes the
/// flags as a bit field, or as a `List<SemanticsFlag>` that are _on_.
///
/// Using `List<SemanticsFlag>` is recommended due to better readability.
final dynamic flags;
/// The [SemanticsAction]s set on this node.
///
/// There are two ways to specify this property: as an `int` that encodes the
/// actions as a bit field, or as a `List<SemanticsAction>`.
///
/// Using `List<SemanticsAction>` is recommended due to better readability.
///
/// The tester does not check the function corresponding to the action, but
/// only its existence.
final dynamic actions;
/// A textual description of this node.
final String label;
/// A textual description for the value of this node.
final String value;
/// What [value] will become after [SemanticsAction.increase] has been
/// performed.
final String increasedValue;
/// What [value] will become after [SemanticsAction.decrease] has been
/// performed.
final String decreasedValue;
/// A brief textual description of the result of the action that can be
/// performed on this node.
final String hint;
/// The reading direction of the [label].
///
/// Even if this is not set, the [hasSemantics] matcher will verify that if a
/// label is present on the [SemanticsNode], a [SemanticsNode.textDirection]
/// is also set.
final TextDirection textDirection;
/// The bounding box for this node in its coordinate system.
///
/// Convenient values are available:
///
/// * [TestSemantics.rootRect]: 2400x1600, the test screen's size in physical
/// pixels, useful for the node with id zero.
///
/// * [TestSemantics.fullScreen] 800x600, the test screen's size in logical
/// pixels, useful for other full-screen widgets.
final Rect rect;
/// The test screen's size in physical pixels, typically used as the [rect]
/// for the node with id zero.
///
/// See also:
///
/// * [new TestSemantics.root], which uses this value to describe the root
/// node.
static const Rect rootRect = Rect.fromLTWH(0.0, 0.0, 2400.0, 1800.0);
/// The test screen's size in logical pixels, useful for the [rect] of
/// full-screen widgets other than the root node.
static const Rect fullScreen = Rect.fromLTWH(0.0, 0.0, 800.0, 600.0);
/// The transform from this node's coordinate system to its parent's coordinate system.
///
/// By default, the transform is null, which represents the identity
/// transformation (i.e., that this node has the same coordinate system as its
/// parent).
final Matrix4 transform;
/// The elevation of this node relative to the parent node.
///
/// See also:
///
/// * [SemanticsConfiguration.elevation] for a detailed discussion regarding
/// elevation and semantics.
final double elevation;
/// The extend that this node occupies in z-direction starting at [elevation].
///
/// See also:
///
/// * [SemanticsConfiguration.thickness] for a more detailed definition.
final double thickness;
/// The index of the first visible semantic node within a scrollable.
final int scrollIndex;
/// The total number of semantic nodes within a scrollable.
final int scrollChildren;
final TextSelection textSelection;
static Matrix4 _applyRootChildScale(Matrix4 transform) {
final Matrix4 result = Matrix4.diagonal3Values(3.0, 3.0, 1.0);
if (transform != null)
result.multiply(transform);
return result;
}
/// The children of this node.
final List<TestSemantics> children;
/// The tags of this node.
final Set<SemanticsTag> tags;
bool _matches(
SemanticsNode node,
Map<dynamic, dynamic> matchState, {
bool ignoreRect = false,
bool ignoreTransform = false,
bool ignoreId = false,
DebugSemanticsDumpOrder childOrder = DebugSemanticsDumpOrder.inverseHitTest,
}) {
bool fail(String message) {
matchState[TestSemantics] = message;
return false;
}
if (node == null)
return fail('could not find node with id $id.');
if (!ignoreId && id != node.id)
return fail('expected node id $id but found id ${node.id}.');
final SemanticsData nodeData = node.getSemanticsData();
final int flagsBitmask = flags is int
? flags as int
: (flags as List<SemanticsFlag>).fold<int>(0, (int bitmask, SemanticsFlag flag) => bitmask | flag.index);
if (flagsBitmask != nodeData.flags)
return fail('expected node id $id to have flags $flags but found flags ${nodeData.flags}.');
final int actionsBitmask = actions is int
? actions as int
: (actions as List<SemanticsAction>).fold<int>(0, (int bitmask, SemanticsAction action) => bitmask | action.index);
if (actionsBitmask != nodeData.actions)
return fail('expected node id $id to have actions $actions but found actions ${nodeData.actions}.');
if (label != nodeData.label)
return fail('expected node id $id to have label "$label" but found label "${nodeData.label}".');
if (value != nodeData.value)
return fail('expected node id $id to have value "$value" but found value "${nodeData.value}".');
if (increasedValue != nodeData.increasedValue)
return fail('expected node id $id to have increasedValue "$increasedValue" but found value "${nodeData.increasedValue}".');
if (decreasedValue != nodeData.decreasedValue)
return fail('expected node id $id to have decreasedValue "$decreasedValue" but found value "${nodeData.decreasedValue}".');
if (hint != nodeData.hint)
return fail('expected node id $id to have hint "$hint" but found hint "${nodeData.hint}".');
if (textDirection != null && textDirection != nodeData.textDirection)
return fail('expected node id $id to have textDirection "$textDirection" but found "${nodeData.textDirection}".');
if ((nodeData.label != '' || nodeData.value != '' || nodeData.hint != '' || node.increasedValue != '' || node.decreasedValue != '') && nodeData.textDirection == null)
return fail('expected node id $id, which has a label, value, or hint, to have a textDirection, but it did not.');
if (!ignoreRect && rect != nodeData.rect)
return fail('expected node id $id to have rect $rect but found rect ${nodeData.rect}.');
if (!ignoreTransform && transform != nodeData.transform)
return fail('expected node id $id to have transform $transform but found transform:\n${nodeData.transform}.');
if (elevation != null && elevation != nodeData.elevation) {
return fail('expected node id $id to have elevation $elevation but found elevation:\n${nodeData.elevation}.');
}
if (thickness != null && thickness != nodeData.thickness) {
return fail('expected node id $id to have thickness $thickness but found thickness:\n${nodeData.thickness}.');
}
if (textSelection?.baseOffset != nodeData.textSelection?.baseOffset || textSelection?.extentOffset != nodeData.textSelection?.extentOffset) {
return fail('expected node id $id to have textSelection [${textSelection?.baseOffset}, ${textSelection?.end}] but found: [${nodeData.textSelection?.baseOffset}, ${nodeData.textSelection?.extentOffset}].');
}
if (scrollIndex != null && scrollIndex != nodeData.scrollIndex) {
return fail('expected node id $id to have scrollIndex $scrollIndex but found scrollIndex ${nodeData.scrollIndex}.');
}
if (scrollChildren != null && scrollChildren != nodeData.scrollChildCount) {
return fail('expected node id $id to have scrollIndex $scrollChildren but found scrollIndex ${nodeData.scrollChildCount}.');
}
final int childrenCount = node.mergeAllDescendantsIntoThisNode ? 0 : node.childrenCount;
if (children.length != childrenCount)
return fail('expected node id $id to have ${children.length} child${ children.length == 1 ? "" : "ren" } but found $childrenCount.');
if (children.isEmpty)
return true;
bool result = true;
final Iterator<TestSemantics> it = children.iterator;
for (final SemanticsNode child in node.debugListChildrenInOrder(childOrder)) {
it.moveNext();
final bool childMatches = it.current._matches(
child,
matchState,
ignoreRect: ignoreRect,
ignoreTransform: ignoreTransform,
ignoreId: ignoreId,
childOrder: childOrder,
);
if (!childMatches) {
result = false;
return false;
}
}
if (it.moveNext()) {
return false;
}
return result;
}
@override
String toString([ int indentAmount = 0 ]) {
final String indent = ' ' * indentAmount;
final StringBuffer buf = StringBuffer();
buf.writeln('$indent$runtimeType(');
if (id != null)
buf.writeln('$indent id: $id,');
if (flags is int && flags != 0 || flags is List<SemanticsFlag> && (flags as List<SemanticsFlag>).isNotEmpty)
buf.writeln('$indent flags: ${SemanticsTester._flagsToSemanticsFlagExpression(flags)},');
if (actions is int && actions != 0 || actions is List<SemanticsAction> && (actions as List<SemanticsAction>).isNotEmpty)
buf.writeln('$indent actions: ${SemanticsTester._actionsToSemanticsActionExpression(actions)},');
if (label != null && label != '')
buf.writeln("$indent label: '$label',");
if (value != null && value != '')
buf.writeln("$indent value: '$value',");
if (increasedValue != null && increasedValue != '')
buf.writeln("$indent increasedValue: '$increasedValue',");
if (decreasedValue != null && decreasedValue != '')
buf.writeln("$indent decreasedValue: '$decreasedValue',");
if (hint != null && hint != '')
buf.writeln("$indent hint: '$hint',");
if (textDirection != null)
buf.writeln('$indent textDirection: $textDirection,');
if (textSelection?.isValid == true)
buf.writeln('$indent textSelection:\n[${textSelection.start}, ${textSelection.end}],');
if (scrollIndex != null)
buf.writeln('$indent scrollIndex: $scrollIndex,');
if (rect != null)
buf.writeln('$indent rect: $rect,');
if (transform != null)
buf.writeln('$indent transform:\n${transform.toString().trim().split('\n').map<String>((String line) => '$indent $line').join('\n')},');
if (elevation != null)
buf.writeln('$indent elevation: $elevation,');
if (thickness != null)
buf.writeln('$indent thickness: $thickness,');
buf.writeln('$indent children: <TestSemantics>[');
for (final TestSemantics child in children) {
buf.writeln('${child.toString(indentAmount + 2)},');
}
buf.writeln('$indent ],');
buf.write('$indent)');
return buf.toString();
}
}
/// Ensures that the given widget tester has a semantics tree to test.
///
/// Useful with [hasSemantics] to test the contents of the semantics tree.
class SemanticsTester {
/// Creates a semantics tester for the given widget tester.
///
/// You should call [dispose] at the end of a test that creates a semantics
/// tester.
SemanticsTester(this.tester) {
_semanticsHandle = tester.binding.pipelineOwner.ensureSemantics();
// This _extra_ clean-up is needed for the case when a test fails and
// therefore fails to call dispose() explicitly. The test is still required
// to call dispose() explicitly, because the semanticsOwner check is
// performed irrespective of whether the owner was created via
// SemanticsTester or directly. When the test succeeds, this tear-down
// becomes a no-op.
addTearDown(dispose);
}
/// The widget tester that this object is testing the semantics of.
final WidgetTester tester;
SemanticsHandle _semanticsHandle;
/// Release resources held by this semantics tester.
///
/// Call this function at the end of any test that uses a semantics tester. It
/// is OK to call this function multiple times. If the resources have already
/// been released, the subsequent calls have no effect.
@mustCallSuper
void dispose() {
_semanticsHandle?.dispose();
_semanticsHandle = null;
}
@override
String toString() => 'SemanticsTester for ${tester.binding.pipelineOwner.semanticsOwner?.rootSemanticsNode}';
/// Returns all semantics nodes in the current semantics tree whose properties
/// match the non-null arguments.
///
/// If multiple arguments are non-null, each of the returned nodes must match
/// on all of them.
///
/// If `ancestor` is not null, only the descendants of it are returned.
Iterable<SemanticsNode> nodesWith({
String label,
String value,
String hint,
TextDirection textDirection,
List<SemanticsAction> actions,
List<SemanticsFlag> flags,
double scrollPosition,
double scrollExtentMax,
double scrollExtentMin,
int currentValueLength,
int maxValueLength,
SemanticsNode ancestor,
}) {
bool checkNode(SemanticsNode node) {
if (label != null && node.label != label)
return false;
if (value != null && node.value != value)
return false;
if (hint != null && node.hint != hint)
return false;
if (textDirection != null && node.textDirection != textDirection)
return false;
if (actions != null) {
final int expectedActions = actions.fold<int>(0, (int value, SemanticsAction action) => value | action.index);
final int actualActions = node.getSemanticsData().actions;
if (expectedActions != actualActions)
return false;
}
if (flags != null) {
final int expectedFlags = flags.fold<int>(0, (int value, SemanticsFlag flag) => value | flag.index);
final int actualFlags = node.getSemanticsData().flags;
if (expectedFlags != actualFlags)
return false;
}
if (scrollPosition != null && !nearEqual(node.scrollPosition, scrollPosition, 0.1))
return false;
if (scrollExtentMax != null && !nearEqual(node.scrollExtentMax, scrollExtentMax, 0.1))
return false;
if (scrollExtentMin != null && !nearEqual(node.scrollExtentMin, scrollExtentMin, 0.1))
return false;
if (currentValueLength != null && node.currentValueLength != currentValueLength) {
return false;
}
if (maxValueLength != null && node.maxValueLength != maxValueLength) {
return false;
}
return true;
}
final List<SemanticsNode> result = <SemanticsNode>[];
bool visit(SemanticsNode node) {
if (checkNode(node)) {
result.add(node);
}
node.visitChildren(visit);
return true;
}
if (ancestor != null) {
visit(ancestor);
} else {
visit(tester.binding.pipelineOwner.semanticsOwner.rootSemanticsNode);
}
return result;
}
/// Generates an expression that creates a [TestSemantics] reflecting the
/// current tree of [SemanticsNode]s.
///
/// Use this method to generate code for unit tests. It works similar to
/// screenshot testing. The very first time you add semantics to a widget you
/// verify manually that the widget behaves correctly. You then use this
/// method to generate test code for this widget.
///
/// Example:
///
/// ```dart
/// testWidgets('generate code for MyWidget', (WidgetTester tester) async {
/// var semantics = SemanticsTester(tester);
/// await tester.pumpWidget(MyWidget());
/// print(semantics.generateTestSemanticsExpressionForCurrentSemanticsTree());
/// semantics.dispose();
/// });
/// ```
///
/// You can now copy the code printed to the console into a unit test:
///
/// ```dart
/// testWidgets('generate code for MyWidget', (WidgetTester tester) async {
/// var semantics = SemanticsTester(tester);
/// await tester.pumpWidget(MyWidget());
/// expect(semantics, hasSemantics(
/// // Generated code:
/// TestSemantics(
/// ... properties and child nodes ...
/// ),
/// ignoreRect: true,
/// ignoreTransform: true,
/// ignoreId: true,
/// ));
/// semantics.dispose();
/// });
/// ```
///
/// At this point the unit test should automatically pass because it was
/// generated from the actual [SemanticsNode]s. Next time the semantics tree
/// changes, the test code may either be updated manually, or regenerated and
/// replaced using this method again.
///
/// Avoid submitting huge piles of generated test code. This will make test
/// code hard to review and it will make it tempting to regenerate test code
/// every time and ignore potential regressions. Make sure you do not
/// over-test. Prefer breaking your widgets into smaller widgets and test them
/// individually.
String generateTestSemanticsExpressionForCurrentSemanticsTree(DebugSemanticsDumpOrder childOrder) {
final SemanticsNode node = tester.binding.pipelineOwner.semanticsOwner?.rootSemanticsNode;
return _generateSemanticsTestForNode(node, 0, childOrder);
}
static String _flagsToSemanticsFlagExpression(dynamic flags) {
Iterable<SemanticsFlag> list;
if (flags is int) {
list = SemanticsFlag.values.values
.where((SemanticsFlag flag) => (flag.index & flags) != 0);
} else {
list = flags as List<SemanticsFlag>;
}
return '<SemanticsFlag>[${list.join(', ')}]';
}
static String _tagsToSemanticsTagExpression(Set<SemanticsTag> tags) {
return '<SemanticsTag>[${tags.map<String>((SemanticsTag tag) => "const SemanticsTag('${tag.name}')").join(', ')}]';
}
static String _actionsToSemanticsActionExpression(dynamic actions) {
Iterable<SemanticsAction> list;
if (actions is int) {
list = SemanticsAction.values.values
.where((SemanticsAction action) => (action.index & actions) != 0);
} else {
list = actions as List<SemanticsAction>;
}
return '<SemanticsAction>[${list.join(', ')}]';
}
/// Recursively generates [TestSemantics] code for [node] and its children,
/// indenting the expression by `indentAmount`.
static String _generateSemanticsTestForNode(SemanticsNode node, int indentAmount, DebugSemanticsDumpOrder childOrder) {
if (node == null)
return 'null';
final String indent = ' ' * indentAmount;
final StringBuffer buf = StringBuffer();
final SemanticsData nodeData = node.getSemanticsData();
final bool isRoot = node.id == 0;
buf.writeln('TestSemantics${isRoot ? '.root': ''}(');
if (!isRoot)
buf.writeln(' id: ${node.id},');
if (nodeData.tags != null)
buf.writeln(' tags: ${_tagsToSemanticsTagExpression(nodeData.tags)},');
if (nodeData.flags != 0)
buf.writeln(' flags: ${_flagsToSemanticsFlagExpression(nodeData.flags)},');
if (nodeData.actions != 0)
buf.writeln(' actions: ${_actionsToSemanticsActionExpression(nodeData.actions)},');
if (node.label != null && node.label.isNotEmpty) {
final String escapedLabel = node.label.replaceAll('\n', r'\n');
if (escapedLabel != node.label) {
buf.writeln(" label: r'$escapedLabel',");
} else {
buf.writeln(" label: '$escapedLabel',");
}
}
if (node.value != null && node.value.isNotEmpty)
buf.writeln(" value: '${node.value}',");
if (node.increasedValue != null && node.increasedValue.isNotEmpty)
buf.writeln(" increasedValue: '${node.increasedValue}',");
if (node.decreasedValue != null && node.decreasedValue.isNotEmpty)
buf.writeln(" decreasedValue: '${node.decreasedValue}',");
if (node.hint != null && node.hint.isNotEmpty)
buf.writeln(" hint: '${node.hint}',");
if (node.textDirection != null)
buf.writeln(' textDirection: ${node.textDirection},');
if (node.hasChildren) {
buf.writeln(' children: <TestSemantics>[');
for (final SemanticsNode child in node.debugListChildrenInOrder(childOrder)) {
buf
..write(_generateSemanticsTestForNode(child, 2, childOrder))
..writeln(',');
}
buf.writeln(' ],');
}
buf.write(')');
return buf.toString().split('\n').map<String>((String l) => '$indent$l').join('\n');
}
}
class _HasSemantics extends Matcher {
const _HasSemantics(
this._semantics, {
@required this.ignoreRect,
@required this.ignoreTransform,
@required this.ignoreId,
@required this.childOrder,
}) : assert(_semantics != null),
assert(ignoreRect != null),
assert(ignoreId != null),
assert(ignoreTransform != null),
assert(childOrder != null);
final TestSemantics _semantics;
final bool ignoreRect;
final bool ignoreTransform;
final bool ignoreId;
final DebugSemanticsDumpOrder childOrder;
@override
bool matches(covariant SemanticsTester item, Map<dynamic, dynamic> matchState) {
final bool doesMatch = _semantics._matches(
item.tester.binding.pipelineOwner.semanticsOwner?.rootSemanticsNode,
matchState,
ignoreTransform: ignoreTransform,
ignoreRect: ignoreRect,
ignoreId: ignoreId,
childOrder: childOrder,
);
if (!doesMatch) {
matchState['would-match'] = item.generateTestSemanticsExpressionForCurrentSemanticsTree(childOrder);
}
if (item.tester.binding.pipelineOwner.semanticsOwner == null) {
matchState['additional-notes'] = '(Check that the SemanticsTester has not been disposed early.)';
}
return doesMatch;
}
@override
Description describe(Description description) {
return description.add('semantics node matching:\n$_semantics');
}
String _indent(String text) {
return text.toString().trimRight().split('\n').map<String>((String line) => ' $line').join('\n');
}
@override
Description describeMismatch(dynamic item, Description mismatchDescription, Map<dynamic, dynamic> matchState, bool verbose) {
Description result = mismatchDescription
.add('${matchState[TestSemantics]}\n')
.add('Current SemanticsNode tree:\n')
.add(_indent(RendererBinding.instance?.renderView?.debugSemantics?.toStringDeep(childOrder: childOrder)))
.add('\n')
.add('The semantics tree would have matched the following configuration:\n')
.add(_indent(matchState['would-match'] as String));
if (matchState.containsKey('additional-notes')) {
result = result
.add('\n')
.add(matchState['additional-notes'] as String);
}
return result;
}
}
/// Asserts that a [SemanticsTester] has a semantics tree that exactly matches the given semantics.
Matcher hasSemantics(
TestSemantics semantics, {
bool ignoreRect = false,
bool ignoreTransform = false,
bool ignoreId = false,
DebugSemanticsDumpOrder childOrder = DebugSemanticsDumpOrder.traversalOrder,
}) {
return _HasSemantics(
semantics,
ignoreRect: ignoreRect,
ignoreTransform: ignoreTransform,
ignoreId: ignoreId,
childOrder: childOrder,
);
}
class _IncludesNodeWith extends Matcher {
const _IncludesNodeWith({
this.label,
this.value,
this.hint,
this.textDirection,
this.actions,
this.flags,
this.scrollPosition,
this.scrollExtentMax,
this.scrollExtentMin,
this.maxValueLength,
this.currentValueLength,
}) : assert(
label != null ||
value != null ||
actions != null ||
flags != null ||
scrollPosition != null ||
scrollExtentMax != null ||
scrollExtentMin != null ||
maxValueLength != null ||
currentValueLength != null
);
final String label;
final String value;
final String hint;
final TextDirection textDirection;
final List<SemanticsAction> actions;
final List<SemanticsFlag> flags;
final double scrollPosition;
final double scrollExtentMax;
final double scrollExtentMin;
final int currentValueLength;
final int maxValueLength;
@override
bool matches(covariant SemanticsTester item, Map<dynamic, dynamic> matchState) {
return item.nodesWith(
label: label,
value: value,
hint: hint,
textDirection: textDirection,
actions: actions,
flags: flags,
scrollPosition: scrollPosition,
scrollExtentMax: scrollExtentMax,
scrollExtentMin: scrollExtentMin,
currentValueLength: currentValueLength,
maxValueLength: maxValueLength,
).isNotEmpty;
}
@override
Description describe(Description description) {
return description.add('includes node with $_configAsString');
}
@override
Description describeMismatch(dynamic item, Description mismatchDescription, Map<dynamic, dynamic> matchState, bool verbose) {
return mismatchDescription.add('could not find node with $_configAsString.\n$_matcherHelp');
}
String get _configAsString {
final List<String> strings = <String>[
if (label != null) 'label "$label"',
if (value != null) 'value "$value"',
if (hint != null) 'hint "$hint"',
if (textDirection != null) ' (${describeEnum(textDirection)})',
if (actions != null) 'actions "${actions.join(', ')}"',
if (flags != null) 'flags "${flags.join(', ')}"',
if (scrollPosition != null) 'scrollPosition "$scrollPosition"',
if (scrollExtentMax != null) 'scrollExtentMax "$scrollExtentMax"',
if (scrollExtentMin != null) 'scrollExtentMin "$scrollExtentMin"',
if (currentValueLength != null) 'currentValueLength "$currentValueLength"',
if (maxValueLength != null) 'maxValueLength "$maxValueLength"',
];
return strings.join(', ');
}
}
/// Asserts that a node in the semantics tree of [SemanticsTester] has `label`,
/// `textDirection`, and `actions`.
///
/// If null is provided for an argument, it will match against any value.
Matcher includesNodeWith({
String label,
String value,
String hint,
TextDirection textDirection,
List<SemanticsAction> actions,
List<SemanticsFlag> flags,
double scrollPosition,
double scrollExtentMax,
double scrollExtentMin,
int maxValueLength,
int currentValueLength,
}) {
return _IncludesNodeWith(
label: label,
value: value,
hint: hint,
textDirection: textDirection,
actions: actions,
flags: flags,
scrollPosition: scrollPosition,
scrollExtentMax: scrollExtentMax,
scrollExtentMin: scrollExtentMin,
maxValueLength: maxValueLength,
currentValueLength: currentValueLength,
);
}