sdk/pkg/dartdev/test/resident_frontend_utils_test.dart

// Copyright (c) 2024, 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.

import 'dart:io';

import 'package:dartdev/src/resident_frontend_utils.dart';
import 'package:frontend_server/resident_frontend_server_utils.dart'
    show ResidentCompilerInfo;
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
import 'utils.dart';

void main() {
  late TestProject testProject;
  late File testExecutableFile;

  setUpAll(() async {
    testProject = project(mainSrc: 'void main() {}');
    testExecutableFile = File(path.join(testProject.dirPath, 'exe'));
  });

  group('ResidentCompilerInfo.fromFile', () {
    test('correctly parses resident compiler info files', () async {
      final testInfoFile = File(
        path.join(testProject.dirPath, 'resident_compiler_info.txt'),
      );
      testInfoFile.writeAsStringSync('address:127.0.0.1 port:45678');

      final testInfo = ResidentCompilerInfo.fromFile(testInfoFile);
      expect(testInfo.address.address, '127.0.0.1');
      expect(testInfo.port, 45678);
    });
  });

  group('isFileKernelFile', () {
    test(
      'returns false when passed a file that is too small to contain the kernel magic number',
      () async {
        testExecutableFile.writeAsBytesSync([1, 2, 3]);
        expect(await isFileKernelFile(testExecutableFile), false);
      },
    );

    test(
      'returns false when passed a file that does not start with the kernel magic number',
      () async {
        testExecutableFile.writeAsBytesSync([1, 2, 3, 4]);
        expect(await isFileKernelFile(testExecutableFile), false);
      },
    );

    test(
      'returns true when passed a file that starts with the kernel magic number',
      () async {
        testExecutableFile.writeAsBytesSync([0x90, 0xab, 0xcd, 0xef, 1, 2, 3]);
        expect(await isFileKernelFile(testExecutableFile), true);
      },
    );
  });

  group('isFileAppJitSnapshot', () {
    test(
      'returns false when passed a file that is too small to contain the AppJIT magic number',
      () async {
        testExecutableFile.writeAsBytesSync([1, 2, 3]);
        expect(await isFileAppJitSnapshot(testExecutableFile), false);
      },
    );

    test(
      'returns false when passed a file that does not start with the AppJIT magic number',
      () async {
        testExecutableFile.writeAsBytesSync([1, 2, 3, 4, 5, 6, 7, 8]);
        expect(await isFileAppJitSnapshot(testExecutableFile), false);
      },
    );

    test(
      'returns true when passed a file that starts with the AppJIT magic number',
      () async {
        testExecutableFile.writeAsBytesSync([
          0xdc,
          0xdc,
          0xf6,
          0xf6,
          0,
          0,
          0,
          0,
          1,
          2,
          3,
        ]);
        expect(await isFileAppJitSnapshot(testExecutableFile), true);
      },
    );

    group('isFileAotSnapshot', () {
      test(
        'returns false when passed a file that is too small to contain any of the AOT magic numbers',
        () async {
          testExecutableFile.writeAsBytesSync([1]);
          expect(await isFileAotSnapshot(testExecutableFile), false);
        },
      );

      test(
        'returns false when passed a file that does not start with any of the AOT magic numbers',
        () async {
          testExecutableFile.writeAsBytesSync([1, 2, 3, 4]);
          expect(await isFileAotSnapshot(testExecutableFile), false);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for arm32 COFF files',
        () async {
          testExecutableFile.writeAsBytesSync([0x01, 0xc0, 1, 2, 3]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for arm64 COFF files',
        () async {
          testExecutableFile.writeAsBytesSync([0xaa, 0x64, 1, 2, 3]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for riscv32 COFF files',
        () async {
          testExecutableFile.writeAsBytesSync([0x50, 0x32, 1, 2, 3]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for riscv64 COFF files',
        () async {
          testExecutableFile.writeAsBytesSync([0x50, 0x64, 1, 2, 3]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for ELF files',
        () async {
          testExecutableFile.writeAsBytesSync([
            0x7f,
            0x45,
            0x4c,
            0x46,
            1,
            2,
            3,
          ]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for macho32 files',
        () async {
          testExecutableFile.writeAsBytesSync([
            0xfe,
            0xed,
            0xfa,
            0xce,
            1,
            2,
            3,
          ]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for macho64 files',
        () async {
          testExecutableFile.writeAsBytesSync([
            0xfe,
            0xed,
            0xfa,
            0xcf,
            1,
            2,
            3,
          ]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );

      test(
        'returns true when passed a file that starts with the AOT magic number for macho64_arm64 files',
        () async {
          testExecutableFile.writeAsBytesSync([
            0xcf,
            0xfa,
            0xed,
            0xfe,
            1,
            2,
            3,
          ]);
          expect(await isFileAotSnapshot(testExecutableFile), true);
        },
      );
    });
  });
}