sdk/tests/standalone/io/directory_rename_test.dart

// Copyright (c) 2021, 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.
//
// Directory rename test.

import "dart:io";

import "package:expect/expect.dart";
import 'test_utils.dart' show withTempDir;

testRenameToNewPath() async {
  await withTempDir('testRenameToNewPath', (Directory tempDir) async {
    final dir1 = Directory("${tempDir.path}/dir1");
    dir1.createSync();

    dir1.renameSync("${tempDir.path}/dir2");
    Expect.isTrue(Directory("${tempDir.path}/dir2").existsSync());
  });
}

testRenamePath() async {
  // Verifies that the returned directory has the correct path.
  await withTempDir('testRenameToNewPath', (Directory tempDir) async {
    final oldDir = Directory("${tempDir.path}/dir1");
    oldDir.createSync();

    final newDir = oldDir.renameSync("${tempDir.path}/dir2");

    Expect.isTrue(
      oldDir.path == "${tempDir.path}/dir1",
      "${oldDir.path} != '${tempDir.path}/dir1'"
      "- path should not be updated",
    );
    Expect.isTrue(
      newDir.path == "${tempDir.path}/dir2",
      "${newDir.path} != '${tempDir.path}/dir2'"
      "- path should be updated",
    );
  });
}

testRenameToSamePath() async {
  await withTempDir('testRenameToSamePath', (Directory tempDir) async {
    final dir = Directory("${tempDir.path}/dir");
    dir.createSync();
    final file = File("${dir.path}/file");
    file.createSync();

    dir.renameSync(dir.path);
    Expect.isTrue(file.existsSync());
  });
}

testRenameToExistingFile() async {
  await withTempDir('testRenameToExistingFile', (Directory tempDir) async {
    final dir = Directory("${tempDir.path}/dir");
    dir.createSync();
    final file = File("${tempDir.path}/file");
    file.createSync();

    // Overwriting an existing file is not allowed.
    try {
      dir.renameSync(file.path);
      Expect.fail('Directory.rename should fail to rename a non-directory');
    } on FileSystemException catch (e) {
      if (Platform.isWindows) {
        Expect.isTrue(
          e.osError!.message.contains('file already exists'),
          'Unexpected error: $e',
        );
      } else if (Platform.isLinux || Platform.isMacOS) {
        Expect.isTrue(
          e.osError!.message.contains('Not a directory'),
          'Unexpected error: $e',
        );
      }
    }
  });
}

testRenameToExistingEmptyDirectory() async {
  await withTempDir('testRenameToExistingEmptyDirectory', (
    Directory tempDir,
  ) async {
    final dir1 = Directory("${tempDir.path}/dir1");
    dir1.createSync();
    File("${dir1.path}/file").createSync();

    final dir2 = Directory("${tempDir.path}/dir2");
    dir2.createSync();

    try {
      dir1.renameSync(dir2.path);
      // Verify that the file contained in dir1 has been moved.
      if (Platform.isWindows) {
        Expect.fail(
          'Directory.rename should fail to rename over an existing directory '
          'on Windows',
        );
      } else {
        Expect.isTrue(File("${dir2.path}/file").existsSync());
      }
    } on FileSystemException catch (e) {
      if (Platform.isWindows) {
        Expect.isTrue(e.osError!.message.contains('file already exists'));
      } else {
        Expect.fail('Directory.rename should allow moves to empty directories');
      }
    }
  });
}

testRenameToExistingNonEmptyDirectory() async {
  await withTempDir('testRenameToExistingNonEmptyDirectory', (
    Directory tempDir,
  ) async {
    final dir1 = Directory("${tempDir.path}/dir1");
    dir1.createSync();
    File("${dir1.path}/file1").createSync();

    final dir2 = Directory("${tempDir.path}/dir2");
    dir2.createSync();
    File("${dir2.path}/file2").createSync();

    try {
      dir1.renameSync(dir2.path);
      Expect.fail(
        'Directory.rename should fail to rename a non-empty directory',
      );
    } on FileSystemException catch (e) {
      if (Platform.isWindows) {
        Expect.isTrue(
          e.osError!.message.contains('file already exists'),
          'Unexpected error: $e',
        );
      } else if (Platform.isLinux || Platform.isMacOS) {
        Expect.isTrue(
          e.osError!.message.contains('Directory not empty'),
          'Unexpected error: $e',
        );
      }
    }
  });
}

testRenameButActuallyFile() async {
  await withTempDir('testRenameButActuallyFile', (Directory tempDir) async {
    final file = File("${tempDir.path}/file");
    file.createSync();
    final dir = Directory(file.path);
    try {
      dir.renameSync("${tempDir.path}/dir");
      Expect.fail("Expected a failure to rename the file.");
    } on FileSystemException catch (e) {
      Expect.isTrue(
        e.message.contains('Rename failed'),
        'Unexpected error: $e',
      );
      if (Platform.isWindows) {
        Expect.isTrue(
          e.osError!.message.contains('cannot find the file'),
          'Unexpected error: $e',
        );
      } else if (Platform.isLinux || Platform.isMacOS) {
        Expect.isTrue(
          e.osError!.message.contains('Not a directory'),
          'Unexpected error: $e',
        );
      }
    }
  });
}

main() async {
  await testRenameToNewPath();
  await testRenamePath();
  await testRenameToSamePath();
  await testRenameToExistingFile();
  await testRenameToExistingEmptyDirectory();
  await testRenameToExistingNonEmptyDirectory();
  await testRenameButActuallyFile();
}