anchor.diff:    });
   }
   
  -class TestImageProvider extends ImageProvider<TestImageProvider> {
  +class ConfigurationAwareKey {
  +  const ConfigurationAwareKey(this.provider, this.configuration)
  +    : assert(provider != null),
  +      assert(configuration != null);
  +
  +  final ImageProvider provider;
  +  final ImageConfiguration configuration;
  +
  +  @override
  +  bool operator ==(Object other) {
  +    if (other.runtimeType != runtimeType) {
  +      return false;
  +    }
  +    return other is ConfigurationAwareKey
  +        && other.provider == provider
  +        && other.configuration == configuration;
  +  }
  +
  +  @override
  +  int get hashCode => hashValues(provider, configuration);
  +}
  +
  +class ConfigurationKeyedTestImageProvider extends TestImageProvider {
  +  @override
  +  Future<ConfigurationAwareKey> obtainKey(ImageConfiguration configuration) {
  +    return SynchronousFuture<ConfigurationAwareKey>(ConfigurationAwareKey(this, configuration));
  +  }
  +}
  +
  +class TestImageProvider extends ImageProvider<Object> {
     TestImageProvider({ImageStreamCompleter streamCompleter}) {
       _streamCompleter = streamCompleter
         ?? OneFrameImageStreamCompleter(_completer.future);
  
positive.code:     );
  
      expect(imageProvider._lastResolvedConfiguration.devicePixelRatio, 10.0);
    });
  
    testWidgets('Verify Image stops listening to ImageStream', (WidgetTester tester) async {
  
negative.code:             child: Image(
                excludeFromSemantics: true,
                key: imageKey,
                image: debouncingProvider,
              ),
            ),
          ],
  