Create adjustable test settings.

pkgs/leak_tracker/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 9.0.9
+
+* Define [SkippedLeaks].
+* Add item `none` to BaseliningMode.
+
 # 9.0.8
 
 * Enable declaring all not disposed objects as leaks.

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

@@ -41,6 +41,7 @@ class Baseliner {
         throw UnimplementedError(
             'Regression testing for memory consumption is not implemented yet. '
             'Upvote the following issue if interested: https://github.com/dart-lang/leak_tracker/issues/120');
+      case BaseliningMode.none:
     }
   }
 

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

@@ -22,6 +22,8 @@ typedef LeaksCallback = void Function(Leaks leaks);
 /// Useable to temporary disable features in case of
 /// noisinness or performance regression
 /// in applications or tests.
+/// TODO(polina-c): delete after migration to [SkippedLeaks].
+/// https://github.com/flutter/devtools/issues/3951
 class Switches {
   const Switches({
     this.disableNotGCed = false,
@@ -38,6 +40,104 @@ class Switches {
   bool get isObjectTrackingDisabled => disableNotDisposed && disableNotGCed;
 }
 
+/// Set of classes to skip during leak tracking.
+class LeakSkipSet {
+  const LeakSkipSet({this.byClass = const {}, this.skipAll = false});
+
+  const LeakSkipSet.skipAll() : this(skipAll: true, byClass: const {});
+
+  const LeakSkipSet.byClass(this.byClass) : skipAll = false;
+
+  /// Classes to skip during leak tracking.
+  ///
+  /// Maps name of the class, as returned by `object.runtimeType.toString()`,
+  /// to the number of instances of the class that are allowed to leak.
+  ///
+  /// If number of instances is [null], all leaks are skipped.
+  final Map<String, int?> byClass;
+
+  /// If true, all leaks are skipped, otherwise [byClass] defines what is skipped.
+  final bool skipAll;
+
+  /// Creates a copy of this object with the given fields replaced
+  /// with the new values.
+  LeakSkipSet copyWith({Map<String, int?>? byClass, bool? skipAll}) {
+    return LeakSkipSet(
+      skipAll: skipAll ?? this.skipAll,
+      byClass: byClass ?? this.byClass,
+    );
+  }
+
+  /// Merges two skip lists.
+  ///
+  /// In the result object the skip limit for a class is maximum of two original skip limits.
+  LeakSkipSet merge(LeakSkipSet? other) {
+    if (other == null) return this;
+    final map = {...byClass};
+    for (final theClass in other.byClass.keys) {
+      if (!map.containsKey(theClass)) {
+        map[theClass] = other.byClass[theClass];
+        continue;
+      }
+      final int? otherCount = other.byClass[theClass];
+      final int? thisCount = byClass[theClass];
+      if (thisCount == null || otherCount == null) {
+        map[theClass] = null;
+        continue;
+      }
+      map[theClass] = max(thisCount, otherCount);
+    }
+    return LeakSkipSet(
+      byClass: map,
+      skipAll: skipAll || other.skipAll,
+    );
+  }
+
+  /// Removes the classes from skip lists.
+  LeakSkipSet track(List<String> list) {
+    if (list.isEmpty) return this;
+    final map = {...byClass};
+    list.forEach(map.remove);
+    return copyWith(byClass: map);
+  }
+
+  /// Returns true if the class should be skipped.
+  bool isSkipped(String className) {
+    if (skipAll) return true;
+    return byClass.containsKey(className) && byClass[className] == null;
+  }
+}
+
+/// Skip lists for each type of leak.
+class SkippedLeaks {
+  const SkippedLeaks({
+    this.notGCed = const LeakSkipSet(),
+    this.notDisposed = const LeakSkipSet(),
+  });
+
+  /// Skip list for notGCed leaks.
+  final LeakSkipSet notGCed;
+
+  /// Skip list for notDisposed leaks.
+  final LeakSkipSet notDisposed;
+
+  /// Returns true if the class is skipped.
+  ///
+  /// If [leakType] is null, returns true if the class is skipped for all
+  /// leak types.
+  bool isSkipped(String className, {LeakType? leakType}) {
+    switch (leakType) {
+      case null:
+        return notGCed.isSkipped(className) && notDisposed.isSkipped(className);
+      case LeakType.notDisposed:
+        return notDisposed.isSkipped(className);
+      case LeakType.notGCed:
+      case LeakType.gcedLate:
+        return notGCed.isSkipped(className);
+    }
+  }
+}
+
 /// Configuration for diagnostics.
 ///
 /// Stacktrace and retaining path collection can seriously affect performance and memory footprint.
@@ -58,7 +158,7 @@ class LeakDiagnosticConfig {
 
   /// If true, retaining path will be collected for non-GCed objects.
   ///
-  /// The collection of retaining path a blocking asyncronous call.
+  /// The collection of retaining path is a blocking asyncronous call.
   /// In release mode this flag does not work.
   final bool collectRetainingPathForNotGCed;
 
@@ -259,6 +359,10 @@ class MemoryBaselining {
     this.baseline,
   }) : assert(!(mode == BaseliningMode.regression && baseline == null));
 
+  const MemoryBaselining.none()
+      : mode = BaseliningMode.none,
+        baseline = null;
+
   final BaseliningMode mode;
 
   final MemoryBaseline? baseline;
@@ -278,6 +382,9 @@ class MemoryBaselining {
 }
 
 enum BaseliningMode {
+  /// No baselining.
+  none,
+
   /// Measure memory footprint and output to console when phase is finished.
   measure,
 

pkgs/leak_tracker/pubspec.yaml

@@ -1,5 +1,5 @@
 name: leak_tracker
-version: 9.0.8
+version: 9.0.9
 description: A framework for memory leak tracking for Dart and Flutter applications.
 repository: https://github.com/dart-lang/leak_tracker/tree/main/pkgs/leak_tracker
 

pkgs/leak_tracker/test/tests/leak_tracking/model_test.dart

@@ -110,4 +110,25 @@ void main() {
       expect(sampler.deltaMax, 1);
     });
   });
+
+  group('$LeakSkipSet', () {
+    test('merges', () {
+      const list1 = LeakSkipSet.byClass({'class1': null});
+      const list2 = LeakSkipSet.byClass({'class2': null});
+
+      final result = list1.merge(list2);
+
+      expect(result.isSkipped('class1'), true);
+      expect(result.isSkipped('class2'), true);
+    });
+
+    test('removes', () {
+      const list = LeakSkipSet.byClass({'class1': null, 'class2': null});
+
+      final result = list.track(['class1']);
+
+      expect(result.isSkipped('class1'), false);
+      expect(result.isSkipped('class2'), true);
+    });
+  });
 }

pkgs/leak_tracker_flutter_testing/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.0.7
+
+* Make configuration adjustable.
+
 # 1.0.6
 
 * If an object is not disposed by the end of testing, mark it as notDisposed.