Refactor LruCache synchronization and update test matchers

Co-authored-by: shtankopro <shtankopro@gmail.com>

Author: cursoragent

lib/src/lru_cache.dart

@@ -161,35 +161,33 @@ class LruCache<K, V> {
   /// If the [maxSize] is less than 0, all entries are evicted.
   /// This method is called by [put] and [resize] after adding or updating
   /// an entry.
-  Future<void> _trimToSize(int maxSize) async {
-    await _lock.synchronized(() {
-      while (true) {
-        K key;
-        V value;
-
-        if (_size < 0 || (_map.isEmpty && _size != 0)) {
-          throw StateError(
-            '$runtimeType.sizeOf() is reporting inconsistent results!',
-          );
-        }
-
-        if (_size <= maxSize) {
-          break;
-        }
-
-        final toEvict = _eldest();
-        if (toEvict == null) {
-          break;
-        }
-
-        key = toEvict.key;
-        value = toEvict.value;
-        _map.remove(key);
-        _size -= safeSizeOf(key, value);
-        _evictionCount++;
-        entryRemoved(true, key, value, null);
+  void _trimToSize(int maxSize) {
+    while (true) {
+      K key;
+      V value;
+
+      if (_size < 0 || (_map.isEmpty && _size != 0)) {
+        throw StateError(
+          '$runtimeType.sizeOf() is reporting inconsistent results!',
+        );
       }
-    });
+
+      if (_size <= maxSize) {
+        break;
+      }
+
+      final toEvict = _eldest();
+      if (toEvict == null) {
+        break;
+      }
+
+      key = toEvict.key;
+      value = toEvict.value;
+      _map.remove(key);
+      _size -= safeSizeOf(key, value);
+      _evictionCount++;
+      entryRemoved(true, key, value, null);
+    }
   }
 
   MapEntry<K, V>? _eldest() => _map.entries.firstOrNull;
@@ -237,7 +235,9 @@ class LruCache<K, V> {
 
   /// Removes all entries from the cache.
   Future<void> evictAll() async {
-    await _trimToSize(-1);
+    await _lock.synchronized(() {
+      _trimToSize(-1);
+    });
   }
 
   /// Returns the number of entries in the cache.

test/lru_cache_comprehensive_test.dart

@@ -41,20 +41,20 @@ void main() {
     group('Basic Operations', () {
       test('should handle null key assertion', () {
         final cache = LruCache<String, String>(1);
-        expect(() => cache.get(null as String), throwsAssertionError);
-        expect(() => cache.put(null as String, 'value'), throwsAssertionError);
-        expect(() => cache.remove(null as String), throwsAssertionError);
-        expect(() => cache.containsKey(null as String), throwsAssertionError);
+        expect(() => cache.get(null as String), throwsA(isA<AssertionError>()));
+        expect(() => cache.put(null as String, 'value'), throwsA(isA<AssertionError>()));
+        expect(() => cache.remove(null as String), throwsA(isA<AssertionError>()));
+        expect(() => cache.containsKey(null as String), throwsA(isA<AssertionError>()));
       });
 
       test('should handle null value assertion', () {
         final cache = LruCache<String, String>(1);
-        expect(() => cache.put('key', null as String), throwsAssertionError);
+        expect(() => cache.put('key', null as String), throwsA(isA<AssertionError>()));
       });
 
       test('should handle zero maxSize assertion', () {
-        expect(() => LruCache<String, String>(0), throwsAssertionError);
-        expect(() => LruCache<String, String>(-1), throwsAssertionError);
+        expect(() => LruCache<String, String>(0), throwsA(isA<AssertionError>()));
+        expect(() => LruCache<String, String>(-1), throwsA(isA<AssertionError>()));
       });
 
       test('should handle single entry cache', () async {

test/matcher_test.dart

@@ -0,0 +1,35 @@
+import 'package:test/test.dart';
+
+void main() {
+  group('Matcher Tests', () {
+    test('should work with throwsA and isA', () {
+      expect(() => throw AssertionError('test'), throwsA(isA<AssertionError>()));
+      expect(() => throw StateError('test'), throwsA(isA<StateError>()));
+    });
+
+    test('should work with isNull', () {
+      expect(null, isNull);
+      expect('not null', isNot(isNull));
+    });
+
+    test('should work with isEmpty and isNotEmpty', () {
+      expect([], isEmpty);
+      expect([1, 2, 3], isNotEmpty);
+    });
+
+    test('should work with contains', () {
+      expect([1, 2, 3], contains(2));
+      expect(['a', 'b', 'c'], contains('b'));
+    });
+
+    test('should work with greaterThan and lessThan', () {
+      expect(5, greaterThan(3));
+      expect(3, lessThan(5));
+      expect(5, lessThanOrEqualTo(5));
+    });
+
+    test('should work with closeTo', () {
+      expect(3.14159, closeTo(3.14, 0.01));
+    });
+  });
+}