mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
b5f9612cac
This turns on order shuffling for all tests that don't fail with it on, marking those tests that do fail with a tag so that they will be run without shuffling on. To determine which tests fail with it on, I ran all the tests 100 times with different random shuffle seeds, and then also ran it with the date seeds from today until the end of July, and tagged all of the test suites (files) that fail, with a seed that caused them to fail.
862 lines
27 KiB
Dart
862 lines
27 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.
|
|
|
|
// TODO(gspencergoog): Remove this tag once this test's state leaks/test
|
|
// dependency have been fixed.
|
|
// https://github.com/flutter/flutter/issues/85160
|
|
// Fails with "flutter test --test-randomize-ordering-seed=456"
|
|
@Tags(<String>['no-shuffle'])
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/rendering.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
|
|
import '../rendering/mock_canvas.dart';
|
|
|
|
void main() {
|
|
|
|
// The "can be constructed" tests that follow are primarily to ensure that any
|
|
// animations started by the progress indicators are stopped at dispose() time.
|
|
|
|
testWidgets('LinearProgressIndicator(value: 0.0) can be constructed and has empty semantics by default', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: 0.0),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byType(LinearProgressIndicator)), matchesSemantics());
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator(value: null) can be constructed and has empty semantics by default', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.rtl,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: null),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byType(LinearProgressIndicator)), matchesSemantics());
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator custom minHeight', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: 0.25, minHeight: 2.0),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 2.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 2.0)),
|
|
);
|
|
|
|
// Same test, but using the theme
|
|
await tester.pumpWidget(
|
|
Theme(
|
|
data: ThemeData(
|
|
progressIndicatorTheme: const ProgressIndicatorThemeData(
|
|
linearMinHeight: 2.0,
|
|
),
|
|
),
|
|
child: const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 2.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 2.0)),
|
|
);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator paint (LTR)', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0)),
|
|
);
|
|
|
|
expect(tester.binding.transientCallbackCount, 0);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator paint (RTL)', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.rtl,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(150.0, 0.0, 200.0, 4.0)),
|
|
);
|
|
|
|
expect(tester.binding.transientCallbackCount, 0);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator indeterminate (LTR)', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
await tester.pump(const Duration(milliseconds: 300));
|
|
final double animationValue = const Interval(0.0, 750.0 / 1800.0, curve: Cubic(0.2, 0.0, 0.8, 1.0))
|
|
.transform(300.0 / 1800.0);
|
|
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: Rect.fromLTRB(0.0, 0.0, animationValue * 200.0, 4.0)),
|
|
);
|
|
|
|
expect(tester.binding.transientCallbackCount, 1);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator paint (RTL)', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.rtl,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
await tester.pump(const Duration(milliseconds: 300));
|
|
final double animationValue = const Interval(0.0, 750.0 / 1800.0, curve: Cubic(0.2, 0.0, 0.8, 1.0))
|
|
.transform(300.0 / 1800.0);
|
|
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: Rect.fromLTRB(200.0 - animationValue * 200.0, 0.0, 200.0, 4.0)),
|
|
);
|
|
|
|
expect(tester.binding.transientCallbackCount, 1);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator with colors', (WidgetTester tester) async {
|
|
// With valueColor & color provided
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(
|
|
value: 0.25,
|
|
backgroundColor: Colors.black,
|
|
color: Colors.blue,
|
|
valueColor: AlwaysStoppedAnimation<Color>(Colors.white),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
// Should use valueColor
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0), color: Colors.white),
|
|
);
|
|
|
|
// With just color provided
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(
|
|
value: 0.25,
|
|
backgroundColor: Colors.black,
|
|
color: Colors.white12,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
// Should use color
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0), color: Colors.white12),
|
|
);
|
|
|
|
// With no color provided
|
|
const Color primaryColor = Color(0xff008800);
|
|
final ThemeData theme = ThemeData(colorScheme: ColorScheme.fromSwatch().copyWith(primary: primaryColor));
|
|
await tester.pumpWidget(
|
|
Theme(
|
|
data: theme,
|
|
child: const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(
|
|
value: 0.25,
|
|
backgroundColor: Colors.black,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
// Should use the theme's primary color
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0), color: primaryColor),
|
|
);
|
|
|
|
// With ProgressIndicatorTheme colors
|
|
const Color indicatorColor = Color(0xff0000ff);
|
|
await tester.pumpWidget(
|
|
Theme(
|
|
data: ThemeData(
|
|
progressIndicatorTheme: const ProgressIndicatorThemeData(
|
|
color: indicatorColor,
|
|
linearTrackColor: Colors.black,
|
|
),
|
|
),
|
|
child: const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(
|
|
value: 0.25,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
// Should use the progress indicator theme colors
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0), color: indicatorColor),
|
|
);
|
|
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator with animation with null colors', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: LinearProgressIndicator(
|
|
value: 0.25,
|
|
valueColor: AlwaysStoppedAnimation<Color?>(null),
|
|
backgroundColor: Colors.black,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 200.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 50.0, 4.0)),
|
|
);
|
|
});
|
|
|
|
testWidgets('CircularProgressIndicator(value: 0.0) can be constructed and has value semantics by default', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: CircularProgressIndicator(value: 0.0),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byType(CircularProgressIndicator)), matchesSemantics(
|
|
value: '0%',
|
|
textDirection: TextDirection.ltr,
|
|
));
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('CircularProgressIndicator(value: null) can be constructed and has empty semantics by default', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
await tester.pumpWidget(
|
|
const Center(
|
|
child: CircularProgressIndicator(value: null),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byType(CircularProgressIndicator)), matchesSemantics());
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator causes a repaint when it changes', (WidgetTester tester) async {
|
|
await tester.pumpWidget(Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: ListView(children: const <Widget>[LinearProgressIndicator(value: 0.0)]),
|
|
));
|
|
final List<Layer> layers1 = tester.layers;
|
|
await tester.pumpWidget(Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: ListView(children: const <Widget>[LinearProgressIndicator(value: 0.5)]),
|
|
));
|
|
final List<Layer> layers2 = tester.layers;
|
|
expect(layers1, isNot(equals(layers2)));
|
|
});
|
|
|
|
testWidgets('CircularProgressIndicator stoke width', (WidgetTester tester) async {
|
|
await tester.pumpWidget(const CircularProgressIndicator());
|
|
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(strokeWidth: 4.0));
|
|
|
|
await tester.pumpWidget(const CircularProgressIndicator(strokeWidth: 16.0));
|
|
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(strokeWidth: 16.0));
|
|
});
|
|
|
|
testWidgets('CircularProgressIndicator paint colors', (WidgetTester tester) async {
|
|
const Color green = Color(0xFF00FF00);
|
|
const Color blue = Color(0xFF0000FF);
|
|
const Color red = Color(0xFFFF0000);
|
|
|
|
// With valueColor & color provided
|
|
await tester.pumpWidget(const CircularProgressIndicator(
|
|
color: red,
|
|
valueColor: AlwaysStoppedAnimation<Color>(blue),
|
|
));
|
|
expect(find.byType(CircularProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(color: blue));
|
|
|
|
// With just color provided
|
|
await tester.pumpWidget(const CircularProgressIndicator(
|
|
color: red,
|
|
));
|
|
expect(find.byType(CircularProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(color: red));
|
|
|
|
// With no color provided
|
|
await tester.pumpWidget(Theme(
|
|
data: ThemeData(colorScheme: ColorScheme.fromSwatch().copyWith(primary: green)),
|
|
child: const CircularProgressIndicator(),
|
|
));
|
|
expect(find.byType(CircularProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(color: green));
|
|
|
|
// With background
|
|
await tester.pumpWidget(const CircularProgressIndicator(
|
|
backgroundColor: green,
|
|
color: blue,
|
|
));
|
|
expect(find.byType(CircularProgressIndicator), paintsExactlyCountTimes(#drawArc, 2));
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(color: green)..arc(color: blue));
|
|
|
|
// With ProgressIndicatorTheme
|
|
await tester.pumpWidget(Theme(
|
|
data: ThemeData(progressIndicatorTheme: const ProgressIndicatorThemeData(
|
|
color: green,
|
|
circularTrackColor: blue,
|
|
)),
|
|
child: const CircularProgressIndicator(),
|
|
));
|
|
expect(find.byType(CircularProgressIndicator), paintsExactlyCountTimes(#drawArc, 2));
|
|
expect(find.byType(CircularProgressIndicator), paints..arc(color: blue)..arc(color: green));
|
|
});
|
|
|
|
testWidgets('RefreshProgressIndicator paint colors', (WidgetTester tester) async {
|
|
const Color green = Color(0xFF00FF00);
|
|
const Color blue = Color(0xFF0000FF);
|
|
const Color red = Color(0xFFFF0000);
|
|
|
|
// With valueColor & color provided
|
|
await tester.pumpWidget(const RefreshProgressIndicator(
|
|
color: red,
|
|
valueColor: AlwaysStoppedAnimation<Color>(blue),
|
|
));
|
|
expect(find.byType(RefreshProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(RefreshProgressIndicator), paints..arc(color: blue));
|
|
|
|
// With just color provided
|
|
await tester.pumpWidget(const RefreshProgressIndicator(
|
|
color: red,
|
|
));
|
|
expect(find.byType(RefreshProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(RefreshProgressIndicator), paints..arc(color: red));
|
|
|
|
// With no color provided
|
|
await tester.pumpWidget(Theme(
|
|
data: ThemeData(colorScheme: ColorScheme.fromSwatch().copyWith(primary: green)),
|
|
child: const RefreshProgressIndicator(),
|
|
));
|
|
expect(find.byType(RefreshProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(RefreshProgressIndicator), paints..arc(color: green));
|
|
|
|
// With background
|
|
await tester.pumpWidget(const RefreshProgressIndicator(
|
|
color: blue,
|
|
backgroundColor: green,
|
|
));
|
|
expect(find.byType(RefreshProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(RefreshProgressIndicator), paints..arc(color: blue));
|
|
final Material backgroundMaterial = tester.widget(find.descendant(
|
|
of: find.byType(RefreshProgressIndicator),
|
|
matching: find.byType(Material),
|
|
));
|
|
expect(backgroundMaterial.type, MaterialType.circle);
|
|
expect(backgroundMaterial.color, green);
|
|
|
|
// With ProgressIndicatorTheme
|
|
await tester.pumpWidget(Theme(
|
|
data: ThemeData(progressIndicatorTheme: const ProgressIndicatorThemeData(
|
|
color: green,
|
|
refreshBackgroundColor: blue,
|
|
)),
|
|
child: const RefreshProgressIndicator(),
|
|
));
|
|
expect(find.byType(RefreshProgressIndicator), paintsExactlyCountTimes(#drawArc, 1));
|
|
expect(find.byType(RefreshProgressIndicator), paints..arc(color: green));
|
|
final Material themeBackgroundMaterial = tester.widget(find.descendant(
|
|
of: find.byType(RefreshProgressIndicator),
|
|
matching: find.byType(Material),
|
|
));
|
|
expect(themeBackgroundMaterial.type, MaterialType.circle);
|
|
expect(themeBackgroundMaterial.color, blue);
|
|
});
|
|
|
|
testWidgets('Indeterminate RefreshProgressIndicator keeps spinning until end of time (approximate)', (WidgetTester tester) async {
|
|
// Regression test for https://github.com/flutter/flutter/issues/13782
|
|
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 200.0,
|
|
child: RefreshProgressIndicator(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
|
|
await tester.pump(const Duration(seconds: 5));
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
|
|
await tester.pump(const Duration(milliseconds: 1));
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
|
|
await tester.pump(const Duration(days: 9999));
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
});
|
|
|
|
testWidgets('Determinate CircularProgressIndicator stops the animator', (WidgetTester tester) async {
|
|
double? progressValue;
|
|
late StateSetter setState;
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: StatefulBuilder(
|
|
builder: (BuildContext context, StateSetter setter) {
|
|
setState = setter;
|
|
return CircularProgressIndicator(value: progressValue);
|
|
},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
|
|
setState(() { progressValue = 1.0; });
|
|
await tester.pump(const Duration(milliseconds: 1));
|
|
expect(tester.hasRunningAnimations, isFalse);
|
|
|
|
setState(() { progressValue = null; });
|
|
await tester.pump(const Duration(milliseconds: 1));
|
|
expect(tester.hasRunningAnimations, isTrue);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator with height 12.0', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 100.0,
|
|
height: 12.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 100.0, 12.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 25.0, 12.0)),
|
|
);
|
|
expect(tester.binding.transientCallbackCount, 0);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator with a height less than the minimum', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 100.0,
|
|
height: 3.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 100.0, 3.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 25.0, 3.0)),
|
|
);
|
|
expect(tester.binding.transientCallbackCount, 0);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator with default height', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Center(
|
|
child: SizedBox(
|
|
width: 100.0,
|
|
height: 4.0,
|
|
child: LinearProgressIndicator(value: 0.25),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
expect(
|
|
find.byType(LinearProgressIndicator),
|
|
paints
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 100.0, 4.0))
|
|
..rect(rect: const Rect.fromLTRB(0.0, 0.0, 25.0, 4.0)),
|
|
);
|
|
expect(tester.binding.transientCallbackCount, 0);
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator can be made accessible', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
const String label = 'Label';
|
|
const String value = '25%';
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: LinearProgressIndicator(
|
|
key: key,
|
|
value: 0.25,
|
|
semanticsLabel: label,
|
|
semanticsValue: value,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics(
|
|
textDirection: TextDirection.ltr,
|
|
label: label,
|
|
value: value,
|
|
));
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator that is determinate gets default a11y value', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
const String label = 'Label';
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: LinearProgressIndicator(
|
|
key: key,
|
|
value: 0.25,
|
|
semanticsLabel: label,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics(
|
|
textDirection: TextDirection.ltr,
|
|
label: label,
|
|
value: '25%',
|
|
));
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator that is determinate does not default a11y value when label is null', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: LinearProgressIndicator(
|
|
key: key,
|
|
value: 0.25,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics());
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('LinearProgressIndicator that is indeterminate does not default a11y value', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
const String label = 'Progress';
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: LinearProgressIndicator(
|
|
key: key,
|
|
value: 0.25,
|
|
semanticsLabel: label,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics(
|
|
textDirection: TextDirection.ltr,
|
|
label: label,
|
|
));
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('CircularProgressIndicator can be made accessible', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
const String label = 'Label';
|
|
const String value = '25%';
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: CircularProgressIndicator(
|
|
key: key,
|
|
value: 0.25,
|
|
semanticsLabel: label,
|
|
semanticsValue: value,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics(
|
|
textDirection: TextDirection.ltr,
|
|
label: label,
|
|
value: value,
|
|
));
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('RefreshProgressIndicator can be made accessible', (WidgetTester tester) async {
|
|
final SemanticsHandle handle = tester.ensureSemantics();
|
|
final GlobalKey key = GlobalKey();
|
|
const String label = 'Label';
|
|
const String value = '25%';
|
|
await tester.pumpWidget(
|
|
Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: RefreshProgressIndicator(
|
|
key: key,
|
|
semanticsLabel: label,
|
|
semanticsValue: value,
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(tester.getSemantics(find.byKey(key)), matchesSemantics(
|
|
textDirection: TextDirection.ltr,
|
|
label: label,
|
|
value: value,
|
|
));
|
|
|
|
handle.dispose();
|
|
});
|
|
|
|
testWidgets('Indeterminate CircularProgressIndicator uses expected animation', (WidgetTester tester) async {
|
|
final AnimationSheetBuilder animationSheet = AnimationSheetBuilder(frameSize: const Size(40, 40));
|
|
|
|
await tester.pumpFrames(animationSheet.record(
|
|
const Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: Padding(
|
|
padding: EdgeInsets.all(4),
|
|
child: CircularProgressIndicator(),
|
|
),
|
|
),
|
|
), const Duration(seconds: 2));
|
|
|
|
await expectLater(
|
|
await animationSheet.collate(20),
|
|
matchesGoldenFile('material.circular_progress_indicator.indeterminate.png'),
|
|
);
|
|
}, skip: isBrowser); // https://github.com/flutter/flutter/issues/42767
|
|
|
|
testWidgets(
|
|
'Adaptive CircularProgressIndicator displays CupertinoActivityIndicator in iOS',
|
|
(WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const MaterialApp(
|
|
home: Scaffold(
|
|
body: Material(
|
|
child: CircularProgressIndicator.adaptive(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(find.byType(CupertinoActivityIndicator), findsOneWidget);
|
|
},
|
|
variant: const TargetPlatformVariant(<TargetPlatform> {
|
|
TargetPlatform.iOS,
|
|
TargetPlatform.macOS,
|
|
}),
|
|
);
|
|
|
|
testWidgets(
|
|
'Adaptive CircularProgressIndicator does not display CupertinoActivityIndicator in non-iOS',
|
|
(WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
const MaterialApp(
|
|
home: Scaffold(
|
|
body: Material(
|
|
child: CircularProgressIndicator.adaptive(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(find.byType(CupertinoActivityIndicator), findsNothing);
|
|
},
|
|
variant: const TargetPlatformVariant(<TargetPlatform> {
|
|
TargetPlatform.android,
|
|
TargetPlatform.fuchsia,
|
|
TargetPlatform.windows,
|
|
TargetPlatform.linux,
|
|
}),
|
|
);
|
|
|
|
testWidgets('ProgressIndicatorTheme.wrap() always creates a new ProgressIndicatorTheme', (WidgetTester tester) async {
|
|
|
|
late BuildContext builderContext;
|
|
|
|
const ProgressIndicatorThemeData themeData = ProgressIndicatorThemeData(
|
|
color: Color(0xFFFF0000),
|
|
linearTrackColor: Color(0xFF00FF00),
|
|
);
|
|
|
|
final ProgressIndicatorTheme progressTheme = ProgressIndicatorTheme(
|
|
data: themeData,
|
|
child: Builder(
|
|
builder: (BuildContext context) {
|
|
builderContext = context;
|
|
return const LinearProgressIndicator(value: 0.5);
|
|
}
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(MaterialApp(
|
|
home: progressTheme,
|
|
));
|
|
final Widget wrappedTheme = progressTheme.wrap(builderContext, Container());
|
|
|
|
// Make sure the returned widget is a new ProgressIndicatorTheme instance
|
|
// with the same theme data as the original.
|
|
expect(wrappedTheme, isNot(equals(progressTheme)));
|
|
expect(wrappedTheme, isInstanceOf<ProgressIndicatorTheme>());
|
|
expect((wrappedTheme as ProgressIndicatorTheme).data, themeData);
|
|
});
|
|
}
|