test('sample test', () async { 
  // なんか色々 
});

test('check flutter driver extension', () async {
  final health = await driver.checkHealth();
  print(health.status);
});

import 'dart:async';
import 'package:flutter_driver/flutter_driver.dart';

abstract class TestScreen {
  TestScreen(this.driver);
  final FlutterDriver driver;
  Future<bool> get isReady;
}

import 'package:flutter_driver/flutter_driver.dart';
import 'base_test_screen.dart';

class TopTestScreen extends TestScreen {
  TopTestScreen(FlutterDriver driver) : super(driver);
  final _fooButton = find.byTooltip('バラ色の人生 Foo!');

  @override
  Future<bool> get isReady {
    return driver.waitFor(_fooButton).then((_) => true).catchError((_) => false);
  }

  Future<void> tapFooButton() async {
    await driver.tap(_fooButton);
  }
}

test('verify showing top page', () async {
  expect(await topTestScreen.isReady, true);
  await topTestScreen.tapFooButton();
  // その他色々
});

import 'dart:io';
import 'package:flutter_driver/flutter_driver.dart';

Future<void> takeScreenshot(FlutterDriver driver, String path) async {
  print('will take screenshot $path');
  await driver.waitUntilNoTransientCallbacks();
  final pixels = await driver.screenshot();
  final file = File(path);
  await file.writeAsBytes(pixels);
  print('wrote $file');
}

  /// Take a screenshot.
  ///
  /// The image will be returned as a PNG.
  Future<List<int>> screenshot() async {
    // HACK: this artificial delay here is to deal with a race between the
    //       driver script and the GPU thread. The issue is that driver API
    //       synchronizes with the framework based on transient callbacks, which
    //       are out of sync with the GPU thread. Here's the timeline of events
    //       in ASCII art:
    //
    //       -------------------------------------------------------------------
    //       Without this delay:
    //       -------------------------------------------------------------------
    //       UI    : <-- build -->
    //       GPU   :               <-- rasterize -->
    //       Gap   :              | random |
    //       Driver:                        <-- screenshot -->
    //
    //       In the diagram above, the gap is the time between the last driver
    //       action taken, such as a `tap()`, and the subsequent call to
    //       `screenshot()`. The gap is random because it is determined by the
    //       unpredictable network communication between the driver process and
    //       the application. If this gap is too short, which it typically will
    //       be, the screenshot is taken before the GPU thread is done
    //       rasterizing the frame, so the screenshot of the previous frame is
    //       taken, which is wrong.
    //
    //       -------------------------------------------------------------------
    //       With this delay, if we're lucky:
    //       -------------------------------------------------------------------
    //       UI    : <-- build -->
    //       GPU   :               <-- rasterize -->
    //       Gap   :              |    2 seconds or more   |
    //       Driver:                                        <-- screenshot -->
    //
    //       The two-second gap should be long enough for the GPU thread to
    //       finish rasterizing the frame, but not longer than necessary to keep
    //       driver tests as fast a possible.
    //
    //       -------------------------------------------------------------------
    //       With this delay, if we're not lucky:
    //       -------------------------------------------------------------------
    //       UI    : <-- build -->
    //       GPU   :               <-- rasterize randomly slow today -->
    //       Gap   :              |    2 seconds or more   |
    //       Driver:                                        <-- screenshot -->
    //
    //       In practice, sometimes the device gets really busy for a while and
    //       even two seconds isn't enough, which means that this is still racy
    //       and a source of flakes.
    await Future<void>.delayed(const Duration(seconds: 2));

    final Map<String, dynamic> result = await _peer.sendRequest('_flutter.screenshot');
    return base64.decode(result['screenshot']);
  }

await driver.waitFor(fooBar, timeout: const Duration(seconds: 3));

const Duration _kUnusuallyLongTimeout = Duration(seconds: 5);

// 中略

Future<T> _warnIfSlow<T>({
  @required Future<T> future,
  @required Duration timeout,
  @required String message,
}) {
  assert(future != null);
  assert(timeout != null);
  assert(message != null);
  return future..timeout(timeout, onTimeout: () { _log.warning(message); });
}

Duration _maxDuration(Duration a, Duration b) {
  if (a == null)
    return b;
  if (b == null)
    return a;
  if (a > b)
    return a;
  return b;
}

// 中略

Future<Map<String, dynamic>> _sendCommand(Command command) async {
  Map<String, dynamic> response;
  try {
    final Map<String, String> serialized = command.serialize();
    _logCommunication('>>> $serialized');
    final Future<Map<String, dynamic>> future = _appIsolate.invokeExtension(
      _flutterExtensionMethodName,
      serialized,
    ).then<Map<String, dynamic>>((Object value) => value);
    response = await _warnIfSlow<Map<String, dynamic>>(
      future: future,
      timeout: _maxDuration(command.timeout, _kUnusuallyLongTimeout),
      message: '${command.kind} message is taking a long time to complete...',
    );
    _logCommunication('<<< $response');
  } catch (error, stackTrace) {
    throw DriverError(
      'Failed to fulfill ${command.runtimeType} due to remote error',
      error,
      stackTrace,
    );
  }
  if (response['isError'])
    throw DriverError('Error in Flutter application: ${response['response']}');
  return response['response'];
}

test('verify showing top page', () async {
  expect(await topTestScreen.isReady, true);
  await topTestScreen.tapFooButton();
  // その他色々
}, timeout: Timeout(Duration(seconds: 100)));

final foo = Platform.environment['Foo']

cp  -r test_driver/screenshots $FCI_EXPORT_DIR/screenshots

final firestoreMock = FirestoreMock();
final mockCollectionRef = MockCollectionReference();
final mockQuery = MockQuery();
final mockQuerySnapshot = MockQuerySnapshot();
final mockDocumentSnapshot = MockDocumentSnapshot();

when(firestoreMock.collection('/version/1/foo')).thenReturn(mockCollectionRef);
when(mockCollectionRef.orderBy('createdAt')).thenReturn(mockQuery);
when(mockQuery.snapshots()).thenAnswer((_) => Stream.fromIterable([mockQuerySnapshot]));
when(mockQuerySnapshot.documents).thenReturn([mockDocumentSnapshot]);
when(mockDocumentSnapshot.data).thenReturn({'foo': 'bar'});