Free tools Windows power users keep installed
One-click scans. No signup required.
Use unit tests for isolated Dart logic, widget tests for UI behavior, and integration tests for complete app flows and platform interactions. A reliable Flutter test suite uses all three where they provide useful confidence: Flutter recommends many unit and widget tests, plus integration tests for important use cases, rather than a single test type or a universal coverage target.
How do I choose the right Flutter test?
Start by asking what failure you need to catch. A function returning the wrong value belongs in a unit test; a button rendering incorrectly or failing to update the screen belongs in a widget test; a multi-part app flow belongs in an integration test. Flutter describes a unit test as testing “a single function, method, or class,” and says integration tests verify the behavior of the complete app. See Flutter’s testing overview and integration testing concepts.
| Test type | Best for | Confidence | Execution speed | Maintenance cost | Dependencies |
|---|---|---|---|---|---|
| Unit | One function, method, or class; usually isolate dependencies with mocks. | Lower than broader test layers. | Quick. | Relatively low. | Relatively low. |
| Widget | A widget’s appearance and response to simulated interaction in a Flutter test environment. | Higher than unit tests. | Quick. | Higher than unit tests. | Higher than unit tests. |
| Integration | A complete app or substantial feature working across components, including behavior on a device or emulator. | Highest of the three. | Slowest. | Highest. | Highest. |
The comparison is qualitative; Flutter’s guidance does not set a universal coverage percentage or numeric threshold. Track coverage to find untested code, then prioritize tests around behavior users rely on rather than chasing a number.
When a unit test is enough
Test deterministic logic, such as validation, formatting, calculations, and state transformations, without rendering the UI or depending on disk or a live platform service. Keep collaborators controllable so a failure points to the logic under test.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute#1 Best Overall
When to use a widget test
Use a widget test when correctness depends on layout, visible content, widget state, or user interaction. Flutter’s simplified test environment supplies widget lifecycle context and supports building child widgets, layout, and simulated input.
When an integration test is needed
Use integration coverage when important parts must work together as an app, such as navigating a flow and observing its outcome. Run on the target platform or emulator when platform behavior is material; integration tests can also be used to measure app performance.
How to start unit and widget tests
Flutter projects conventionally put test files in the project-root test/ directory and give them names ending in _test.dart. New Flutter projects commonly include flutter_test in dev_dependencies. For Dart-only unit tests, Flutter’s recipe uses the test package; widget tests use flutter_test from the Flutter SDK. See Flutter’s widget testing introduction.
Example widget test
This small test builds a widget, finds its label, taps a button, and verifies the updated state. Save it as test/counter_test.dart in a Flutter project:
Recommended Free Tools
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
class Counter extends StatefulWidget {
const Counter({super.key});
@override
State<Counter> createState() => _CounterState();
}
class _CounterState extends State<Counter> {
int count = 0;
@override
Widget build(BuildContext context) {
return MaterialApp(
home: Scaffold(
body: Text('Count: $count'),
floatingActionButton: FloatingActionButton(
onPressed: () => setState(() => count++),
child: const Icon(Icons.add),
),
),
);
}
}
void main() {
testWidgets('increments the displayed count when tapped', (tester) async {
await tester.pumpWidget(const Counter());
expect(find.text('Count: 0'), findsOneWidget);
await tester.tap(find.byType(FloatingActionButton));
await tester.pump();
expect(find.text('Count: 1'), findsOneWidget);
});
}Run the suite from the project root with flutter test. In a widget test, testWidgets() provides a WidgetTester; use it to build the tree and simulate interaction. A Finder locates widgets or text, and matchers such as findsOneWidget express the expected result.
How to add an integration test
Flutter’s integration_test package supports test code using flutter_test APIs. The standard setup uses an integration_test/ directory and initializes IntegrationTestWidgetsFlutterBinding. Follow the current integration test guide for platform-specific setup and commands.
Dependency and test outline
Add the SDK package as a development dependency in pubspec.yaml:
dev_dependencies:
flutter_test:
sdk: flutter
integration_test:
sdk: flutterCreate integration_test/app_test.dart. This illustrative test assumes the app has a floating action button with key increment and displays the count as text:
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:your_app/main.dart' as app;
void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
testWidgets('counter flow works in the app', (tester) async {
app.main();
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('increment')));
await tester.pumpAndSettle();
expect(find.text('1'), findsOneWidget);
});
}Replace your_app with the package name in your project and adapt the key and expected text to the app. The official example drives a basic app flow by tapping a keyed floating action button, pumping the widget tree, and checking that the counter changed.
Where integration tests can run
The Flutter guide covers desktop, Android, iOS, and web contexts. Firebase Test Lab is one option it names for automating tests across a variety of devices. Linux CI may need an X server; use the current platform-specific Flutter instructions for exact commands and prerequisites.
Testing plugins and native UI
A Flutter plugin usually combines a Dart API with host-side code such as Kotlin or Swift. Host implementations are available when an app or integration test runs, but not in ordinary Dart unit or widget tests. Calling a plugin directly in those tests can raise MissingPluginException. For app code, Flutter’s preferred approach is to place plugin calls behind an application-owned API and mock that API in unit or widget tests. See Plugins in Flutter tests.
Choose the layer for the plugin behavior
- Test your own decision-making and data handling through the mockable app-owned API in unit or widget tests.
- Test Dart-to-native interaction in an integration test when the actual platform implementation matters.
- For a plugin package, combine Dart unit or widget tests, integration tests for Dart/native interaction, and native unit tests for platform-specific code. Flutter’s plugin testing guide describes these complementary layers.
Native dialogs and platform views
Flutter’s official integration_test package cannot interact with native platform UI such as permission dialogs, notifications, or platform views. If the test must drive those elements, investigate native UI frameworks or Patrol, a third-party option Flutter identifies for native interactions. Check Patrol’s current documentation before relying on specific setup or capabilities.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #4
How to make a test suite useful and maintainable
- Assert behavior a caller or user depends on: displayed content, results of interaction, state transitions, layout-sensitive outcomes, and relevant error states.
- Keep most checks close to the smallest layer that can reliably catch the failure; reserve slower integration runs for high-value complete flows and platform boundaries.
- Use coverage to reveal missed areas, not as a substitute for choosing meaningful assertions. Flutter’s guidance favors many unit and widget tests and enough integration tests for important use cases, without prescribing a universal coverage target.
- When a test is flaky, separate timing or external-service dependencies from app logic, and test the app-owned boundary independently where possible.
Troubleshooting common Flutter test failures
MissingPluginException in a unit or widget test
Cause: The test environment does not load the plugin’s native host implementation. Fix: Wrap plugin calls behind an app-owned interface and mock it for Dart-only tests, or run a suitable integration/native test for the platform behavior.
Finder cannot locate an expected widget
Cause: The widget may not have been built yet, the finder may target the wrong text or type, or an earlier interaction may not have updated state. Fix: Check the finder against the actual widget tree, await the action, then call pump() for a simple state update or pumpAndSettle() when scheduled frames need to finish.
Integration test fails to launch in CI
Cause: Platform prerequisites differ across runners; Linux CI may require an X server. Fix: Follow the current Flutter instructions for the specific target and configure its required display or emulator environment before changing app assertions.
A native permission prompt blocks the test
Cause: Flutter’s integration_test cannot drive native UI. Fix: Use an appropriate native UI testing framework or evaluate Patrol for this concrete need; keep the rest of the app flow covered with Flutter tests.
Best Value
Or skip the browser setup
If your testing workflow needs screenshots of web pages as visual artifacts, ScreenshotNeo can return an image or PDF with one GET request. For example, save this as a shell command after replacing the key:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for options. It accepts cookie or consent banners as a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and responses identify page verdict and billing in headers. Its MCP server gives AI agents screenshot, page-info, and PDF tools. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000. Sign up for 1,000 free screenshots a month with no card.
Frequently Asked Questions
Does Flutter set a required code coverage percentage?
No universal percentage target is stated in the reviewed Flutter testing guidance.
Can Flutter integration tests run across different platforms?
The Flutter guide covers desktop, Android, iOS, and web contexts; exact setup depends on the target platform.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
