Port scrollable_lazy_list_test.dart to ListView (#8025)

We call the builder in slightly different ways, but the new results
seem reasonable.

packages/flutter/test/widgets/scrollable_lazy_list_test.dart → packages/flutter/test/widgets/list_view_builder_test.dart

@@ -2,15 +2,13 @@
 // 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:flutter/widgets.dart';
 
 import 'test_widgets.dart';
 
 void main() {
-  testWidgets('HomogeneousViewport mount/dismount smoke test', (WidgetTester tester) async {
+  testWidgets('ListView.builder mount/dismount smoke test', (WidgetTester tester) async {
     List<int> callbackTracker = <int>[];
 
     // the root view is 800x600 in the test environment
@@ -18,22 +16,18 @@ void main() {
 
     Widget builder() {
       return new FlipWidget(
-        left: new ScrollableLazyList(
-          itemBuilder: (BuildContext context, int start, int count) {
-            List<Widget> result = <Widget>[];
-            for (int index = start; index < start + count; index += 1) {
+        left: new ListView.builder(
+          itemExtent: 100.0,
+          itemBuilder: (BuildContext context, int index) {
             callbackTracker.add(index);
-              result.add(new Container(
+            return new Container(
               key: new ValueKey<int>(index),
               height: 100.0,
-                child: new Text("$index")
-              ));
-            }
-            return result;
+              child: new Text('$index'),
+            );
           },
-          itemExtent: 100.0
         ),
-        right: new Text('Not Today')
+        right: new Text('Not Today'),
       );
     }
 
@@ -56,166 +50,171 @@ void main() {
     expect(callbackTracker, equals(<int>[0, 1, 2, 3, 4, 5]));
   });
 
-  testWidgets('HomogeneousViewport vertical', (WidgetTester tester) async {
+  testWidgets('ListView.builder vertical', (WidgetTester tester) async {
     List<int> callbackTracker = <int>[];
 
     // the root view is 800x600 in the test environment
     // so if our widget is 200 pixels tall, it should fit exactly 3 times.
     // but if we are offset by 300 pixels, there will be 4, numbered 1-4.
 
-    ItemListBuilder itemBuilder = (BuildContext context, int start, int count) {
-      List<Widget> result = <Widget>[];
-      for (int index = start; index < start + count; index += 1) {
+    IndexedWidgetBuilder itemBuilder = (BuildContext context, int index) {
       callbackTracker.add(index);
-        result.add(new Container(
+      return new Container(
         key: new ValueKey<int>(index),
         width: 500.0, // this should be ignored
         height: 400.0, // should be overridden by itemExtent
-          child: new Text("$index")
-        ));
-      }
-      return result;
+        child: new Text('$index')
+      );
     };
 
-    FlipWidget testWidget = new FlipWidget(
-      left: new ScrollableLazyList(
-        itemBuilder: itemBuilder,
+    FlipWidget buildWidget() {
+      return new FlipWidget(
+        left: new ListView.builder(
+          controller: new ScrollController(initialScrollOffset: 300.0),
           itemExtent: 200.0,
-        initialScrollOffset: 300.0
+          itemBuilder: itemBuilder,
         ),
         right: new Text('Not Today')
       );
-    Completer<Null> scrollTo(double newScrollOffset) {
-      Completer<Null> completer = new Completer<Null>();
-      final ScrollableState scrollable = tester.state(find.byType(Scrollable));
-      scrollable.scrollTo(newScrollOffset).whenComplete(completer.complete);
-      return completer;
     }
 
-    await tester.pumpWidget(testWidget);
+    void jumpTo(double newScrollOffset) {
+      final Scrollable2State scrollable = tester.state(find.byType(Scrollable2));
+      scrollable.position.jumpTo(newScrollOffset);
+    }
 
-    expect(callbackTracker, equals(<int>[1, 2, 3, 4]));
+    await tester.pumpWidget(buildWidget());
 
+    expect(callbackTracker, equals(<int>[1, 2, 3, 4]));
     callbackTracker.clear();
 
-    Completer<Null> completer = scrollTo(400.0);
-    expect(completer.isCompleted, isFalse);
+    jumpTo(400.0);
     // now only 3 should fit, numbered 2-4.
 
-    await tester.pumpWidget(testWidget);
+    await tester.pumpWidget(buildWidget());
+
+    expect(callbackTracker, equals(<int>[1, 2, 3, 4]));
+    callbackTracker.clear();
+
+    await tester.pumpWidget(buildWidget());
 
     expect(callbackTracker, equals(<int>[2, 3, 4]));
-    expect(completer.isCompleted, isTrue);
+    callbackTracker.clear();
+
+    jumpTo(500.0);
+    // now 4 should fit, numbered 2-5.
+
+    await tester.pumpWidget(buildWidget());
 
+    expect(callbackTracker, equals(<int>[2, 3, 4, 5]));
     callbackTracker.clear();
   });
 
-  testWidgets('HomogeneousViewport horizontal', (WidgetTester tester) async {
+  testWidgets('ListView.builder horizontal', (WidgetTester tester) async {
     List<int> callbackTracker = <int>[];
 
     // the root view is 800x600 in the test environment
     // so if our widget is 200 pixels wide, it should fit exactly 4 times.
     // but if we are offset by 300 pixels, there will be 5, numbered 1-5.
 
-    ItemListBuilder itemBuilder = (BuildContext context, int start, int count) {
-      List<Widget> result = <Widget>[];
-      for (int index = start; index < start + count; index += 1) {
+    IndexedWidgetBuilder itemBuilder = (BuildContext context, int index) {
       callbackTracker.add(index);
-        result.add(new Container(
+      return new Container(
         key: new ValueKey<int>(index),
         width: 400.0, // this should be overridden by itemExtent
         height: 500.0, // this should be ignored
-          child: new Text("$index")
-        ));
-      }
-      return result;
+        child: new Text('$index'),
+      );
     };
 
-    FlipWidget testWidget = new FlipWidget(
-      left: new ScrollableLazyList(
+    FlipWidget buildWidget() {
+      return new FlipWidget(
+        left: new ListView.builder(
+          controller: new ScrollController(initialScrollOffset: 300.0),
           itemBuilder: itemBuilder,
           itemExtent: 200.0,
-        initialScrollOffset: 300.0,
           scrollDirection: Axis.horizontal
         ),
         right: new Text('Not Today')
       );
-    Completer<Null> scrollTo(double newScrollOffset) {
-      Completer<Null> completer = new Completer<Null>();
-      final ScrollableState scrollable = tester.state(find.byType(Scrollable));
-      scrollable.scrollTo(newScrollOffset).whenComplete(completer.complete);
-      return completer;
     }
 
-    await tester.pumpWidget(testWidget);
+    void jumpTo(double newScrollOffset) {
+      final Scrollable2State scrollable = tester.state(find.byType(Scrollable2));
+      scrollable.position.jumpTo(newScrollOffset);
+    }
+
+    await tester.pumpWidget(buildWidget());
 
     expect(callbackTracker, equals(<int>[1, 2, 3, 4, 5]));
 
     callbackTracker.clear();
 
-    Completer<Null> completer = scrollTo(400.0);
-    expect(completer.isCompleted, isFalse);
+    jumpTo(400.0);
     // now only 4 should fit, numbered 2-5.
 
-    await tester.pumpWidget(testWidget);
+    await tester.pumpWidget(buildWidget());
+
+    expect(callbackTracker, equals(<int>[1, 2, 3, 4, 5]));
+    callbackTracker.clear();
+
+    await tester.pumpWidget(buildWidget());
 
     expect(callbackTracker, equals(<int>[2, 3, 4, 5]));
-    expect(completer.isCompleted, isTrue);
+    callbackTracker.clear();
+
+    jumpTo(500.0);
+    // now only 5 should fit, numbered 2-6.
+
+    await tester.pumpWidget(buildWidget());
 
+    expect(callbackTracker, equals(<int>[2, 3, 4, 5, 6]));
     callbackTracker.clear();
   });
 
-  testWidgets('ScrollableLazyList 10 items, 2-3 items visible', (WidgetTester tester) async {
+  testWidgets('ListView.builder 10 items, 2-3 items visible', (WidgetTester tester) async {
     List<int> callbackTracker = <int>[];
 
     // The root view is 800x600 in the test environment and our list
     // items are 300 tall. Scrolling should cause two or three items
     // to be built.
 
-    ItemListBuilder itemBuilder = (BuildContext context, int start, int count) {
-      List<Widget> result = <Widget>[];
-      for (int index = start; index < start + count; index += 1) {
+    IndexedWidgetBuilder itemBuilder = (BuildContext context, int index) {
       callbackTracker.add(index);
-        result.add(new Text('$index', key: new ValueKey<int>(index)));
-      }
-      return result;
+      return new Text('$index', key: new ValueKey<int>(index));
     };
 
-    Widget testWidget = new ScrollableLazyList(
+    Widget testWidget = new ListView.builder(
       itemBuilder: itemBuilder,
       itemExtent: 300.0,
-      itemCount: 10
+      itemCount: 10,
     );
-    Completer<Null> scrollTo(double newScrollOffset) {
-      Completer<Null> completer = new Completer<Null>();
-      ScrollableState scrollable = tester.state(find.byType(Scrollable));
-      scrollable.scrollTo(newScrollOffset).whenComplete(completer.complete);
-      return completer;
+
+    void jumpTo(double newScrollOffset) {
+      final Scrollable2State scrollable = tester.state(find.byType(Scrollable2));
+      scrollable.position.jumpTo(newScrollOffset);
     }
 
     await tester.pumpWidget(testWidget);
     expect(callbackTracker, equals(<int>[0, 1]));
     callbackTracker.clear();
 
-    Completer<Null> completer = scrollTo(150.0);
-    expect(completer.isCompleted, isFalse);
-    await tester.pumpWidget(testWidget);
-    expect(callbackTracker, equals(<int>[0, 1, 2]));
-    expect(completer.isCompleted, isTrue);
+    jumpTo(150.0);
+    await tester.pump();
+
+    expect(callbackTracker, equals(<int>[2]));
     callbackTracker.clear();
 
-    completer = scrollTo(600.0);
-    expect(completer.isCompleted, isFalse);
-    await tester.pumpWidget(testWidget);
-    expect(callbackTracker, equals(<int>[2, 3]));
-    expect(completer.isCompleted, isTrue);
+    jumpTo(600.0);
+    await tester.pump();
+
+    expect(callbackTracker, equals(<int>[3]));
     callbackTracker.clear();
 
-    completer = scrollTo(750.0);
-    expect(completer.isCompleted, isFalse);
-    await tester.pumpWidget(testWidget);
-    expect(callbackTracker, equals(<int>[2, 3, 4]));
-    expect(completer.isCompleted, isTrue);
+    jumpTo(750.0);
+    await tester.pump();
+
+    expect(callbackTracker, equals(<int>[4]));
     callbackTracker.clear();
   });