tests/standalone_2/io/directory_fuzz_test.dart

// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// @dart = 2.9

// 'fuzz' test the directory APIs by providing unexpected type
// arguments. The test passes if the VM does not crash.

import 'dart:async';
import 'dart:io';

import "package:async_helper/async_helper.dart";
import "package:expect/expect.dart";

import 'fuzz_support.dart';
import 'file_write_only_test.dart' show withTempDir, withTempDirSync;

fuzzSyncMethods() {
  withTempDirSync('dart_directory_fuzz', (temp) {
    typeMapping.forEach((k, v) {
      doItSync(() {
        Directory.systemTemp.createTempSync("${temp.path}/$v").deleteSync();
      });
      Directory d;
      doItSync(() => d = new Directory("${temp.path}/$v"));
      if (d == null) return;
      doItSync(d.existsSync);
      doItSync(d.createSync);
      doItSync(d.deleteSync);
      doItSync(d.listSync);
      doItSync(() {
        d.createTempSync('tempdir').deleteSync();
      });
      doItSync(() {
        // Let's be a little careful. If the directory exists we don't
        // want to delete it and all its contents.
        if (!d.existsSync()) d.deleteSync(recursive: true);
      });
      typeMapping.forEach((k2, v2) {
        doItSync(() => d.renameSync(v2));
        doItSync(() => d.listSync(recursive: v2));
      });
    });
  });
}

fuzzAsyncMethods() async {
  asyncStart();
  await withTempDir('dart_directory_fuzz', (temp) async {
    final futures = <Future>[];
    typeMapping.forEach((k, v) {
      futures.add(doItAsync(() {
        Directory.systemTemp.createTempSync("${temp.path}/$v").deleteSync();
      }));
      if (v is! String) {
        Expect.throws(() => new Directory(v),
                      (e) => e is ArgumentError || e is TypeError);
        return;
      }
      var d = new Directory("${temp.path}/$v");
      futures.add(doItAsync(d.exists));
      futures.add(doItAsync(d.create));
      futures.add(doItAsync(d.delete));
      futures.add(doItAsync(() {
        return d.createTemp('tempdir').then((temp) {
          return temp.delete();
        });
      }));
      futures.add(doItAsync(() {
        return d.exists().then((res) {
          if (!res) return d.delete(recursive: true);
          return new Future.value(true);
        });
      }));
      typeMapping.forEach((k2, v2) {
        futures.add(doItAsync(() => d.rename(v2)));
        futures.add(doItAsync(() {
          d.list(recursive: v2).listen((_) {}, onError: (e) => null);
        }));
      });
    });
    await Future.wait(futures).then((_) => asyncEnd());
  });
}

main() {
  fuzzSyncMethods();
  fuzzAsyncMethods();
}