¿Cómo puedo "dormir" un programa de Dart?

Me gusta simular una llamada de servicio web asincrónica en mi aplicación Dart para realizar pruebas. Para simular la aleatoriedad de estas llamadas simuladas respondiendo (posiblemente fuera de orden), me gustaría programar mis simulaciones para esperar (dormir) durante un cierto período de tiempo antes de devolver el 'Futuro'.

¿Cómo puedo hacer esto?

También puede utilizar la fábrica Future.delayed para completar un futuro después de un retraso. A continuación, se muestra un ejemplo de dos funciones que devuelven una cadena de forma asincrónica después de un retraso:

import 'dart:async';

Future sleep1() {
  return new Future.delayed(const Duration(seconds: 1), () => "1");
}

Future sleep2() {
  return new Future.delayed(const Duration(seconds: 2), () => "2");
}

No siempre es lo que quieres (a veces quieres Future.delayed), pero si realmente quieres dormir en tu aplicación de línea de comandos Dart, puedes usar dart: io's sleep():

import 'dart:io';

main() {
  sleep(const Duration(seconds:1));
}

Edición 2019:

En código asincrónico

await Future.delayed(Duration(seconds: 1));

En código de sincronización

import 'dart:io';

sleep(Duration(seconds:1));

Nota: Esto bloquea todo el proceso (aislar), por lo que no se procesarán otras funciones asíncronas. Tampoco está disponible en la web porque Javascript es solo asíncrono.

Descubrí que hay varias implementaciones en Dart para hacer que el código demore la ejecución:

new Future.delayed(const Duration(seconds: 1)); //recommend

new Timer(const Duration(seconds: 1), ()=>print("1 second later."));

sleep(const Duration(seconds: 1)); //import 'dart:io';

new Stream.periodic(const Duration(seconds: 1), (_) => print("1 second later.")).first.then((_)=>print("Also 1 second later."));
//new Stream.periodic(const Duration(seconds: 1)).first.then((_)=>print("Also 1 second later."));

Para la sintaxis de Dart 2+, en un contexto de función asíncrona:

import 'package:meta/meta.dart'; //for @required annotation

void main() async {
  void justWait({@required int numberOfSeconds}) async {
    await Future.delayed(Duration(seconds: numberOfSeconds));
  }

  await justWait(numberOfSeconds: 5);
} 

Este es un simulacro útil que puede tomar un parámetro opcional para simular un error:

  Future _mockService([dynamic error]) {
    return new Future.delayed(const Duration(seconds: 2), () {
      if (error != null) {
        throw error;
      }
    });
  }

Puedes usarlo así:

  await _mockService(new Exception('network error'));

También necesitaba esperar a que se completara un servicio durante una prueba unitaria. Implementé de esta manera:

void main()
{
    test('Send packages using isolate', () async {
        await SendingService().execute();
    });
    // Loop to the amount of time the service will take to complete
    for( int seconds = 0; seconds < 10; seconds++ ) {
        test('Waiting 1 second...', () {
            sleep(const Duration(seconds:1));
        } );
    }
}
...
class SendingService {
    Isolate _isolate;
    Future execute() async {
        ...
        final MyMessage msg = new MyMessage(...);
        ...
        Isolate.spawn(_send, msg)
            .then<Null>((Isolate isolate) => _isolate = isolate);
    }
    static void _send(MyMessage msg) {
        final IMyApi api = new IMyApi();
        api.send(msg.data)
            .then((ignored) {
                ...
            })
            .catchError((e) {
                ...
            } );
    }
}