tests/ffi/function_callbacks_subtype_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.

// Dart test program for testing dart:ffi callbacks that take advantage of
// subtyping rules.
//
// VMOptions=
// VMOptions=--stacktrace-every=100
// VMOptions=--use-slow-path
// VMOptions=--use-slow-path --stacktrace-every=100
// VMOptions=--dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
// VMOptions=--test_il_serialization
// VMOptions=--profiler --profile_vm=true
// VMOptions=--profiler --profile_vm=false
// SharedObjects=ffi_test_functions

import 'dart:async';
import 'dart:ffi';

import "package:expect/expect.dart";

import 'dylib_utils.dart';

final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");

typedef TwoIntVoidFnNativeType = Void Function(Pointer, Int32, Int32);
typedef TwoIntVoidFnType = void Function(Pointer, int, int);
final callTwoIntVoidFunction = ffiTestFunctions
    .lookupFunction<TwoIntVoidFnNativeType, TwoIntVoidFnType>(
      "CallTwoIntVoidFunction",
    );

typedef TwoIntPointerFnNativeType =
    Pointer<NativeType> Function(Pointer, Int32, Int32);
typedef TwoIntPointerFnType = Pointer<NativeType> Function(Pointer, int, int);
final callTwoIntPointerFunction = ffiTestFunctions
    .lookupFunction<TwoIntPointerFnNativeType, TwoIntPointerFnType>(
      "CallTwoIntPointerFunction",
    );

typedef TwoPointerIntFnNativeType =
    Int32 Function(Pointer, Pointer<NativeType>, Pointer<NativeType>);
typedef TwoPointerIntFnType =
    int Function(Pointer, Pointer<NativeType>, Pointer<NativeType>);
final callTwoPointerIntFunction = ffiTestFunctions
    .lookupFunction<TwoPointerIntFnNativeType, TwoPointerIntFnType>(
      "CallTwoPointerIntFunction",
    );

typedef VoidReturnFunction = Void Function(Int32, Int32);
int addVoidResult = 0;
int addVoid(int x, int y) {
  print("addVoid($x, $y)");
  addVoidResult = x + y;
  return addVoidResult;
}

final addVoidAsyncResult = Completer<int>();
int addVoidAsync(int x, int y) {
  print("addVoidAsync($x, $y)");
  final result = x + y;
  addVoidAsyncResult.complete(result);
  return result;
}

typedef NaTyPtrReturnFunction = Pointer<NativeType> Function(Int32, Int32);
Pointer<Int64> addInt64PtrReturn(int x, int y) {
  print("addInt64PtrReturn($x, $y)");
  return Pointer<Int64>.fromAddress(x + y);
}

typedef Int64PtrParamFunction = Int32 Function(Pointer<Int64>, Pointer<Int64>);
int addNaTyPtrParam(Pointer<NativeType> x, Pointer<NativeType> y) {
  print("addNaTyPtrParam($x, $y)");
  return x.address + y.address;
}

Future<void> main() async {
  await testReturnVoid();
  testReturnSubtype();
  testParamSubtype();
  print("Done! :)");
}

Future<void> testReturnVoid() async {
  // If the native function type returns void, the Dart function can return
  // anything.
  final legacyCallback = Pointer.fromFunction<VoidReturnFunction>(addVoid);
  callTwoIntVoidFunction(legacyCallback, 100, 23);
  Expect.equals(123, addVoidResult);

  final isolateLocal = NativeCallable<VoidReturnFunction>.isolateLocal(addVoid)
    ..keepIsolateAlive = false;
  callTwoIntVoidFunction(isolateLocal.nativeFunction, 400, 56);
  Expect.equals(456, addVoidResult);

  final listener = NativeCallable<VoidReturnFunction>.listener(addVoidAsync)
    ..keepIsolateAlive = false;
  callTwoIntVoidFunction(listener.nativeFunction, 700, 89);
  Expect.equals(789, await addVoidAsyncResult.future);
}

void testReturnSubtype() {
  // The Dart function is allowed to return a subtype of the native return type.
  final legacyCallback = Pointer.fromFunction<NaTyPtrReturnFunction>(
    addInt64PtrReturn,
  );
  Expect.equals(
    123,
    callTwoIntPointerFunction(legacyCallback, 100, 23).address,
  );

  final isolateLocal = NativeCallable<NaTyPtrReturnFunction>.isolateLocal(
    addInt64PtrReturn,
  )..keepIsolateAlive = false;
  Expect.equals(
    456,
    callTwoIntPointerFunction(isolateLocal.nativeFunction, 400, 56).address,
  );
}

void testParamSubtype() {
  // The Dart function is allowed to accept params that are a supertype of the
  // native type's params.
  final legacyCallback = Pointer.fromFunction<Int64PtrParamFunction>(
    addNaTyPtrParam,
    0,
  );
  Expect.equals(
    123,
    callTwoPointerIntFunction(
      legacyCallback,
      Pointer<Int64>.fromAddress(100),
      Pointer<Int64>.fromAddress(23),
    ),
  );

  final isolateLocal = NativeCallable<Int64PtrParamFunction>.isolateLocal(
    addNaTyPtrParam,
    exceptionalReturn: 0,
  )..keepIsolateAlive = false;
  Expect.equals(
    456,
    callTwoPointerIntFunction(
      isolateLocal.nativeFunction,
      Pointer<Int64>.fromAddress(400),
      Pointer<Int64>.fromAddress(56),
    ),
  );
}