Fix flakiness in detection of notDisposed leaks in tests.

pkgs/leak_tracker/lib/src/leak_tracking/_object_record_set.dart

@@ -32,8 +32,10 @@ class ObjectRecordSet {
     return list.firstWhereOrNull((r) => r.ref.target == object);
   }
 
+  /// Removes record if it exists in the set.
   void remove(ObjectRecord record) {
-    final list = _records[record.code]!;
+    final list = _records[record.code];
+    if (list == null) return;
     bool removed = false;
     list.removeWhere((r) {
       if (r == record) {
@@ -42,7 +44,6 @@ class ObjectRecordSet {
       }
       return r == record;
     });
-    assert(removed);
     _length--;
     if (list.isEmpty) _records.remove(record.code);
   }

pkgs/leak_tracker/lib/src/leak_tracking/_object_tracker.dart

@@ -84,6 +84,10 @@ class ObjectTracker implements LeakProvider {
     _objects.assertRecordIntegrity(record);
     record.setGCed(_gcCounter.gcCount, clock.now());
 
+    _declareNotDisposedLeak(record);
+  }
+
+  void _declareNotDisposedLeak(ObjectRecord record) {
     if (record.isGCedLateLeak(disposalTime, numberOfGcCycles)) {
       _objects.gcedLateLeaks.add(record);
     } else if (record.isNotDisposedLeak) {
@@ -98,6 +102,18 @@ class ObjectTracker implements LeakProvider {
     _objects.assertRecordIntegrity(record);
   }
 
+  /// Declares all not disposed objects as leaks, even if they are not GCed yet.
+  ///
+  /// Is used to make sure all disposables are disposed by the the end of the test.
+  void declareAllNotDisposedAsLeaks() {
+    throwIfDisposed();
+    final notGCedAndNotDisposed = <ObjectRecord>[];
+    _objects.notGCed.forEach((record) {
+      if (!record.isDisposed) notGCedAndNotDisposed.add(record);
+    });
+    notGCedAndNotDisposed.forEach(_declareNotDisposedLeak);
+  }
+
   void dispatchDisposal(
     Object object, {
     required Map<String, dynamic>? context,

pkgs/leak_tracker/lib/src/leak_tracking/leak_tracking.dart

@@ -210,4 +210,12 @@ abstract class LeakTracking {
 
     await (result ?? Future.value());
   }
+
+  /// Declares all not disposed objects as leaks.
+  ///
+  /// Should be invoked after test execution, to detect
+  /// not disposed objects, even if they are not GCed yet.
+  static void declareNotDisposedObjectsAsLeaks() {
+    _leakTracker?.objectTracker.declareAllNotDisposedAsLeaks();
+  }
 }

pkgs/leak_tracker_flutter_testing/CHANGELOG.md

@@ -1,5 +1,6 @@
 # 1.0.5
 
+* If an object is not disposed by the end of testing, mark it as notDisposed.
 * Bump version of SDK to 3.1.2.
 
 # 1.0.4

pkgs/leak_tracker_flutter_testing/lib/src/test_widgets.dart

@@ -66,8 +66,9 @@ void configureLeakTrackingTearDown({
 Future<void> _tearDownTestingWithLeakTracking(LeaksCallback? onLeaks) async {
   if (!LeakTracking.isStarted) return;
   if (!_isPlatformSupported) return;
-
   MemoryAllocations.instance.removeListener(_flutterEventToLeakTracker);
+
+  LeakTracking.declareNotDisposedObjectsAsLeaks();
   await forceGC(fullGcCycles: _leakTrackingTestSettings.numberOfGcCycles);
   // This delay is needed to make sure all disposed and not GCed object are
   // declared as leaks, and thus there is no flakiness in tests.

pkgs/leak_tracker_flutter_testing/test/tests/end_to_end/failing_tests/failure_test.dart

@@ -0,0 +1,21 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:leak_tracker_flutter_testing/leak_tracker_flutter_testing.dart';
+
+late String twoControllers;
+
+/// Verification for the tests happens in flutter_test_config.dart.
+void main() {
+  testWidgetsWithLeakTracking(
+      twoControllers = 'Two not disposed controllers results in two leaks.',
+      (tester) async {
+    // ignore: unused_local_variable
+    final TextEditingController controller = TextEditingController();
+
+    // ignore: unused_local_variable
+    final FocusNode focusNode = FocusNode(debugLabel: 'Test Node');
+  });
+}

pkgs/leak_tracker_flutter_testing/test/tests/end_to_end/failing_tests/flutter_test_config.dart

@@ -0,0 +1,41 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. 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:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:leak_tracker/leak_tracker.dart';
+import 'package:leak_tracker_flutter_testing/leak_tracker_flutter_testing.dart';
+
+import 'failure_test.dart';
+
+/// The test configuration for each test library in this directory.
+///
+/// See https://api.flutter.dev/flutter/flutter_test/flutter_test-library.html.
+Future<void> testExecutable(FutureOr<void> Function() testMain) async {
+  Leaks? leaks;
+
+  // This tear down should be set before leak tracking tear down in
+  // order to happen after it and verify that leaks are found.
+  tearDownAll(() async {
+    final theLeaks = leaks;
+    if (theLeaks == null) throw 'leaks should be detected';
+
+    expect(
+      theLeaks.notDisposed.where((l) => l.phase == twoControllers),
+      hasLength(2),
+    );
+  });
+
+  configureLeakTrackingTearDown(
+    configureOnce: true,
+    onLeaks: (l) => leaks = l,
+  );
+
+  setUpAll(() {
+    LeakTracking.warnForUnsupportedPlatforms = false;
+  });
+
+  await testMain();
+}