diff --git a/src/Generation/Generator/Model/Type.cs b/src/Generation/Generator/Model/Type.cs index fe268b10f..02e51a810 100644 --- a/src/Generation/Generator/Model/Type.cs +++ b/src/Generation/Generator/Model/Type.cs @@ -19,9 +19,11 @@ public static string GetName(GirModel.Type type) GirModel.SignedByte => "sbyte", GirModel.Short => "short", GirModel.Long => "long", + GirModel.CLong => "long", GirModel.UnsignedShort => "ushort", GirModel.UnsignedInteger => "uint", GirModel.UnsignedLong => "ulong", + GirModel.UnsignedCLong => "ulong", GirModel.Byte => "byte", GirModel.Bool => "bool", GirModel.Void => "void", diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs new file mode 100644 index 000000000..fb8200ac0 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs @@ -0,0 +1,25 @@ +namespace Generator.Renderer.Internal.Field; + +internal class CLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + Attribute: null, + NullableTypeName: GetNullableTypeName(field) + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : "CLong"; + } +} diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs index 0b70ef722..38534a169 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs @@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field) { return field.IsPointer ? Model.Type.Pointer - : "CLong"; + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); } } diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..46a9da47f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs @@ -0,0 +1,25 @@ +namespace Generator.Renderer.Internal.Field; + +internal class UnsignedCLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + Attribute: null, + NullableTypeName: GetNullableTypeName(field) + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : "CULong"; + } +} diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs index 7269e71f2..687235bba 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs @@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field) { return field.IsPointer ? Model.Type.Pointer - : "CULong"; + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); } } diff --git a/src/Generation/Generator/Renderer/Internal/Field/Fields.cs b/src/Generation/Generator/Renderer/Internal/Field/Fields.cs index 12382baeb..d37ba8ea7 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Fields.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Fields.cs @@ -21,6 +21,8 @@ internal static class Fields new Field.PointerArray(), new Field.Long(), //Must be before primitive value new Field.UnsignedLong(), //Must be before primitive value + new Field.CLong(), //Must be before primitive value + new Field.UnsignedCLong(), //Must be before primitive value new Field.PrimitiveValueType(), new Field.PrimitiveValueTypeAlias(), new Field.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs b/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs index 0ada82832..e7a717d58 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs @@ -27,6 +27,8 @@ internal static class CallbackParameters new Parameter.PointerGLibPtrArray(), new Parameter.Long(), //Must be before primitive value type new Parameter.UnsignedLong(), //Must be before primitive value type + new Parameter.CLong(), //Must be before primitive value type + new Parameter.UnsignedCLong(), //Must be before primitive value type new Parameter.PrimitiveValueType(), new Parameter.PrimitiveValueTypeAlias(), new Parameter.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs new file mode 100644 index 000000000..dbe1a9e8f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs @@ -0,0 +1,44 @@ +using System; + +namespace Generator.Renderer.Internal.Parameter; + +internal class CLong : ParameterConverter +{ + public bool Supports(GirModel.AnyType anyType) + { + return anyType.Is(); + } + + public RenderableParameter Convert(GirModel.Parameter parameter) + { + // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly + // ownership transfer (this combination does not currently occur for any functions). + if (parameter is { Nullable: true, Optional: true }) + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported"); + + // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. + if (parameter.Nullable) + Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + + // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) + if (parameter.CallerAllocates) + Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + + return new RenderableParameter( + Attribute: string.Empty, + Direction: GetDirection(parameter), + NullableTypeName: "CLong", + Name: Model.Parameter.GetName(parameter) + ); + } + + private static string GetDirection(GirModel.Parameter parameter) => parameter switch + { + // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired. + { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), + { Direction: GirModel.Direction.In } => ParameterDirection.In(), + _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.") + }; +} diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs index b1055f050..a52c36ce3 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs @@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter) // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly // ownership transfer (this combination does not currently occur for any functions). if (parameter is { Nullable: true, Optional: true }) - throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported"); + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported"); // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. if (parameter.Nullable) - Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) if (parameter.CallerAllocates) - Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); return new RenderableParameter( Attribute: string.Empty, Direction: GetDirection(parameter), - NullableTypeName: "CLong", + NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0), Name: Model.Parameter.GetName(parameter) ); } @@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter) { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), { Direction: GirModel.Direction.In } => ParameterDirection.In(), - _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.") + _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.") }; } diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..17a13bc3d --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs @@ -0,0 +1,44 @@ +using System; + +namespace Generator.Renderer.Internal.Parameter; + +internal class UnsignedCLong : ParameterConverter +{ + public bool Supports(GirModel.AnyType anyType) + { + return anyType.Is(); + } + + public RenderableParameter Convert(GirModel.Parameter parameter) + { + // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly + // ownership transfer (this combination does not currently occur for any functions). + if (parameter is { Nullable: true, Optional: true }) + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported"); + + // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. + if (parameter.Nullable) + Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + + // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) + if (parameter.CallerAllocates) + Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + + return new RenderableParameter( + Attribute: string.Empty, + Direction: GetDirection(parameter), + NullableTypeName: "CULong", + Name: Model.Parameter.GetName(parameter) + ); + } + + private static string GetDirection(GirModel.Parameter parameter) => parameter switch + { + // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired. + { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), + { Direction: GirModel.Direction.In } => ParameterDirection.In(), + _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.") + }; +} diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs index d5396f0e1..48833c472 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs @@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter) // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly // ownership transfer (this combination does not currently occur for any functions). if (parameter is { Nullable: true, Optional: true }) - throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported"); + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported"); // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. if (parameter.Nullable) - Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) if (parameter.CallerAllocates) - Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); return new RenderableParameter( Attribute: string.Empty, Direction: GetDirection(parameter), - NullableTypeName: "CULong", + NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0), Name: Model.Parameter.GetName(parameter) ); } @@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter) { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), { Direction: GirModel.Direction.In } => ParameterDirection.In(), - _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.") + _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.") }; } diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs index 144b0c531..081cb83d9 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs @@ -32,6 +32,8 @@ internal static class Parameters new Parameter.PointerGLibPtrArray(), new Parameter.Long(), //Must be before primitive value type new Parameter.UnsignedLong(), //Must be before primitive value type + new Parameter.CLong(), //Must be before primitive value type + new Parameter.UnsignedCLong(), //Must be before primitive value type new Parameter.PrimitiveValueType(), new Parameter.PrimitiveValueTypeAlias(), new Parameter.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs new file mode 100644 index 000000000..463cd2954 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Internal.ParameterToManagedExpressions; + +internal class CLong : ToManagedParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToManagedData parameterData, IEnumerable parameters) + { + switch (parameterData.Parameter) + { + case { Direction: GirModel.Direction.In, IsPointer: false }: + Direct(parameterData); + break; + default: + throw new NotImplementedException($"This kind of internal long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently."); + } + } + + private static void Direct(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"{variableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs index eb69e0b5e..5f02d8e6f 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs @@ -12,19 +12,41 @@ public void Initialize(ParameterToManagedData parameterData, IEnumerable variableName); + parameterData.SetCallName(() => $"ref {variableName}"); + } + private static void Direct(ParameterToManagedData parameterData) { var variableName = Model.Parameter.GetName(parameterData.Parameter); parameterData.SetSignatureName(() => variableName); - parameterData.SetCallName(() => $"{variableName}.Value"); + parameterData.SetCallName(() => variableName); + } + + private static void Out(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"out {variableName}"); } } diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..daef63381 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Internal.ParameterToManagedExpressions; + +internal class UnsignedCLong : ToManagedParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToManagedData parameterData, IEnumerable parameters) + { + switch (parameterData.Parameter) + { + case { Direction: GirModel.Direction.In, IsPointer: false }: + Direct(parameterData); + break; + default: + throw new NotImplementedException($"This kind of internal unsigned long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently."); + } + } + + private static void Direct(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"{variableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs index 97e667229..0300cf5be 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs @@ -12,19 +12,41 @@ public void Initialize(ParameterToManagedData parameterData, IEnumerable variableName); + parameterData.SetCallName(() => $"ref {variableName}"); + } + private static void Direct(ParameterToManagedData parameterData) { var variableName = Model.Parameter.GetName(parameterData.Parameter); parameterData.SetSignatureName(() => variableName); - parameterData.SetCallName(() => $"{variableName}.Value"); + parameterData.SetCallName(() => variableName); + } + + private static void Out(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"out {variableName}"); } } diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs index c02d67e18..0bc64b99b 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs @@ -21,6 +21,8 @@ internal static class ParameterToManagedExpression new ParameterToManagedExpressions.PointerAlias(), new ParameterToManagedExpressions.Long(), //Must be before primitive value type new ParameterToManagedExpressions.UnsignedLong(), //Must be before primitive value type + new ParameterToManagedExpressions.CLong(), //Must be before primitive value type + new ParameterToManagedExpressions.UnsignedCLong(), //Must be before primitive value type new ParameterToManagedExpressions.PrimitiveValueType(), new ParameterToManagedExpressions.PrimitiveValueTypeAlias(), new ParameterToManagedExpressions.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs new file mode 100644 index 000000000..791ce5d64 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs @@ -0,0 +1,18 @@ +namespace Generator.Renderer.Internal.ReturnType; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.ReturnType returnType) + { + return returnType.AnyType.Is(); + } + + public RenderableReturnType Convert(GirModel.ReturnType returnType) + { + var nullableTypeName = returnType.IsPointer + ? Model.Type.Pointer + : "CLong"; + + return new RenderableReturnType(nullableTypeName); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs index b8b12d08b..4152a69e7 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs @@ -11,7 +11,7 @@ public RenderableReturnType Convert(GirModel.ReturnType returnType) { var nullableTypeName = returnType.IsPointer ? Model.Type.Pointer - : "CLong"; + : Model.Type.GetName(returnType.AnyType.AsT0); return new RenderableReturnType(nullableTypeName); } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..bd2da332e --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs @@ -0,0 +1,18 @@ +namespace Generator.Renderer.Internal.ReturnType; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(GirModel.ReturnType returnType) + { + return returnType.AnyType.Is(); + } + + public RenderableReturnType Convert(GirModel.ReturnType returnType) + { + var nullableTypeName = returnType.IsPointer + ? Model.Type.Pointer + : "CULong"; + + return new RenderableReturnType(nullableTypeName); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs index 02c52fc3b..6fb7dcb69 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs @@ -11,7 +11,7 @@ public RenderableReturnType Convert(GirModel.ReturnType returnType) { var nullableTypeName = returnType.IsPointer ? Model.Type.Pointer - : "CULong"; + : Model.Type.GetName(returnType.AnyType.AsT0); return new RenderableReturnType(nullableTypeName); } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs index 6c800edbe..d24eb70df 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs @@ -21,6 +21,8 @@ internal static class ReturnTypeRenderer new ReturnType.PointerAlias(), new ReturnType.Long(), //Must be before primitive value type new ReturnType.UnsignedLong(), //Must be before primitive value type + new ReturnType.CLong(), //Must be before primitive value type + new ReturnType.UnsignedCLong(), //Must be before primitive value type new ReturnType.PrimitiveValueType(), new ReturnType.PrimitiveValueTypeAlias(), new ReturnType.PrimitiveValueTypeAliasArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs index cdc5998b9..984780610 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs @@ -18,8 +18,10 @@ internal static class ReturnTypeRendererCallback new ReturnType.PlatformStringInCallback(), new ReturnType.PlatformStringArrayInCallback(), new ReturnType.Pointer(), - new ReturnType.Long(), - new ReturnType.UnsignedLong(), + new ReturnType.Long(), //Must be before primitive value type + new ReturnType.UnsignedLong(), //Must be before primitive value type + new ReturnType.CLong(), //Must be before primitive value type + new ReturnType.UnsignedCLong(), //Must be before primitive value type new ReturnType.PrimitiveValueType(), new ReturnType.PrimitiveValueTypeAlias(), new ReturnType.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs new file mode 100644 index 000000000..ec6710d89 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs @@ -0,0 +1,10 @@ +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public string GetString(GirModel.ReturnType returnType, string fromVariableName) + => $"new CLong(checked((nint){fromVariableName}))"; +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs index a85d2d855..ea0f23575 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs @@ -1,10 +1,12 @@ -namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; +using GirModel; + +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; internal class Long : ReturnTypeConverter { - public bool Supports(GirModel.AnyType type) + public bool Supports(AnyType type) => type.Is(); public string GetString(GirModel.ReturnType returnType, string fromVariableName) - => $"new CLong(checked((nint){fromVariableName}))"; + => fromVariableName; } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..abccc342f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,10 @@ +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public string GetString(GirModel.ReturnType returnType, string fromVariableName) + => $"new CULong(checked((nuint){fromVariableName}))"; +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs index d12586849..99920c3cb 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs @@ -1,10 +1,12 @@ -namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; +using GirModel; -internal class UnsigendLong : ReturnTypeConverter +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class UnsignedLong : ReturnTypeConverter { - public bool Supports(GirModel.AnyType type) + public bool Supports(AnyType type) => type.Is(); public string GetString(GirModel.ReturnType returnType, string fromVariableName) - => $"new CULong(checked((nuint){fromVariableName}))"; + => fromVariableName; } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs index 1ec15ad88..54ba488b1 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs @@ -15,7 +15,9 @@ internal static class ReturnTypeToNativeExpression new ReturnTypeToNativeExpressions.OpaqueUntypedRecord(), new ReturnTypeToNativeExpressions.Pointer(), new ReturnTypeToNativeExpressions.Long(), //Must be before Primitive value type - new ReturnTypeToNativeExpressions.UnsigendLong(), //Must be before primitive value type + new ReturnTypeToNativeExpressions.UnsignedLong(), //Must be before Primitive value type + new ReturnTypeToNativeExpressions.CLong(), //Must be before Primitive value type + new ReturnTypeToNativeExpressions.UnsignedCLong(), //Must be before primitive value type new ReturnTypeToNativeExpressions.PrimitiveValueType(), new ReturnTypeToNativeExpressions.PrimitiveValueTypeAlias(), new ReturnTypeToNativeExpressions.TypedRecord(), diff --git a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs index 0c45552ea..31637c118 100644 --- a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs +++ b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs @@ -31,6 +31,7 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.Byte => byte.TryParse(constant.Value, out _), GirModel.Double => double.TryParse(constant.Value, out _), GirModel.Integer => int.TryParse(constant.Value, out _), + GirModel.CLong => long.TryParse(constant.Value, out _), GirModel.Long => long.TryParse(constant.Value, out _), GirModel.NativeInteger => nint.TryParse(constant.Value, out _), GirModel.NativeUnsignedInteger => nuint.TryParse(constant.Value, out _), @@ -38,6 +39,7 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.SignedByte => sbyte.TryParse(constant.Value, out _), GirModel.UnsignedInteger => uint.TryParse(constant.Value, out _), GirModel.UnsignedLong => ulong.TryParse(constant.Value, out _), + GirModel.UnsignedCLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedShort => ushort.TryParse(constant.Value, out _), _ => false }; diff --git a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs index cf2637e47..41ae25a11 100644 --- a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs +++ b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs @@ -34,12 +34,14 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.Byte => byte.TryParse(constant.Value, out _), GirModel.Double => double.TryParse(constant.Value, out _), GirModel.Integer => int.TryParse(constant.Value, out _), + GirModel.CLong => long.TryParse(constant.Value, out _), GirModel.Long => long.TryParse(constant.Value, out _), GirModel.NativeInteger => nint.TryParse(constant.Value, out _), GirModel.NativeUnsignedInteger => nuint.TryParse(constant.Value, out _), GirModel.Short => short.TryParse(constant.Value, out _), GirModel.SignedByte => sbyte.TryParse(constant.Value, out _), GirModel.UnsignedInteger => uint.TryParse(constant.Value, out _), + GirModel.UnsignedCLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedShort => ushort.TryParse(constant.Value, out _), _ => false diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs new file mode 100644 index 000000000..1feaa7352 --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs @@ -0,0 +1,36 @@ +namespace Generator.Renderer.Public.Field; + +internal class CLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + NullableTypeName: GetNullableTypeName(field), + SetExpression: SetExpression, + GetExpression: GetExpression + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); + } + + private static string SetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Set{Model.Field.GetName(field)}(new CLong(checked((nint)value)))"; + } + + private static string GetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Get{Model.Field.GetName(field)}().Value"; + } +} diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs index e16c5f4d7..9aba91891 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs @@ -26,11 +26,11 @@ private static string GetNullableTypeName(GirModel.Field field) private static string SetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Set{Model.Field.GetName(field)}(new CLong(checked((nint)value)))"; + return $"Handle.Set{Model.Field.GetName(field)}(value)"; } private static string GetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Get{Model.Field.GetName(field)}().Value"; + return $"Handle.Get{Model.Field.GetName(field)}()"; } } diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..55b36ca5a --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs @@ -0,0 +1,36 @@ +namespace Generator.Renderer.Public.Field; + +internal class UnsignedCLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + NullableTypeName: GetNullableTypeName(field), + SetExpression: SetExpression, + GetExpression: GetExpression + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); + } + + private static string SetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Set{Model.Field.GetName(field)}(new CULong(checked((nuint)value)))"; + } + + private static string GetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Get{Model.Field.GetName(field)}().Value"; + } +} diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs index 44f335bd4..140e99406 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs @@ -26,11 +26,11 @@ private static string GetNullableTypeName(GirModel.Field field) private static string SetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Set{Model.Field.GetName(field)}(new CULong(checked((nuint)value)))"; + return $"Handle.Set{Model.Field.GetName(field)}(value)"; } private static string GetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Get{Model.Field.GetName(field)}().Value"; + return $"Handle.Get{Model.Field.GetName(field)}()"; } } diff --git a/src/Generation/Generator/Renderer/Public/Field/Fields.cs b/src/Generation/Generator/Renderer/Public/Field/Fields.cs index af897c8fd..d5fbbeb40 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Fields.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Fields.cs @@ -8,7 +8,9 @@ internal static class Fields { new Field.Bitfield(), new Field.Enumeration(), + new Field.CLong(), //Must be before PrimitiveValueType new Field.Long(), //Must be before PrimitiveValueType + new Field.UnsignedCLong(), //Must be before PrimitiveValueType new Field.UnsignedLong(), //Must be before PrimitiveValueType new Field.PrimitiveValueType(), new Field.String(), diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs new file mode 100644 index 000000000..596b476cb --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ParameterToNativeExpressions; + +internal class CLong : ToNativeParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToNativeData parameter, IEnumerable _) + { + //Array length parameters are handled as part of the corresponding array converters + if (parameter.IsArrayLengthParameter) + return; + + switch (parameter.Parameter) + { + case { IsPointer: false, Direction: GirModel.Direction.In }: + Direct(parameter); + break; + default: + throw new NotImplementedException($"{parameter.Parameter.AnyTypeOrVarArgs}: This long value type can not yet be converted to native"); + } + } + + private static void Direct(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"new CLong(checked((nint) {parameterName}))"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs index dce7942a0..8fa1d47b8 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs @@ -16,11 +16,20 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable parameterName); - parameter.SetCallName(() => $"new CLong(checked((nint) {parameterName}))"); + parameter.SetCallName(() => parameterName); + } + + private static void Ref(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"ref {parameterName}"); + } + + private static void Out(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => parameter.IsArrayLengthParameter + ? $"out var {parameterName}" + : $"out {parameterName}"); } } diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..a469a4738 --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ParameterToNativeExpressions; + +internal class UnsignedCLong : ToNativeParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToNativeData parameter, IEnumerable _) + { + //Array length parameters are handled as part of the corresponding array converters + if (parameter.IsArrayLengthParameter) + return; + + switch (parameter.Parameter) + { + case { IsPointer: false, Direction: GirModel.Direction.In }: + Direct(parameter); + break; + default: + throw new NotImplementedException($"{parameter.Parameter.AnyTypeOrVarArgs}: This unsigned long value type can not yet be converted to native"); + } + } + + private static void Direct(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"new CULong(checked((nuint) {parameterName}))"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs index 7b4a47c2c..2f75ebdfd 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs @@ -16,11 +16,20 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable parameterName); - parameter.SetCallName(() => $"new CULong(checked((nuint) {parameterName}))"); + parameter.SetCallName(() => parameterName); + } + + private static void Ref(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"ref {parameterName}"); + } + + private static void Out(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => parameter.IsArrayLengthParameter + ? $"out var {parameterName}" + : $"out {parameterName}"); } } diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs index 07267737b..0da5d7f67 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs @@ -26,7 +26,9 @@ internal static class ParameterToNativeExpression new ParameterToNativeExpressions.Pointer(), new ParameterToNativeExpressions.PointerAlias(), new ParameterToNativeExpressions.Long(), //Must be before primitive value type + new ParameterToNativeExpressions.CLong(), //Must be before primitive value type new ParameterToNativeExpressions.UnsignedLong(), //Must be before primitive value type + new ParameterToNativeExpressions.UnsignedCLong(), //Must be before primitive value type new ParameterToNativeExpressions.PrimitiveValueType(), new ParameterToNativeExpressions.PrimitiveValueTypeAlias(), new ParameterToNativeExpressions.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs new file mode 100644 index 000000000..f869123ae --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ReturnTypeToManagedExpressions; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ReturnTypeToManagedData data, IEnumerable _) + { + data.SetExpression(fromVariableName => data.ReturnType.IsPointer + ? fromVariableName + : $"{fromVariableName}.Value" + ); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs index ae2ce9c68..79a977aa8 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs @@ -9,10 +9,5 @@ public bool Supports(AnyType type) => type.Is(); public void Initialize(ReturnTypeToManagedData data, IEnumerable _) - { - data.SetExpression(fromVariableName => data.ReturnType.IsPointer - ? fromVariableName - : $"{fromVariableName}.Value" - ); - } + => data.SetExpression(fromVariableName => fromVariableName); //Valid for IsPointer = true && IsPointer = false } diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..6abd6ab0f --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using GirModel; + +namespace Generator.Renderer.Public.ReturnTypeToManagedExpressions; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(AnyType type) + => type.Is(); + + public void Initialize(ReturnTypeToManagedData data, IEnumerable _) + { + data.SetExpression(fromVariableName => data.ReturnType.IsPointer + ? fromVariableName + : $"{fromVariableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs index dd2f6bc37..c2dce1dd0 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs @@ -9,9 +9,5 @@ public bool Supports(AnyType type) => type.Is(); public void Initialize(ReturnTypeToManagedData data, IEnumerable _) - { - data.SetExpression(fromVariableName => data.ReturnType.IsPointer - ? fromVariableName - : $"{fromVariableName}.Value"); - } + => data.SetExpression(fromVariableName => fromVariableName); //Valid for IsPointer = true && IsPointer = false } diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs index b4ab950db..00130c73e 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs @@ -19,6 +19,8 @@ internal static class ReturnTypeToManagedExpression new ReturnTypeToManagedExpressions.PointerAlias(), new ReturnTypeToManagedExpressions.Long(), //Must be before primitive value type new ReturnTypeToManagedExpressions.UnsignedLong(), //Must be before primitive value type + new ReturnTypeToManagedExpressions.CLong(), //Must be before primitive value type + new ReturnTypeToManagedExpressions.UnsignedCLong(), //Must be before primitive value type new ReturnTypeToManagedExpressions.PrimitiveValueType(), new ReturnTypeToManagedExpressions.PrimitiveValueTypeAlias(), new ReturnTypeToManagedExpressions.PrimitiveValueTypeAliasArray(), diff --git a/src/Generation/GirLoader/Output/CLong.cs b/src/Generation/GirLoader/Output/CLong.cs new file mode 100644 index 000000000..fcfaf3811 --- /dev/null +++ b/src/Generation/GirLoader/Output/CLong.cs @@ -0,0 +1,6 @@ +namespace GirLoader.Output; + +public class CLong : PrimitiveValueType, GirModel.CLong +{ + public CLong(string ctype) : base(ctype) { } +} diff --git a/src/Generation/GirLoader/Output/UnsignedCLong.cs b/src/Generation/GirLoader/Output/UnsignedCLong.cs new file mode 100644 index 000000000..c33d293ed --- /dev/null +++ b/src/Generation/GirLoader/Output/UnsignedCLong.cs @@ -0,0 +1,6 @@ +namespace GirLoader.Output; + +public class UnsignedCLong : PrimitiveValueType, GirModel.UnsignedCLong +{ + public UnsignedCLong(string ctype) : base(ctype) { } +} diff --git a/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs b/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs index 607136341..b66239ff3 100644 --- a/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs +++ b/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs @@ -57,7 +57,7 @@ public GlobalTypeCache() Add(new Output.UnpointedSignedByte("char")); Add(new Output.SignedByte("gint8")); - Add(new Output.Long("glong")); + Add(new Output.CLong("glong")); Add(new Output.NativeInteger("gssize")); Add(new Output.Long("gint64")); Add(new Output.Long("goffset")); @@ -65,7 +65,7 @@ public GlobalTypeCache() Add(new Output.NativeUnsignedInteger("gsize")); Add(new Output.UnsignedLong("guint64")); - Add(new Output.UnsignedLong("gulong")); + Add(new Output.UnsignedCLong("gulong")); Add(new Output.Utf8String()); Add(new Output.PlatformString()); diff --git a/src/Generation/GirModel/CLong.cs b/src/Generation/GirModel/CLong.cs new file mode 100644 index 000000000..b03140dfa --- /dev/null +++ b/src/Generation/GirModel/CLong.cs @@ -0,0 +1,3 @@ +namespace GirModel; + +public interface CLong : PrimitiveValueType { } diff --git a/src/Generation/GirModel/UnsignedCLong.cs b/src/Generation/GirModel/UnsignedCLong.cs new file mode 100644 index 000000000..36da3f88e --- /dev/null +++ b/src/Generation/GirModel/UnsignedCLong.cs @@ -0,0 +1,3 @@ +namespace GirModel; + +public interface UnsignedCLong : PrimitiveValueType { } diff --git a/src/Generation/GirModel/UnsignedLong.cs b/src/Generation/GirModel/UnsignedLong.cs index db06436e3..5d161dff6 100644 --- a/src/Generation/GirModel/UnsignedLong.cs +++ b/src/Generation/GirModel/UnsignedLong.cs @@ -1,6 +1,3 @@ namespace GirModel; -public interface UnsignedLong : PrimitiveValueType -{ - -} +public interface UnsignedLong : PrimitiveValueType { } diff --git a/src/Native/GirTestLib/girtest-clong-tester.c b/src/Native/GirTestLib/girtest-clong-tester.c new file mode 100644 index 000000000..e42304ed4 --- /dev/null +++ b/src/Native/GirTestLib/girtest-clong-tester.c @@ -0,0 +1,52 @@ +#include "girtest-clong-tester.h" + +/** + * GirTestCLongTester: + * + * Test records with CLong fields + */ + +gsize girtest_clong_tester_get_sizeof_l(GirTestCLongTester* record) +{ + return sizeof(record->l); +} + +glong girtest_clong_tester_get_max_long_value() +{ + return LONG_MAX; +} + +gboolean girtest_clong_tester_is_max_long_value(glong value) +{ + if(value == LONG_MAX) + return TRUE; + + return FALSE; +} + +glong girtest_clong_tester_get_min_long_value() +{ + return LONG_MIN; +} + +gboolean girtest_clong_tester_is_min_long_value(glong value) +{ + if(value == LONG_MIN) + return TRUE; + + return FALSE; +} + +/** + * girtest_clong_tester_run_callback: + * @value: The long value which should be passed to the callback + * @callback: (scope call): a function that is called receives a long and should return a long + * + * Calls the callback and returns the data from the callback. + * + * Returns: The result of the callback. + **/ +glong girtest_clong_tester_run_callback(glong value, GirTestCLongCallback callback) +{ + return callback(value); +} \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-clong-tester.h b/src/Native/GirTestLib/girtest-clong-tester.h new file mode 100644 index 000000000..0fc0c7cda --- /dev/null +++ b/src/Native/GirTestLib/girtest-clong-tester.h @@ -0,0 +1,22 @@ +#pragma once + +#include + +G_BEGIN_DECLS + +typedef glong (*GirTestCLongCallback) (glong val); + +typedef struct _GirTestCLongTester GirTestCLongTester; + +struct _GirTestCLongTester +{ + long l; +}; + +gsize girtest_clong_tester_get_sizeof_l(GirTestCLongTester* record); +glong girtest_clong_tester_get_max_long_value(); +glong girtest_clong_tester_get_min_long_value(); +gboolean girtest_clong_tester_is_max_long_value(glong value); +gboolean girtest_clong_tester_is_min_long_value(glong value); +glong girtest_clong_tester_run_callback(glong value, GirTestCLongCallback callback); +G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-culong-tester.c b/src/Native/GirTestLib/girtest-culong-tester.c new file mode 100644 index 000000000..93d71ca92 --- /dev/null +++ b/src/Native/GirTestLib/girtest-culong-tester.c @@ -0,0 +1,39 @@ +#include "girtest-culong-tester.h" + +/** + * GirTestCULongTester: + * + * Test records with unsigned long fields + */ + +gsize girtest_cu_long_tester_get_sizeof_ul(GirTestCULongTester* record) +{ + return sizeof(record->ul); +} + +gulong girtest_cu_long_tester_get_max_unsigned_long_value() +{ + return ULONG_MAX; +} + +gboolean girtest_cu_long_tester_is_max_unsigned_long_value(gulong value) +{ + if(value == ULONG_MAX) + return TRUE; + + return FALSE; +} + +/** + * girtest_cu_long_tester_run_callback: + * @value: The long value which should be passed to the callback + * @callback: (scope call): a function that is called receives a ulong and should return a ulong + * + * Calls the callback and returns the data from the callback. + * + * Returns: The result of the callback. + **/ +gulong girtest_cu_long_tester_run_callback(gulong value, GirTestCULongCallback callback) +{ + return callback(value); +} \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-culong-tester.h b/src/Native/GirTestLib/girtest-culong-tester.h new file mode 100644 index 000000000..75a29a336 --- /dev/null +++ b/src/Native/GirTestLib/girtest-culong-tester.h @@ -0,0 +1,20 @@ +#pragma once + +#include + +G_BEGIN_DECLS + +typedef gulong (*GirTestCULongCallback) (gulong val); + +typedef struct _GirTestCULongTester GirTestCULongTester; + +struct _GirTestCULongTester +{ + unsigned long ul; +}; + +gsize girtest_cu_long_tester_get_sizeof_ul(GirTestCULongTester* record); +gulong girtest_cu_long_tester_get_max_unsigned_long_value(); +gboolean girtest_cu_long_tester_is_max_unsigned_long_value(gulong value); +gulong girtest_cu_long_tester_run_callback(gulong value, GirTestCULongCallback callback); +G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-integer-array-tester.c b/src/Native/GirTestLib/girtest-integer-array-tester.c index 3b071ab86..b1c394b0b 100644 --- a/src/Native/GirTestLib/girtest-integer-array-tester.c +++ b/src/Native/GirTestLib/girtest-integer-array-tester.c @@ -124,6 +124,21 @@ girtest_integer_array_tester_get_data_from_const_pointer(gconstpointer data, gsi return *(p + (size -1)); } +/** + * girtest_integer_array_tester_get_data_with_gint64_size: + * @data: (transfer none) (array length=size) (element-type gint): + * the data to be used + * @size: the size of @data + * + * Returns: The last integer of the given data. + */ +gint +girtest_integer_array_tester_get_data_with_gint64_size(gconstpointer data, gint64 size) +{ + gint* p = (gint*) data; + return *(p + (size -1)); +} + /** * girtest_integer_array_tester_clear_data: * @data: (array length=count) (element-type gint) (inout): diff --git a/src/Native/GirTestLib/girtest-integer-array-tester.h b/src/Native/GirTestLib/girtest-integer-array-tester.h index 10e7dddc4..f8bfd600e 100644 --- a/src/Native/GirTestLib/girtest-integer-array-tester.h +++ b/src/Native/GirTestLib/girtest-integer-array-tester.h @@ -34,6 +34,7 @@ gsize girtest_integer_array_tester_get_data_count(); void girtest_integer_array_tester_invoke_callback(GirTestIntegerArrayTesterCallback callback); void girtest_integer_array_tester_invoke_callback_no_length(GirTestIntegerArrayTesterCallbackNoLength callback); gint girtest_integer_array_tester_get_data_from_const_pointer(gconstpointer data, gsize size); +gint girtest_integer_array_tester_get_data_with_gint64_size(gconstpointer data, gint64 size); void girtest_integer_array_tester_clear_data(void *data, gsize count); G_END_DECLS diff --git a/src/Native/GirTestLib/girtest-long-tester.c b/src/Native/GirTestLib/girtest-long-tester.c index 1ebe81313..0b3355102 100644 --- a/src/Native/GirTestLib/girtest-long-tester.c +++ b/src/Native/GirTestLib/girtest-long-tester.c @@ -3,7 +3,7 @@ /** * GirTestLongTester: * - * Test records with long fields + * Test records with long (64 bit) fields */ gsize girtest_long_tester_get_sizeof_l(GirTestLongTester* record) @@ -11,27 +11,27 @@ gsize girtest_long_tester_get_sizeof_l(GirTestLongTester* record) return sizeof(record->l); } -glong girtest_long_tester_get_max_long_value() +gint64 girtest_long_tester_get_max_long_value() { - return LONG_MAX; + return G_MAXINT64; } -gboolean girtest_long_tester_is_max_long_value(glong value) +gboolean girtest_long_tester_is_max_long_value(gint64 value) { - if(value == LONG_MAX) + if(value == G_MAXINT64) return TRUE; return FALSE; } -glong girtest_long_tester_get_min_long_value() +gint64 girtest_long_tester_get_min_long_value() { - return LONG_MIN; + return G_MININT64; } -gboolean girtest_long_tester_is_min_long_value(glong value) +gboolean girtest_long_tester_is_min_long_value(gint64 value) { - if(value == LONG_MIN) + if(value == G_MININT64) return TRUE; return FALSE; @@ -46,7 +46,7 @@ gboolean girtest_long_tester_is_min_long_value(glong value) * * Returns: The result of the callback. **/ -glong girtest_long_tester_run_callback(glong value, GirTestLongCallback callback) +gint64 girtest_long_tester_run_callback(gint64 value, GirTestLongCallback callback) { return callback(value); } \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-long-tester.h b/src/Native/GirTestLib/girtest-long-tester.h index abb5056da..c8ff6fb19 100644 --- a/src/Native/GirTestLib/girtest-long-tester.h +++ b/src/Native/GirTestLib/girtest-long-tester.h @@ -4,19 +4,19 @@ G_BEGIN_DECLS -typedef glong (*GirTestLongCallback) (glong val); +typedef gint64 (*GirTestLongCallback) (gint64 val); typedef struct _GirTestLongTester GirTestLongTester; struct _GirTestLongTester { - long l; + gint64 l; }; gsize girtest_long_tester_get_sizeof_l(GirTestLongTester* record); -glong girtest_long_tester_get_max_long_value(); -glong girtest_long_tester_get_min_long_value(); -gboolean girtest_long_tester_is_max_long_value(glong value); -gboolean girtest_long_tester_is_min_long_value(glong value); -glong girtest_long_tester_run_callback(glong value, GirTestLongCallback callback); +gint64 girtest_long_tester_get_max_long_value(); +gint64 girtest_long_tester_get_min_long_value(); +gboolean girtest_long_tester_is_max_long_value(gint64 value); +gboolean girtest_long_tester_is_min_long_value(gint64 value); +gint64 girtest_long_tester_run_callback(gint64 value, GirTestLongCallback callback); G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-ulong-tester.c b/src/Native/GirTestLib/girtest-ulong-tester.c index ffb7c1096..5fef833fa 100644 --- a/src/Native/GirTestLib/girtest-ulong-tester.c +++ b/src/Native/GirTestLib/girtest-ulong-tester.c @@ -3,22 +3,22 @@ /** * GirTestULongTester: * - * Test records with unsigned long fields + * Test records with unsigned long (64 bit) fields */ -gsize girtest_ulong_tester_get_sizeof_ul(GirTestULongTester* record) +gsize girtest_ulong_tester_get_sizeof_l(GirTestULongTester* record) { - return sizeof(record->ul); + return sizeof(record->l); } -gulong girtest_ulong_tester_get_max_unsigned_long_value() +guint64 girtest_ulong_tester_get_max_ulong_value() { - return ULONG_MAX; + return G_MAXUINT64; } -gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value) +gboolean girtest_ulong_tester_is_max_ulong_value(guint64 value) { - if(value == ULONG_MAX) + if(value == G_MAXUINT64) return TRUE; return FALSE; @@ -27,13 +27,13 @@ gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value) /** * girtest_ulong_tester_run_callback: * @value: The long value which should be passed to the callback - * @callback: (scope call): a function that is called receives a ulong and should return a ulong + * @callback: (scope call): a function that is called receives a long and should return a long * * Calls the callback and returns the data from the callback. * * Returns: The result of the callback. **/ -gulong girtest_ulong_tester_run_callback(gulong value, GirTestULongCallback callback) +guint64 girtest_ulong_tester_run_callback(guint64 value, GirTestULongCallback callback) { - return callback(value); + return callback(value); } \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-ulong-tester.h b/src/Native/GirTestLib/girtest-ulong-tester.h index 143aca1fa..b4da0d139 100644 --- a/src/Native/GirTestLib/girtest-ulong-tester.h +++ b/src/Native/GirTestLib/girtest-ulong-tester.h @@ -4,17 +4,17 @@ G_BEGIN_DECLS -typedef gulong (*GirTestULongCallback) (gulong val); +typedef guint64 (*GirTestULongCallback) (guint64 val); typedef struct _GirTestULongTester GirTestULongTester; struct _GirTestULongTester { - unsigned long ul; + guint64 l; }; -gsize girtest_ulong_tester_get_sizeof_ul(GirTestULongTester* record); -gulong girtest_ulong_tester_get_max_unsigned_long_value(); -gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value); -gulong girtest_ulong_tester_run_callback(gulong value, GirTestULongCallback callback); +gsize girtest_ulong_tester_get_sizeof_l(GirTestULongTester* record); +guint64 girtest_ulong_tester_get_max_ulong_value(); +gboolean girtest_ulong_tester_is_max_ulong_value(guint64 value); +guint64 girtest_ulong_tester_run_callback(guint64 value, GirTestULongCallback callback); G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest.h b/src/Native/GirTestLib/girtest.h index b3c5314b1..e6296643d 100644 --- a/src/Native/GirTestLib/girtest.h +++ b/src/Native/GirTestLib/girtest.h @@ -6,7 +6,9 @@ #include "girtest-byte-array-tester.h" #include "girtest-callback-tester.h" #include "girtest-class-tester.h" +#include "girtest-clong-tester.h" #include "girtest-constant-tester.h" +#include "girtest-culong-tester.h" #include "girtest-enum-tester.h" #include "girtest-error-tester.h" #include "girtest-integer-array-tester.h" diff --git a/src/Native/GirTestLib/meson.build b/src/Native/GirTestLib/meson.build index 52ab40e01..c7ccce963 100644 --- a/src/Native/GirTestLib/meson.build +++ b/src/Native/GirTestLib/meson.build @@ -9,7 +9,9 @@ header_files = [ 'girtest-byte-array-tester.h', 'girtest-callback-tester.h', 'girtest-class-tester.h', + 'girtest-clong-tester.h', 'girtest-constant-tester.h', + 'girtest-culong-tester.h', 'girtest-enum-tester.h', 'girtest-error-tester.h', 'girtest-integer-array-tester.h', @@ -41,6 +43,8 @@ source_files = [ 'girtest-byte-array-tester.c', 'girtest-callback-tester.c', 'girtest-class-tester.c', + 'girtest-clong-tester.c', + 'girtest-culong-tester.c', 'girtest-enum-tester.c', 'girtest-error-tester.c', 'girtest-integer-array-tester.c', diff --git a/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs b/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs index 02e44e1f8..5c0a36cca 100644 --- a/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs +++ b/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs @@ -88,14 +88,14 @@ public void PropertyNameShouldBeLoaded() [DataRow("gchar", false, typeof(Output.SignedByte))] [DataRow("char", false, typeof(Output.SignedByte))] [DataRow("gint8", false, typeof(Output.SignedByte))] - [DataRow("glong", false, typeof(Output.Long))] + [DataRow("glong", false, typeof(Output.CLong))] [DataRow("gssize", false, typeof(Output.NativeInteger))] [DataRow("gint64", false, typeof(Output.Long))] [DataRow("goffset", false, typeof(Output.Long))] [DataRow("time_t", false, typeof(Output.Long))] [DataRow("gsize", false, typeof(Output.NativeUnsignedInteger))] [DataRow("guint64", false, typeof(Output.UnsignedLong))] - [DataRow("gulong", false, typeof(Output.UnsignedLong))] + [DataRow("gulong", false, typeof(Output.UnsignedCLong))] [DataRow("gboolean*", true, typeof(Output.Boolean))] [DataRow("gfloat*", true, typeof(Output.Float))] [DataRow("float*", true, typeof(Output.Float))] @@ -124,14 +124,14 @@ public void PropertyNameShouldBeLoaded() //[DataRow("gchar*", true, typeof(Output.Model.String))] -> Ambigous between UTF8 and platform strings //[DataRow("char*", true, typeof(Output.Model.String))] -> Ambigous between UTF8 and platform strings [DataRow("gint8*", true, typeof(Output.SignedByte))] - [DataRow("glong*", true, typeof(Output.Long))] + [DataRow("glong*", true, typeof(Output.CLong))] [DataRow("gssize*", true, typeof(Output.NativeInteger))] [DataRow("gint64*", true, typeof(Output.Long))] [DataRow("goffset*", true, typeof(Output.Long))] [DataRow("time_t*", true, typeof(Output.Long))] [DataRow("gsize*", true, typeof(Output.NativeUnsignedInteger))] [DataRow("guint64*", true, typeof(Output.UnsignedLong))] - [DataRow("gulong*", true, typeof(Output.UnsignedLong))] + [DataRow("gulong*", true, typeof(Output.UnsignedCLong))] public void PropertyTypeShouldMatchCType(string ctype, bool isPointer, System.Type resultType) { var property = GetLoadedProperty(ctype, null); diff --git a/src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs new file mode 100644 index 000000000..88f4aaf94 --- /dev/null +++ b/src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs @@ -0,0 +1,186 @@ +using System; +using System.Runtime.InteropServices; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace GirTest.Tests; + +[TestClass, TestCategory("BindingTest")] +public class CLongTest : Test +{ + [TestMethod] + public void ShouldUseCLongInInternalStructData() + { + var data = new GirTest.Internal.CLongTesterData(); + data.L.Should().BeOfType(); + } + + [TestMethod] + public unsafe void GetSizeOfLShouldBeSizeOfCLong() + { + var sizeOfCLong = sizeof(CLong); + var obj = new CLongTester(); + obj.GetSizeofL().Should().Be((nuint) sizeOfCLong); + } + + [DataTestMethod] + [DataRow(long.MaxValue)] + [DataRow(long.MinValue)] + public void ShouldHandleMaxMinLongValue(long value) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + var obj = new CLongTester { L = value }; + obj.L.Should().Be(value); + } + + [DataTestMethod] + [DataRow(int.MaxValue)] + [DataRow(int.MinValue)] + public void ShouldHandleMaxMinIntValue(int value) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var obj = new CLongTester { L = value }; + obj.L.Should().Be(value); + } + + [DataTestMethod] + [DataRow(long.MaxValue)] + [DataRow(long.MinValue)] + public void ShouldThrowIfValueExceedsIntegerSize(long value) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var obj = new CLongTester(); + var act = () => obj.L = value; + act.Should().Throw(); + } + + [TestMethod] + public void ReturnsMaxLongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CLongTester.GetMaxLongValue().Should().Be(long.MaxValue); + } + + [TestMethod] + public void ReturnsMaxLongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CLongTester.GetMaxLongValue().Should().Be(int.MaxValue); + } + + [TestMethod] + public void ReturnsMinLongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CLongTester.GetMinLongValue().Should().Be(long.MinValue); + } + + [TestMethod] + public void ReturnsMinLongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CLongTester.GetMinLongValue().Should().Be(int.MinValue); + } + + [TestMethod] + public void SetsMaxLongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CLongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); + } + + [TestMethod] + public void SetsMaxLongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CLongTester.IsMaxLongValue(int.MaxValue).Should().BeTrue(); + } + + [TestMethod] + public void SetsMinLongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CLongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); + } + + [TestMethod] + public void SetsMinLongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CLongTester.IsMinLongValue(int.MinValue).Should().BeTrue(); + } + + [TestMethod] + public void ThrowsOverflowExceptionIfLongMinValueIsPassedOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var action = () => CLongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); + action.Should().Throw(); + } + + [TestMethod] + public void ThrowsOverflowExceptionIfLongMaxValueIsPassedOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var action = () => CLongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); + action.Should().Throw(); + } + + [DataTestMethod] + [DataRow(long.MaxValue)] + [DataRow(long.MinValue)] + public void CanPassLongValueThroughCallbackOn64BitUnix(long value) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + long Callback(long val) + { + return val; + } + + CLongTester.RunCallback(value, Callback).Should().Be(value); + } + + [DataTestMethod] + [DataRow(int.MaxValue)] + [DataRow(int.MinValue)] + public void CanPassIntValueThroughCallbackOnWindows(int value) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + long Callback(long val) + { + return val; + } + + CLongTester.RunCallback(value, Callback).Should().Be(value); + } +} diff --git a/src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs new file mode 100644 index 000000000..68d7f1988 --- /dev/null +++ b/src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs @@ -0,0 +1,138 @@ +using System; +using System.Runtime.InteropServices; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace GirTest.Tests; + +[TestClass, TestCategory("BindingTest")] +public class CULongTest : Test +{ + [TestMethod] + public void ShouldUseCULongInInternalStructData() + { + var data = new GirTest.Internal.CULongTesterData(); + data.Ul.Should().BeOfType(); + } + + [TestMethod] + public unsafe void GetSizeOfLShouldBeSizeOfCULong() + { + var sizeOfCULong = sizeof(CULong); + var obj = new CULongTester(); + obj.GetSizeofUl().Should().Be((nuint) sizeOfCULong); + } + + [DataTestMethod] + [DataRow(ulong.MaxValue)] + [DataRow(ulong.MinValue)] + public void ShouldHandleMaxULongValue(ulong value) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + var obj = new CULongTester { Ul = value }; + obj.Ul.Should().Be(value); + } + + [DataTestMethod] + [DataRow(uint.MaxValue)] + [DataRow(uint.MinValue)] + public void ShouldHandleMaxMinUIntValue(uint value) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var obj = new CULongTester { Ul = value }; + obj.Ul.Should().Be(value); + } + + [TestMethod] + public void ShouldThrowIfValueExceedsUIntegerSize() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var obj = new CULongTester(); + var act = () => obj.Ul = ulong.MaxValue; + act.Should().Throw(); + } + + [TestMethod] + public void ReturnsMaxULongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CULongTester.GetMaxUnsignedLongValue().Should().Be(ulong.MaxValue); + } + + [TestMethod] + public void ReturnsMaxULongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CULongTester.GetMaxUnsignedLongValue().Should().Be(uint.MaxValue); + } + + [TestMethod] + public void SetsMaxULongValueOn64BitUnix() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + CULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); + } + + [TestMethod] + public void SetsMaxULongValueOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + CULongTester.IsMaxUnsignedLongValue(uint.MaxValue).Should().BeTrue(); + } + + [TestMethod] + public void ThrowsOverflowExceptionIfULongMaxValueIsPassedOnWindows() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + var action = () => CULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); + action.Should().Throw(); + } + + [DataTestMethod] + [DataRow(ulong.MaxValue)] + [DataRow(ulong.MinValue)] + public void CanPassULongValueThroughCallbackOn64BitUnix(ulong value) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); + + ulong Callback(ulong val) + { + return val; + } + + CULongTester.RunCallback(value, Callback).Should().Be(value); + } + + [DataTestMethod] + [DataRow(uint.MaxValue)] + [DataRow(uint.MinValue)] + public void CanPassIntValueThroughCallbackOnWindows(uint value) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) + Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); + + ulong Callback(ulong val) + { + return val; + } + + CULongTester.RunCallback(value, Callback).Should().Be(value); + } +} diff --git a/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs index f6ca7d59e..1fdb49872 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs @@ -100,6 +100,13 @@ public void IntegerArrayFromConstPointer() IntegerArrayTester.GetDataFromConstPointer(data).Should().Be(6); } + [TestMethod] + public void IntegerArrayWithGint64Size() + { + var data = new int[] { 5, 6 }; + IntegerArrayTester.GetDataWithGint64Size(data).Should().Be(6); + } + [TestMethod] public void SupportsInOutIntegerArray() { diff --git a/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs index 61de83cd7..f1fb49cde 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs @@ -9,18 +9,17 @@ namespace GirTest.Tests; public class LongTest : Test { [TestMethod] - public void ShouldUseCLongInInternalStructData() + public void ShouldUseLongInInternalStructData() { var data = new GirTest.Internal.LongTesterData(); - data.L.Should().BeOfType(); + data.L.Should().BeOfType(typeof(long)); } [TestMethod] - public unsafe void GetSizeOfLShouldBeSizeOfCLong() + public void GetSizeOfLShouldBeSizeOfLong() { - var sizeOfCLong = sizeof(CLong); var obj = new LongTester(); - obj.GetSizeofL().Should().Be((nuint) sizeOfCLong); + obj.GetSizeofL().Should().Be(sizeof(long)); } [DataTestMethod] @@ -28,154 +27,39 @@ public unsafe void GetSizeOfLShouldBeSizeOfCLong() [DataRow(long.MinValue)] public void ShouldHandleMaxMinLongValue(long value) { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - var obj = new LongTester { L = value }; - obj.L.Should().Be(value); - } - - [DataTestMethod] - [DataRow(int.MaxValue)] - [DataRow(int.MinValue)] - public void ShouldHandleMaxMinIntValue(int value) - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var obj = new LongTester { L = value }; obj.L.Should().Be(value); } - [DataTestMethod] - [DataRow(long.MaxValue)] - [DataRow(long.MinValue)] - public void ShouldThrowIfValueExceedsIntegerSize(long value) - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var obj = new LongTester(); - var act = () => obj.L = value; - act.Should().Throw(); - } - [TestMethod] - public void ReturnsMaxLongValueOn64BitUnix() + public void ReturnsMaxLongValue() { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.GetMaxLongValue().Should().Be(long.MaxValue); } [TestMethod] - public void ReturnsMaxLongValueOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - LongTester.GetMaxLongValue().Should().Be(int.MaxValue); - } - - [TestMethod] - public void ReturnsMinLongValueOn64BitUnix() + public void ReturnsMinLongValue() { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.GetMinLongValue().Should().Be(long.MinValue); } [TestMethod] - public void ReturnsMinLongValueOnWindows() + public void SetsMaxLongValue() { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - LongTester.GetMinLongValue().Should().Be(int.MinValue); - } - - [TestMethod] - public void SetsMaxLongValueOn64BitUnix() - { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); } [TestMethod] - public void SetsMaxLongValueOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - LongTester.IsMaxLongValue(int.MaxValue).Should().BeTrue(); - } - - [TestMethod] - public void SetsMinLongValueOn64BitUnix() + public void SetsMinLongValue() { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); } - [TestMethod] - public void SetsMinLongValueOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - LongTester.IsMinLongValue(int.MinValue).Should().BeTrue(); - } - - [TestMethod] - public void ThrowsOverflowExceptionIfLongMinValueIsPassedOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var action = () => LongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); - action.Should().Throw(); - } - - [TestMethod] - public void ThrowsOverflowExceptionIfLongMaxValueIsPassedOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var action = () => LongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); - action.Should().Throw(); - } - [DataTestMethod] [DataRow(long.MaxValue)] [DataRow(long.MinValue)] - public void CanPassLongValueThroughCallbackOn64BitUnix(long value) + public void CanPassLongValueThroughCallback(long value) { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - long Callback(long val) - { - return val; - } - - LongTester.RunCallback(value, Callback).Should().Be(value); - } - - [DataTestMethod] - [DataRow(int.MaxValue)] - [DataRow(int.MinValue)] - public void CanPassIntValueThroughCallbackOnWindows(int value) - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - long Callback(long val) { return val; diff --git a/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs index 1717a3b0d..16aaf8e92 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs @@ -9,125 +9,45 @@ namespace GirTest.Tests; public class ULongTest : Test { [TestMethod] - public void ShouldUseCULongInInternalStructData() + public void ShouldUseLongInInternalStructData() { var data = new GirTest.Internal.ULongTesterData(); - data.Ul.Should().BeOfType(); + data.L.Should().BeOfType(typeof(ulong)); } [TestMethod] - public unsafe void GetSizeOfLShouldBeSizeOfCULong() + public void GetSizeOfLShouldBeSizeOfLong() { - var sizeOfCULong = sizeof(CULong); var obj = new ULongTester(); - obj.GetSizeofUl().Should().Be((nuint) sizeOfCULong); + obj.GetSizeofL().Should().Be(sizeof(ulong)); } [DataTestMethod] [DataRow(ulong.MaxValue)] [DataRow(ulong.MinValue)] - public void ShouldHandleMaxULongValue(ulong value) + public void ShouldHandleMaxMinLongValue(ulong value) { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - var obj = new ULongTester { Ul = value }; - obj.Ul.Should().Be(value); - } - - [DataTestMethod] - [DataRow(uint.MaxValue)] - [DataRow(uint.MinValue)] - public void ShouldHandleMaxMinUIntValue(uint value) - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var obj = new ULongTester { Ul = value }; - obj.Ul.Should().Be(value); + var obj = new ULongTester { L = value }; + obj.L.Should().Be(value); } [TestMethod] - public void ShouldThrowIfValueExceedsUIntegerSize() + public void ReturnsMaxLongValue() { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var obj = new ULongTester(); - var act = () => obj.Ul = ulong.MaxValue; - act.Should().Throw(); + ULongTester.GetMaxUlongValue().Should().Be(ulong.MaxValue); } [TestMethod] - public void ReturnsMaxULongValueOn64BitUnix() + public void SetsMaxLongValue() { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - ULongTester.GetMaxUnsignedLongValue().Should().Be(ulong.MaxValue); - } - - [TestMethod] - public void ReturnsMaxULongValueOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - ULongTester.GetMaxUnsignedLongValue().Should().Be(uint.MaxValue); - } - - [TestMethod] - public void SetsMaxULongValueOn64BitUnix() - { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - ULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); - } - - [TestMethod] - public void SetsMaxULongValueOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - ULongTester.IsMaxUnsignedLongValue(uint.MaxValue).Should().BeTrue(); - } - - [TestMethod] - public void ThrowsOverflowExceptionIfULongMaxValueIsPassedOnWindows() - { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - - var action = () => ULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); - action.Should().Throw(); + ULongTester.IsMaxUlongValue(ulong.MaxValue).Should().BeTrue(); } [DataTestMethod] [DataRow(ulong.MaxValue)] [DataRow(ulong.MinValue)] - public void CanPassULongValueThroughCallbackOn64BitUnix(ulong value) - { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - - ulong Callback(ulong val) - { - return val; - } - - ULongTester.RunCallback(value, Callback).Should().Be(value); - } - - [DataTestMethod] - [DataRow(uint.MaxValue)] - [DataRow(uint.MinValue)] - public void CanPassIntValueThroughCallbackOnWindows(uint value) + public void CanPassLongValueThroughCallback(ulong value) { - if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) - Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - ulong Callback(ulong val) { return val;