From 699e2a88a95d8bf432dd6f4e2b3e383da36f9f39 Mon Sep 17 00:00:00 2001 From: badcel <1218031+badcel@users.noreply.github.com> Date: Wed, 25 Sep 2024 22:26:00 +0200 Subject: [PATCH] Differentiate between Long and CLong GirModel.CLong is 32 bit on all windows platforms, 32 bit on 32 bit unix platforms and 64 bit on 64bit unix platforms. GirModel.Long ist 64 bit on all platforms. This reverts the changes from #1067 and only adds the CLong / CULong handling for "glong" / "gulong". All other long types stay like originally intended. Fixes #1098 --- src/Generation/Generator/Model/Type.cs | 2 + .../Internal/Field/Converter/CLong.cs | 25 +++ .../Renderer/Internal/Field/Converter/Long.cs | 2 +- .../Internal/Field/Converter/UnsignedCLong.cs | 25 +++ .../Internal/Field/Converter/UnsignedLong.cs | 2 +- .../Renderer/Internal/Field/Fields.cs | 2 + .../Internal/Parameter/CallbackParameters.cs | 2 + .../Internal/Parameter/Converter/CLong.cs | 44 +++++ .../Internal/Parameter/Converter/Long.cs | 10 +- .../Parameter/Converter/UnsignedCLong.cs | 44 +++++ .../Parameter/Converter/UnsignedLong.cs | 10 +- .../Renderer/Internal/Parameter/Parameters.cs | 2 + .../Converter/CLong.cs | 30 +++ .../Converter/Long.cs | 26 ++- .../Converter/UnsignedCLong.cs | 30 +++ .../Converter/UnsignedLong.cs | 26 ++- .../ParameterToManagedExpression.cs | 2 + .../Internal/ReturnType/Converter/CLong.cs | 18 ++ .../Internal/ReturnType/Converter/Long.cs | 2 +- .../ReturnType/Converter/UnsignedCLong.cs | 18 ++ .../ReturnType/Converter/UnsignedLong.cs | 2 +- .../Internal/ReturnType/ReturnTypeRenderer.cs | 2 + .../ReturnType/ReturnTypeRendererCallback.cs | 6 +- .../Converter/CLong.cs | 10 + .../Converter/Long.cs | 8 +- .../Converter/UnsignedCLong.cs | 10 + .../Converter/UnsignedLong.cs | 10 +- .../ReturnTypeToNativeExpression.cs | 4 +- .../Constant/Converter/PrimitiveValueType.cs | 2 + .../Converter/PrimitiveValueTypeAlias.cs | 2 + .../Renderer/Public/Field/Converter/CLong.cs | 36 ++++ .../Renderer/Public/Field/Converter/Long.cs | 4 +- .../Public/Field/Converter/UnsignedCLong.cs | 36 ++++ .../Public/Field/Converter/UnsignedLong.cs | 4 +- .../Generator/Renderer/Public/Field/Fields.cs | 2 + .../Converter/CLong.cs | 33 ++++ .../Converter/Long.cs | 29 ++- .../Converter/UnsignedCLong.cs | 33 ++++ .../Converter/UnsignedLong.cs | 29 ++- .../ParameterToNativeExpression.cs | 2 + .../Converter/CLong.cs | 17 ++ .../Converter/Long.cs | 7 +- .../Converter/UnsignedCLong.cs | 17 ++ .../Converter/UnsignedLong.cs | 6 +- .../ReturnTypeToManagedExpression.cs | 2 + src/Generation/GirLoader/Output/CLong.cs | 6 + .../GirLoader/Output/UnsignedCLong.cs | 6 + .../TypeReferenceResolver.GlobalTypeCache.cs | 4 +- src/Generation/GirModel/CLong.cs | 3 + src/Generation/GirModel/UnsignedCLong.cs | 3 + src/Generation/GirModel/UnsignedLong.cs | 5 +- src/Native/GirTestLib/girtest-clong-tester.c | 52 +++++ src/Native/GirTestLib/girtest-clong-tester.h | 22 +++ src/Native/GirTestLib/girtest-culong-tester.c | 39 ++++ src/Native/GirTestLib/girtest-culong-tester.h | 20 ++ .../GirTestLib/girtest-integer-array-tester.c | 15 ++ .../GirTestLib/girtest-integer-array-tester.h | 1 + src/Native/GirTestLib/girtest-long-tester.c | 20 +- src/Native/GirTestLib/girtest-long-tester.h | 14 +- src/Native/GirTestLib/girtest-ulong-tester.c | 20 +- src/Native/GirTestLib/girtest-ulong-tester.h | 12 +- src/Native/GirTestLib/girtest.h | 2 + src/Native/GirTestLib/meson.build | 4 + .../GirLoader.Tests/ClassPropertyTest.cs | 8 +- src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs | 186 ++++++++++++++++++ .../Libs/GirTest-0.1.Tests/CULongTest.cs | 138 +++++++++++++ .../GirTest-0.1.Tests/IntegerArrayTest.cs | 7 + src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs | 134 +------------ src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs | 104 ++-------- 69 files changed, 1153 insertions(+), 307 deletions(-) create mode 100644 src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs create mode 100644 src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs create mode 100644 src/Generation/GirLoader/Output/CLong.cs create mode 100644 src/Generation/GirLoader/Output/UnsignedCLong.cs create mode 100644 src/Generation/GirModel/CLong.cs create mode 100644 src/Generation/GirModel/UnsignedCLong.cs create mode 100644 src/Native/GirTestLib/girtest-clong-tester.c create mode 100644 src/Native/GirTestLib/girtest-clong-tester.h create mode 100644 src/Native/GirTestLib/girtest-culong-tester.c create mode 100644 src/Native/GirTestLib/girtest-culong-tester.h create mode 100644 src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs create mode 100644 src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs 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..f2036421a 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;