// 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.
//
// Dart test program for testing dart:ffi with null values.
//
// Separated into a separate file to make NNBD testing easier.
//
// VMOptions=
// VMOptions=--deterministic --optimization-counter-threshold=10
// VMOptions=--use-slow-path
// VMOptions=--use-slow-path --stacktrace-every=100
// VMOptions=--write-protect-code --no-dual-map-code
// VMOptions=--write-protect-code --no-dual-map-code --use-slow-path
// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
// SharedObjects=ffi_test_functions

// @dart = 2.9

import 'dart:ffi';

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

import 'dylib_utils.dart';
import 'ffi_test_helpers.dart';

void main() {
  for (int i = 0; i < 100; i++) {
    testPointerStoreNull();
    testEquality();
    testNullReceivers();
    testNullIndices();
    testNullArguments();
    testNullInt();
    testNullDouble();
    testNullManyArgs();
    testException();
    testNullReturnCallback();
  }
}

void testPointerStoreNull() {
  int i = null;
  Pointer<Int8> p = calloc();
  Expect.throws(() => p.value = i);
  calloc.free(p);
  double d = null;
  Pointer<Float> p2 = calloc();
  Expect.throws(() => p2.value = d);
  calloc.free(p2);
  Pointer<Void> x = null;
  Pointer<Pointer<Void>> p3 = calloc();
  Expect.throws(() => p3.value = x);
  calloc.free(p3);
}

void testEquality() {
  Pointer<Int8> p = Pointer.fromAddress(12345678);
  Expect.notEquals(p, null);
  Expect.notEquals(null, p);
}

/// With extension methods, the receiver position can be null.
testNullReceivers() {
  Pointer<Int8> p = calloc();

  Pointer<Int8> p4 = null;
  Expect.throws(() => Expect.equals(10, p4.value));
  Expect.throws(() => p4.value = 10);

  Pointer<Pointer<Int8>> p5 = null;
  Expect.throws(() => Expect.equals(10, p5.value));
  Expect.throws(() => p5.value = p);

  Pointer<Foo> p6 = null;
  Expect.throws(() => Expect.equals(10, p6.ref));

  calloc.free(p);
}

testNullIndices() {
  Pointer<Int8> p = calloc();

  Expect.throws(() => Expect.equals(10, p[null]));
  Expect.throws(() => p[null] = 10);

  Pointer<Pointer<Int8>> p5 = p.cast();
  Expect.throws(() => Expect.equals(10, p5[null]));
  Expect.throws(() => p5[null] = p);

  Pointer<Foo> p6 = p.cast();
  Expect.throws(() => Expect.equals(10, p6[null]));

  calloc.free(p);
}

testNullArguments() {
  Pointer<Int8> p = calloc();
  Expect.throws(() => p.value = null);
  calloc.free(p);
}

class Foo extends Struct {
  @Int8()
  int a;
}

void testNullInt() {
  Expect.throws(() => sumPlus42(43, null));
}

void testNullDouble() {
  Expect.throws(() => times1_337Double(null));
}

void testNullManyArgs() {
  Expect.throws(() => sumManyNumbers(1, 2.0, 3, 4.0, 5, 6.0, 7, 8.0, 9, 10.0,
      11, 12.0, 13, 14.0, 15, 16.0, 17, 18.0, null, 20.0));
}

typedef NativeBinaryOp = Int32 Function(Int32, Int32);
typedef BinaryOp = int Function(int, int);

typedef NativeDoubleUnaryOp = Double Function(Double);
typedef DoubleUnaryOp = double Function(double);

DoubleUnaryOp times1_337Double = ffiTestFunctions
    .lookupFunction<NativeDoubleUnaryOp, DoubleUnaryOp>("Times1_337Double");

typedef NativeVigesimalOp = Double Function(
    IntPtr,
    Float,
    IntPtr,
    Double,
    IntPtr,
    Float,
    IntPtr,
    Double,
    IntPtr,
    Float,
    IntPtr,
    Double,
    IntPtr,
    Float,
    IntPtr,
    Double,
    IntPtr,
    Float,
    IntPtr,
    Double);
typedef VigesimalOp = double Function(
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double,
    int,
    double);

VigesimalOp sumManyNumbers = ffiTestFunctions
    .lookupFunction<NativeVigesimalOp, VigesimalOp>("SumManyNumbers");

// Throw an exception from within the trampoline and collect a stacktrace
// include its frame.
void testException() {
  try {
    sumPlus42(null, null);
  } catch (e, s) {
    return;
  }
  throw "Didn't throw!";
}

BinaryOp sumPlus42 =
    ffiTestFunctions.lookupFunction<NativeBinaryOp, BinaryOp>("SumPlus42");

void testNullReturnCallback() {
  final test =
      Test("ReturnNull", Pointer.fromFunction<ReturnNullType>(returnNull, 42));
  test.run();
}

typedef NativeCallbackTest = Int32 Function(Pointer);
typedef NativeCallbackTestFn = int Function(Pointer);

final DynamicLibrary testLibrary = dlopenPlatformSpecific("ffi_test_functions");

class Test {
  final String name;
  final Pointer callback;
  final bool skip;

  Test(this.name, this.callback, {bool skipIf: false}) : skip = skipIf {}

  void run() {
    if (skip) return;

    final NativeCallbackTestFn tester = testLibrary
        .lookupFunction<NativeCallbackTest, NativeCallbackTestFn>("Test$name");
    final int testCode = tester(callback);
    if (testCode != 0) {
      Expect.fail("Test $name failed.");
    }
  }
}

typedef ReturnNullType = Int32 Function();
int returnNull() {
  return null;
}