tests/ffi/c_types_test.dart

// 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.
//
// Tests the sizes of c types from https://dartbug.com/36140.
//
// SharedObjects=ffi_test_functions

import 'dart:ffi';
import 'dart:io' show Platform;

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

import 'ffi_test_helpers.dart';

void main() {
  printSizes();
  testSizes();
  testIntAssumptions();
  testSizeTAssumptions();
  testLongAssumptions();
  testWCharTAssumptions();
}

class CType {
  final int ffiSize;
  final int Function(Pointer)? ffiLoad;
  final String modifier;
  final String type;
  final String type2;

  CType(this.ffiSize, this.type,
      {this.type2 = '', this.modifier = '', this.ffiLoad});

  String get cRepresentation => '$modifier $type $type2'.trim();

  String get _getSizeName => 'FfiSizeOf_$modifier\_$type\_$type2';

  String get _getSignName => 'FfiSignOf_$modifier\_$type\_$type2';

  int Function() get sizeFunction => ffiTestFunctions
      .lookupFunction<Uint64 Function(), int Function()>(_getSizeName);

  int Function() get signFunction => ffiTestFunctions
      .lookupFunction<Uint64 Function(), int Function()>(_getSignName);

  int get size => sizeFunction();

  bool get isSigned => signFunction() != 0;

  bool? get ffiIsSigned {
    final ffiLoad_ = ffiLoad;
    if (ffiLoad_ == null) {
      return null;
    }
    assert(size < 8);
    return using((Arena arena) {
      final p = arena<Int64>()..value = -1;
      return ffiLoad_(p) < 0;
    });
  }

  String toString() => cRepresentation;
}

final char = CType(
  sizeOf<Char>(),
  'char',
  ffiLoad: (Pointer p) => p.cast<Char>().value,
);
final uchar = CType(
  sizeOf<UnsignedChar>(),
  'char',
  modifier: 'unsigned',
  ffiLoad: (Pointer p) => p.cast<UnsignedChar>().value,
);
final schar = CType(
  sizeOf<SignedChar>(),
  'char',
  modifier: 'signed',
  ffiLoad: (Pointer p) => p.cast<SignedChar>().value,
);
final short = CType(
  sizeOf<Short>(),
  'short',
  ffiLoad: (Pointer p) => p.cast<Short>().value,
);
final ushort = CType(
  sizeOf<UnsignedShort>(),
  'short',
  modifier: 'unsigned',
  ffiLoad: (Pointer p) => p.cast<UnsignedShort>().value,
);
final int_ = CType(
  sizeOf<Int>(),
  'int',
  ffiLoad: (Pointer p) => p.cast<Int>().value,
);
final uint = CType(
  sizeOf<UnsignedInt>(),
  'int',
  modifier: 'unsigned',
  ffiLoad: (Pointer p) => p.cast<UnsignedInt>().value,
);
final long = CType(
  sizeOf<Long>(),
  'long',
);
final ulong = CType(
  sizeOf<UnsignedLong>(),
  'long',
  modifier: 'unsigned',
);
final longlong = CType(
  sizeOf<LongLong>(),
  'long',
  type2: 'long',
);
final ulonglong = CType(
  sizeOf<UnsignedLongLong>(),
  'long',
  type2: 'long',
  modifier: 'unsigned',
);
final intptr_t = CType(
  sizeOf<IntPtr>(),
  'intptr_t',
);
final uintptr_t = CType(
  sizeOf<UintPtr>(),
  'uintptr_t',
);
final size_t = CType(
  sizeOf<Size>(),
  'size_t',
);
final wchar_t = CType(
  sizeOf<WChar>(),
  'wchar_t',
  ffiLoad: (Pointer p) => p.cast<WChar>().value,
);

final cTypes = [
  char,
  uchar,
  schar,
  short,
  ushort,
  int_,
  uint,
  long,
  ulong,
  longlong,
  ulonglong,
  intptr_t,
  uintptr_t,
  size_t,
  wchar_t,
];

void printSizes() {
  cTypes.forEach((element) {
    final cName = element.cRepresentation.padRight(20);
    final size = element.size;
    final signed = element.isSigned ? 'signed' : 'unsigned';
    print('$cName: $size $signed');
  });
}

void testSizes() {
  cTypes.forEach((element) {
    print(element);
    Expect.equals(element.size, element.ffiSize);
    final ffiIsSigned = element.ffiIsSigned;
    if (ffiIsSigned != null) {
      Expect.equals(element.isSigned, ffiIsSigned);
    }
  });
}

void testIntAssumptions() {
  Expect.equals(4, int_.size);
  Expect.equals(4, uint.size);
}

void testSizeTAssumptions() {
  Expect.equals(intptr_t.size, size_t.size);
}

void testLongAssumptions() {
  if (Platform.isWindows) {
    Expect.equals(4, long.size);
    Expect.equals(4, ulong.size);
  } else {
    Expect.equals(intptr_t.size, long.size);
    Expect.equals(intptr_t.size, ulong.size);
  }
}

void testWCharTAssumptions() {
  final bool isSigned = wchar_t.isSigned;
  print('wchar_t isSigned $isSigned');
  if (Platform.isWindows) {
    Expect.equals(2, wchar_t.size);
    if (isSigned) {
      Expect.equals(-0x8000, wCharMinValue());
      Expect.equals(0x7fff, wCharMaxValue());
    } else {
      Expect.equals(0, wCharMinValue());
      Expect.equals(0xffff, wCharMaxValue());
    }
  } else {
    Expect.equals(4, wchar_t.size);
    if (isSigned) {
      Expect.equals(-0x80000000, wCharMinValue());
      Expect.equals(0x7fffffff, wCharMaxValue());
    } else {
      Expect.equals(0, wCharMinValue());
      Expect.equals(0xffffffff, wCharMaxValue());
    }
  }
}

int Function() wCharMinValue = ffiTestFunctions
    .lookupFunction<Uint64 Function(), int Function()>('WCharMinValue');

int Function() wCharMaxValue = ffiTestFunctions
    .lookupFunction<Uint64 Function(), int Function()>('WCharMaxValue');