[vm/ffi] Split up some tests/ffi into vmspecific and non-vmspecific

The separation will allow flutter/flutter integration tests to run the
non-vmspecific parts.

Change-Id: I0e771f1247ec62d2f0c3faa95ee10560e62524f1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127144
Reviewed-by: Daco Harkes <dacoharkes@google.com>
Commit-Queue: Martin Kustermann <kustermann@google.com>

Author: mkustermann

runtime/bin/BUILD.gn

@@ -1120,9 +1120,14 @@ shared_library("ffi_test_functions") {
   deps = [
     ":dart",
   ]
+
+  # The two files here do not depend on each other.
+  # flutter/flutter integration tests will only use `ffi_test_functions.cc` -
+  # any test functionality using `dart_api.h` has to go into
+  # `ffi_test_functions_vmspecific.cc`.
   sources = [
     "ffi_test/ffi_test_functions.cc",
-    "ffi_test/ffi_test_functions_special.cc",
+    "ffi_test/ffi_test_functions_vmspecific.cc",
   ]
   if (is_win && current_cpu == "x64") {
     sources += [ "ffi_test/clobber_x64_win.S" ]

runtime/bin/ffi_test/ffi_test_functions.cc

@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 
 // This file contains test functions for the dart:ffi test cases.
+// This file is not allowed to depend on any symbols from the embedder and is
+// therefore not allowed to use `dart_api.h`. (The flutter/flutter integration
+// tests will run dart tests using this library only.)
 
 #include <stddef.h>
 #include <stdlib.h>

runtime/bin/ffi_test/ffi_test_functions_special.cc renamed to runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc

@@ -17,7 +17,7 @@ function_callbacks_test/03: Skip
 *: Skip # "hardfp" calling convention is not yet supported (iOS is also supported but not tested): dartbug.com/36309
 
 [ $compiler == dart2analyzer ]
-enable_ffi_test: SkipByDesign # This is a check for VM only.
+vmspecific_enable_ffi_test: SkipByDesign # This is a check for VM only.
 
 [ $runtime != dart_precompiled && $runtime != vm && $compiler != dart2analyzer ]
 *: SkipByDesign # FFI is a VM-only feature. (This test suite is part of the default set.)

tests/ffi/ffi.status

@@ -2,9 +2,6 @@
 // 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.
 
-// VMOptions=--enable-testing-pragmas --enable-isolate-groups
-// VMOptions=--enable-testing-pragmas --no-enable-isolate-groups
-//
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
 // VMOptions=--enable-testing-pragmas
@@ -19,7 +16,6 @@
 
 import 'dart:io';
 import 'dart:ffi';
-import 'dart:isolate';
 import 'dylib_utils.dart';
 
 import "package:expect/expect.dart";
@@ -176,19 +172,6 @@ Pointer<Void> throwExceptionPointer() {
   throw "Exception.";
 }
 
-void testGC() {
-  triggerGc();
-}
-
-typedef WaitForHelperNative = Void Function(Pointer<Void>);
-typedef WaitForHelper = void Function(Pointer<Void>);
-
-void waitForHelper(Pointer<Void> helper) {
-  print("helper: $helper");
-  testLibrary
-      .lookupFunction<WaitForHelperNative, WaitForHelper>("WaitForHelper")(helper);
-}
-
 final List<Test> testcases = [
   Test("SimpleAddition",
       Pointer.fromFunction<SimpleAdditionType>(simpleAddition, 0)),
@@ -213,65 +196,10 @@ final List<Test> testcases = [
       Pointer.fromFunction<ThrowExceptionPointer>(throwExceptionPointer)),
   Test("ThrowException",
       Pointer.fromFunction<ThrowExceptionInt>(throwExceptionInt, 42)),
-  Test("GC", Pointer.fromFunction<ReturnVoid>(testGC)),
-  Test("UnprotectCode", Pointer.fromFunction<WaitForHelperNative>(waitForHelper)),
 ];
 
-testCallbackWrongThread() =>
-    Test("CallbackWrongThread", Pointer.fromFunction<ReturnVoid>(returnVoid))
-        .run();
-
-testCallbackOutsideIsolate() =>
-    Test("CallbackOutsideIsolate", Pointer.fromFunction<ReturnVoid>(returnVoid))
-        .run();
-
-isolateHelper(int callbackPointer) {
-  final Pointer<Void> ptr = Pointer.fromAddress(callbackPointer);
-  final NativeCallbackTestFn tester =
-      testLibrary.lookupFunction<NativeCallbackTest, NativeCallbackTestFn>(
-          "TestCallbackWrongIsolate");
-  Expect.equals(0, tester(ptr));
-}
-
-testCallbackWrongIsolate() async {
-  final int callbackPointer =
-      Pointer.fromFunction<ReturnVoid>(returnVoid).address;
-  final ReceivePort exitPort = ReceivePort();
-  await Isolate.spawn(isolateHelper, callbackPointer,
-      errorsAreFatal: true, onExit: exitPort.sendPort);
-  await exitPort.first;
-}
-
-const double zeroPointZero = 0.0;
-
-// Correct type of exceptionalReturn argument to Pointer.fromFunction.
-double testExceptionalReturn() {
-  Pointer.fromFunction<Double Function()>(testExceptionalReturn, 0.0);
-  Pointer.fromFunction<Double Function()>(testExceptionalReturn, zeroPointZero);
-
-  Pointer.fromFunction<Double Function()>(returnVoid, null);  //# 59: compile-time error
-  Pointer.fromFunction<Void Function()>(returnVoid, 0);  //# 60: compile-time error
-  Pointer.fromFunction<Double Function()>(testExceptionalReturn, "abc");  //# 61: compile-time error
-  Pointer.fromFunction<Double Function()>(testExceptionalReturn, 0);  //# 62: compile-time error
-  Pointer.fromFunction<Double Function()>(testExceptionalReturn);  //# 63: compile-time error
-
-  return 0.0;  // not used
-}
-
 void main() async {
   testcases.forEach((t) => t.run()); //# 00: ok
-  testExceptionalReturn(); //# 00: ok
-
-  // These tests terminate the process after successful completion, so we have
-  // to run them separately.
-  //
-  // Since they use signal handlers they only run on Linux.
-  if (Platform.isLinux && !const bool.fromEnvironment("dart.vm.product")) {
-    testCallbackWrongThread(); //# 01: ok
-    testCallbackOutsideIsolate(); //# 02: ok
-    await testCallbackWrongIsolate(); //# 03: ok
-  }
-
   testManyCallbacks(); //# 04: ok
 }
 

tests/ffi/function_callbacks_test.dart

@@ -42,11 +42,10 @@ void main() {
     testVoidReturn();
     testNoArgs();
     testException();
-    testLookupFunctionPointerNativeType();
   }
 }
 
-DynamicLibrary ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");
+final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");
 
 typedef NativeBinaryOp = Int32 Function(Int32, Int32);
 typedef UnaryOp = int Function(int);
@@ -404,24 +403,12 @@ void testNoArgs() {
   Expect.approxEquals(1337.0, result);
 }
 
-typedef NativeTypeNFT = Pointer<NativeType> Function(
-    Pointer<Pointer<NativeType>>, Int8);
-typedef NativeTypeFT = Pointer<NativeType> Function(
-    Pointer<Pointer<NativeType>>, int);
-
-void testLookupFunctionPointerNativeType() {
-  // The function signature does not match up, but that does not matter since
-  // this test does not use the trampoline.
-  ffiTestFunctions.lookupFunction<NativeTypeNFT, NativeTypeFT>("LargePointer");
-}
-
 // Throw an exception from within the trampoline and collect a stacktrace
 // include its frame.
 void testException() {
   try {
     sumPlus42(null, null);
   } catch (e, s) {
-    print("$e, $s");
     return;
   }
   throw "Didn't throw!";

tests/ffi/function_test.dart

@@ -102,18 +102,12 @@ Future generateCLibs(String sdkRoot, String destDir, Set<String> allFiles,
       path.join(sdkRoot, 'runtime/bin/ffi_test/ffi_test_dynamic_library.cc');
   destinationFile =
       path.join(dir.path, path.basename(lib1)).replaceAll('.cc', '.cpp');
-  File(destinationFile)
-      .writeAsStringSync(cleanCC(File(lib1).readAsStringSync()));
+  File(destinationFile).writeAsStringSync(File(lib1).readAsStringSync());
 
   final lib2 = path.join(sdkRoot, 'runtime/bin/ffi_test/ffi_test_functions.cc');
   destinationFile =
       path.join(dir.path, path.basename(lib2)).replaceAll('.cc', '.cpp');
-  File(destinationFile)
-      .writeAsStringSync(cleanCC(File(lib2).readAsStringSync()));
-}
-
-String cleanCC(String content) {
-  return content.replaceAll('DART_EXPORT', 'extern "C" ');
+  File(destinationFile).writeAsStringSync(File(lib2).readAsStringSync());
 }
 
 String cleanDart(String content) {
@@ -125,21 +119,23 @@ Future generateDartTests(
   final dir = await generateCleanDir(destDir);
 
   final sink = File(path.join(dir.path, 'all.dart')).openWrite();
+  sink.writeln('import "dart:async";');
+  sink.writeln('');
   for (int i = 0; i < testFiles.length; ++i) {
     sink.writeln('import "${path.basename(testFiles[i])}" as main$i;');
   }
   sink.writeln('');
-  sink.writeln('invoke(fn) {');
-  sink.writeln('  if (fn is void Function()) {');
-  sink.writeln('    fn();');
+  sink.writeln('Future invoke(dynamic fun) async {');
+  sink.writeln('  if (fun is void Function() || fun is Future Function()) {');
+  sink.writeln('    return await fun();');
   sink.writeln('  } else {');
-  sink.writeln('    fn(<String>[]);');
+  sink.writeln('    return await fun(<String>[]);');
   sink.writeln('  }');
   sink.writeln('}');
   sink.writeln('');
-  sink.writeln('main() {');
+  sink.writeln('dynamic main() async {');
   for (int i = 0; i < testFiles.length; ++i) {
-    sink.writeln('  invoke(main$i.main);');
+    sink.writeln('  await invoke(main$i.main);');
   }
   sink.writeln('}');
   await sink.close();
@@ -166,32 +162,19 @@ Stream<String> listTestFiles(
   await for (final file in Directory(path.join(sdkRoot, 'tests/ffi')).list()) {
     if (file is File && file.path.endsWith('_test.dart')) {
       // These tests are VM specific and cannot necessarily be run on Flutter.
-      final blacklistedTests = const [
-        'function_callbacks_test.dart',
-        'function_callbacks_test.dart',
-        'function_gc_test.dart',
-        'function_test.dart',
-        'object_gc_test.dart',
-        'regress_37100_test.dart',
-        'regress_37511_callbacks_test.dart',
-        'regress_37511_test.dart',
-        'regress_37780_test.dart',
-      ];
-      if (blacklistedTests.contains(path.basename(file.path))) {
+      if (path.basename(file.path).startsWith('vmspecific_')) {
         filteredTests.add(file.path);
         continue;
       }
+      // These tests use special features which are hard to test on Flutter.
       final contents = file.readAsStringSync();
-      if (!contents.contains('//#') &&
-          !contents.contains('dart:async') &&
-          !contents.contains('dart:isolate') &&
-          !contents.contains('async') &&
-          !contents.contains('Future') &&
-          !contents.contains('DynamicLibrary.process') &&
-          !contents.contains('DynamicLibrary.executable') &&
-          !contents.contains('Future')) {
-        yield file.path;
+      if (contents.contains(RegExp('//# .* compile-time error')) ||
+          contents.contains('DynamicLibrary.process') ||
+          contents.contains('DynamicLibrary.executable')) {
+        filteredTests.add(file.path);
+        continue;
       }
+      yield file.path;
     }
   }
 }

tests/ffi/prepare_flutter_bundle.dart

@@ -0,0 +1,13 @@
+// Copyright (c) 2019, 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.
+//
+// SharedObjects=ffi_test_functions
+
+import 'dart:ffi';
+
+import "package:expect/expect.dart";
+
+void main() async {
+  Expect.equals(true, 4 == sizeOf<Pointer>() || 8 == sizeOf<Pointer>());
+}