public void StructInfixOpTest() { var swiftCode = @" public struct IntRep { public init (with: Int32) { val = with } public var val:Int32 = 0 } infix operator %^^% : AdditionPrecedence public func %^^% (left:IntRep, right: IntRep) -> IntRep { return IntRep (with: left.val + right.val) } "; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSFunctionCall("IntRep", true, CSConstant.Val(3))); var rightID = new CSIdentifier("right"); var rightDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, rightID, new CSFunctionCall("IntRep", true, CSConstant.Val(4))); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("TopLevelEntities.InfixOperatorPercentHatHatPercent", false, leftID, rightID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID.Dot(new CSIdentifier("Val"))); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, rightDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "7\n"); }
public void ClassInlinePostfixOperator() { var swiftCode = @" postfix operator ^*--*^ public class NumRep1 { public init (a: Int) { val = a } public var val: Int public static postfix func ^*--*^(val: NumRep1) -> NumRep1 { return NumRep1 (a: -val.val) } }"; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSFunctionCall("NumRep1", true, CSConstant.Val(4))); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("NumRep1.PostfixOperatorHatStarMinusMinusStarHat", false, leftID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID.Dot(new CSIdentifier("Val"))); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "-4\n"); }
public void StructPostfixOpTest() { var swiftCode = @" public struct IntRep2 { public init (with: Int32) { val = with } public var val:Int32 = 0 } prefix operator %--% public prefix func %--% (left:IntRep2) -> IntRep2 { return IntRep2 (with: left.val - 1) } "; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSFunctionCall("IntRep2", true, CSConstant.Val(3))); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("TopLevelEntities.PrefixOperatorPercentMinusMinusPercent", false, leftID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID.Dot(new CSIdentifier("Val"))); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "2\n"); }
public void TestExistentialContainer() { var swiftCode = @" public protocol SomeProtocol { func foo () } "; // var ocsty = typeof (ISomeProtocol); // var mt = StructMarshal.Marshaler.ExistentialMetatypeof (ocsty); // Type csty; // SwiftTypeRegistry.Registry.TryGetValue (mt, out csty); // Console.WriteLine (csty.Name); // Console.WriteLine (csty == ocsty); var ocsTypeID = new CSIdentifier("ocsty"); var csTypeID = new CSIdentifier("csty"); var mtID = new CSIdentifier("mt"); var ocstyDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, ocsTypeID, new CSSimpleType("ISomeProtocol").Typeof()); var mtDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, mtID, new CSFunctionCall("StructMarshal.Marshaler.ExistentialMetatypeof", false, ocsTypeID)); var cstyDecl = CSVariableDeclaration.VarLine(CSSimpleType.Type, csTypeID); var tryGetLine = CSFunctionCall.FunctionCallLine("SwiftTypeRegistry.Registry.TryGetValue", false, mtID, new CSUnaryExpression(CSUnaryOperator.Out, csTypeID)); var print1 = CSFunctionCall.ConsoleWriteLine(ocsTypeID.Dot(new CSIdentifier("Name"))); var print2 = CSFunctionCall.ConsoleWriteLine(csTypeID == ocsTypeID); var callingCode = CSCodeBlock.Create(ocstyDecl, mtDecl, cstyDecl, tryGetLine, print1, print2); TestRunning.TestAndExecute(swiftCode, callingCode, "ISomeProtocol\nTrue\n", platform: PlatformName.macOS); }
public void CanGetProtocolConformanceDesc() { // var nomDesc = SwiftProtocolTypeAttribute.DescriptorForType (typeof (IIteratorProtocol<>)); // var witTable = SwiftCore.ConformsToSwiftProtocol (StructMarshal.Marshaler.Metatypeof (typeof (SwiftIteratorProtocolProxy<nint>)), // nomDesc); // Console.WriteLine (confDesc != IntPtr.Zero); var swiftCode = @" public func canGetProtocolConfDesc () { } "; var nomDescID = new CSIdentifier("nomDesc"); var witTableID = new CSIdentifier("witTable"); var nomDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, nomDescID, new CSFunctionCall("SwiftProtocolTypeAttribute.DescriptorForType", false, new CSSimpleType("IIteratorProtocol<>").Typeof())); var metaTypeCall = new CSFunctionCall("StructMarshal.Marshaler.Metatypeof", false, new CSSimpleType("SwiftIteratorProtocolProxy<nint>").Typeof()); var confDescDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, witTableID, new CSFunctionCall("SwiftCore.ConformsToSwiftProtocol", false, metaTypeCall, nomDescID)); var printer = CSFunctionCall.ConsoleWriteLine(witTableID.Dot(new CSIdentifier("Handle")) != new CSIdentifier("IntPtr.Zero")); var callingCode = CSCodeBlock.Create(nomDecl, confDescDecl, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "True\n"); }
public void TestDictionary() { var swiftCode = @" public func dictionaryTestDoesNothing () { }"; // var ocsty = typeof (SwiftOptional<bool>); // var mt = StructMarshal.Marshaler.Metatypeof (ocsty); // Type csty; // SwiftTypeRegistry.Registry.TryGetValue (mt, out csty); // Console.WriteLine (csty.Name); // Console.WriteLine (genargs.Length); // Console.WriteLine (genargs[1].Name); // Console.WriteLine (csty == ocsty); var ocsTypeID = new CSIdentifier("ocsty"); var csTypeID = new CSIdentifier("csty"); var mtID = new CSIdentifier("mt"); var ocstyDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, ocsTypeID, new CSSimpleType("SwiftDictionary", false, CSSimpleType.Bool, CSSimpleType.Int).Typeof()); var mtDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, mtID, new CSFunctionCall("StructMarshal.Marshaler.Metatypeof", false, ocsTypeID)); var cstyDecl = CSVariableDeclaration.VarLine(CSSimpleType.Type, csTypeID); var tryGetLine = CSFunctionCall.FunctionCallLine("SwiftTypeRegistry.Registry.TryGetValue", false, mtID, new CSUnaryExpression(CSUnaryOperator.Out, csTypeID)); var print1 = CSFunctionCall.ConsoleWriteLine(ocsTypeID.Dot(new CSIdentifier("Name"))); var genargsID = new CSIdentifier("genargs"); var genArgsDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, genargsID, new CSFunctionCall($"{csTypeID.Name}.GetGenericArguments", false)); var print2 = CSFunctionCall.ConsoleWriteLine(genargsID.Dot(new CSIdentifier("Length"))); var print3 = CSFunctionCall.ConsoleWriteLine(new CSIdentifier($"{genargsID.Name} [0].Name")); var print4 = CSFunctionCall.ConsoleWriteLine(csTypeID == ocsTypeID); var callingCode = CSCodeBlock.Create(ocstyDecl, mtDecl, cstyDecl, tryGetLine, print1, genArgsDecl, print2, print3, print4); TestRunning.TestAndExecute(swiftCode, callingCode, "SwiftDictionary`2\n2\nBoolean\nTrue\n"); }
public void VirtualOpenPropStruct(PlatformName platform) { string swiftCode = $"import Foundation\nopen class AnotherOpenVirtualClass{platform} {{\n\tpublic init () {{ }}\n\topen var OSVersion = OperatingSystemVersion (majorVersion: 1, minorVersion:2, patchVersion: 3)\n}}\n"; // var cl = new AnotherVirtualClass (); // var vers = cl.OSVersion; // Console.WriteLine(vers); // vers.Major = 5; // cl.OSVersion = vers; // vers = cl.OSVersion; // Console.WriteLine(vers); var versID = new CSIdentifier("vers"); var clID = new CSIdentifier("cl"); var osverExpr = clID.Dot(new CSIdentifier("OSVersion")); var clDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, clID, new CSFunctionCall($"AnotherOpenVirtualClass{platform}", true)); var versDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, versID, osverExpr); var printer = CSFunctionCall.ConsoleWriteLine(versID); var setMajor = CSAssignment.Assign(versID.Dot(new CSIdentifier("Major")), CSConstant.Val(5)); var setOSVer = CSAssignment.Assign(osverExpr, versID); var resetVer = CSAssignment.Assign(versID, osverExpr); var callingCode = CSCodeBlock.Create(clDecl, versDecl, printer, setMajor, setOSVer, resetVer, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "1.2.3\n5.2.3\n", platform: platform); }
public void NSObjectSubclassableMethodTest3() { string swiftCode = "import Foundation\n" + "@objc\n" + "open class Subclassable3 : NSObject {\n" + " public override init () { }\n" + " open var returnsTrue:Bool {\n" + " get { return true\n } " + " }\n" + "}\n" + "public func callIt (a: Subclassable3) -> Bool {\n" + " return a.returnsTrue\n" + "}\n"; var theSub = new CSClass(CSVisibility.Public, "TheSub3"); var ctor = new CSMethod(CSVisibility.Public, CSMethodKind.None, null, theSub.Name, new CSParameterList(), new CSBaseExpression [0], true, new CSCodeBlock()); theSub.Constructors.Add(ctor); theSub.Inheritance.Add(new CSIdentifier("Subclassable3")); var theBody = new CSCodeBlock(); theBody.Add(CSReturn.ReturnLine(CSConstant.Val(false))); LineCodeElementCollection <ICodeElement> getCode = new LineCodeElementCollection <ICodeElement> ( new ICodeElement [] { CSReturn.ReturnLine(CSConstant.Val(false)) }, false, true); CSProperty returnsFalse = new CSProperty(CSSimpleType.Bool, CSMethodKind.Override, new CSIdentifier("ReturnsTrue"), CSVisibility.Public, new CSCodeBlock(getCode), CSVisibility.Public, null); theSub.Properties.Add(returnsFalse); var callingCode = new CodeElementCollection <ICodeElement> (); var objID = new CSIdentifier("subTest"); var objDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, objID, new CSFunctionCall("TheSub3", true)); var call = CSFunctionCall.ConsoleWriteLine(objID.Dot((CSIdentifier)"ReturnsTrue")); var call2 = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.CallIt", objID)); callingCode.Add(objDecl); callingCode.Add(call); callingCode.Add(call2); TestRunning.TestAndExecute(swiftCode, callingCode, "False\nFalse\n", otherClass: theSub, platform: PlatformName.macOS); }
void TestObjectType(string type, string expectedOutput, PlatformName platform) { string source = // no-op $"public func GetType{type} () {{\n" + "}\n"; string testName = $"TestObjectType{type}"; var mtID = new CSIdentifier("mt"); var mtDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, mtID, new CSFunctionCall("StructMarshal.Marshaler.Metatypeof", false, new CSSimpleType(type).Typeof())); var printer = CSFunctionCall.ConsoleWriteLine(mtID.Dot(new CSIdentifier("Kind"))); var callingCode = CSCodeBlock.Create(mtDecl, printer); TestRunning.TestAndExecute(source, callingCode, expectedOutput, testName: testName, platform: platform); }
public void TestAllocCount(string tag) { var swiftCode = $"public func neverUsed{tag}() {{\n}}\n"; var ptrID = new CSIdentifier("ptr"); var ptrDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, ptrID, new CSFunctionCall("System.Runtime.InteropServices.Marshal.AllocHGlobal", false, CSConstant.Val(128))); var clID = new CSIdentifier("ubp"); var clDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, clID, new CSFunctionCall(tag, true, ptrID, CSConstant.Val(128))); var printer = CSFunctionCall.ConsoleWriteLine(clID.Dot(new CSIdentifier("Count"))); var cleanUp = CSFunctionCall.FunctionCallLine("System.Runtime.InteropServices.Marshal.FreeHGlobal", false, ptrID); var callingCode = CSCodeBlock.Create(ptrDecl, clDecl, printer, cleanUp); TestRunning.TestAndExecute(swiftCode, callingCode, "128\n", testName: "TestAllocCount" + tag); }
public void TrivialEnumMarshalProp() { var swiftCode = @" import Foundation @objc public enum TrivEnum0 : Int { case None, Blind, Free } open class TrivClass0 { public init () { } open var X : TrivEnum0 = .Blind }"; var declID = new CSIdentifier("cl"); var decl = CSVariableDeclaration.VarLine(CSSimpleType.Var, declID, new CSFunctionCall("TrivClass0", true)); var printer = CSFunctionCall.ConsoleWriteLine(declID.Dot(new CSIdentifier("X"))); var callingCode = CSCodeBlock.Create(decl, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "Blind\n", platform: PlatformName.macOS); }
public void EnumInfixOpTest() { var swiftCode = @" public enum IntOrFloat { case IntVal(Int) case FloatVal(Float) } infix operator ^++^ : AdditionPrecedence public func ^++^ (left: IntOrFloat, right: IntOrFloat) -> IntOrFloat { switch left { case .IntVal(let x): switch right { case .IntVal(let y): return .IntVal(x + y) case .FloatVal(let y): return .FloatVal(Float(x) + y) } case .FloatVal(let x): switch right { case .IntVal(let y): return .FloatVal(x + Float(y)) case .FloatVal(let y): return .FloatVal(x + y) } } } "; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSFunctionCall("IntOrFloat.NewIntVal", false, CSConstant.Val(3))); var rightID = new CSIdentifier("right"); var rightDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, rightID, new CSFunctionCall("IntOrFloat.NewIntVal", false, CSConstant.Val(4))); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("TopLevelEntities.InfixOperatorHatPlusPlusHat", false, leftID, rightID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID.Dot(new CSIdentifier("ValueIntVal"))); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, rightDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "7\n"); }
public void VirtualPropIsVirtual() { string swiftCode = "open class ItsAVirtProp {\n" + " open var x = 0\n" + " public init (ix: Int) {\n" + " x = ix\n" + " }\n" + "}\n"; // var pi = typeof (ItsAVirtProp).GetProperty ("X"); // Console.WriteLine(pi.GetGetMethod().IsVirtual); var piID = new CSIdentifier("pi"); var getProp = new CSFunctionCall("GetProperty", false, CSConstant.Val("X")); var propInfo = CSVariableDeclaration.VarLine(CSSimpleType.Var, piID, new CSSimpleType("ItsAVirtProp").Typeof().Dot(getProp)); var getGet = new CSFunctionCall("GetGetMethod", false); var printer = CSFunctionCall.ConsoleWriteLine(piID.Dot(getGet.Dot(new CSIdentifier("IsVirtual")))); var callingCode = CSCodeBlock.Create(propInfo, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "True\n", platform: PlatformName.macOS); }
public void WrapOptionalVirtualProp() { string swiftCode = "open class OptPropClass {\n" + " open var x:Int? = 17\n" + " public init () {\n" + " }\n" + " open func referenceFunc () -> Int? {\n" + " return x\n" + " }" + "}\n"; var classID = new CSIdentifier("cl"); var classDecl = CSVariableDeclaration.VarLine(new CSSimpleType("OptPropClass"), classID, new CSFunctionCall("OptPropClass", true)); var printer = CSFunctionCall.ConsoleWriteLine(classID.Dot((CSIdentifier)"X").Dot((CSIdentifier)"Value")); var callingCode = CSCodeBlock.Create(classDecl, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "17\n", platform: PlatformName.macOS); }
public void TestAddCount(string swiftType, string cstype, string val1) { var variant = swiftType; var swiftCode = $"public func makeSetTAC{variant}() -> Set<{swiftType}> {{\n" + " return Set()\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> (); var setID = new CSIdentifier("theSet"); var setDecl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftSet", false, new CSSimpleType(cstype)), setID, new CSFunctionCall($"TopLevelEntities.MakeSetTAC{variant}", false)); var countLine = CSFunctionCall.ConsoleWriteLine(setID.Dot(new CSIdentifier("Count"))); var addLine = CSFunctionCall.FunctionCallLine("theSet.Insert", false, new CSIdentifier(val1)); callingCode.Add(setDecl); callingCode.Add(countLine); callingCode.Add(addLine); callingCode.Add(countLine); TestRunning.TestAndExecute(swiftCode, callingCode, "0\n1\n", testName: $"TestAddCount{variant}"); }
public void CanGetProtocolConformanceDescMarshal() { // var confDesc = StructMarshal.Marshaler.ProtocolConformanceof (typeof (IIteratorProtocol<>), // typeof (SwiftIteratorProtocolProxy<nint>); // Console.WriteLine (confDesc != IntPtr.Zero); var swiftCode = @" public func canGetProtocolConfDescMarshal () { } "; var confDescID = new CSIdentifier("confDesc"); var concreteType = new CSSimpleType("SwiftIteratorProtocolProxy<nint>").Typeof(); var ifaceType = new CSSimpleType("IIteratorProtocol<>").Typeof(); var confDescDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, confDescID, new CSFunctionCall("StructMarshal.Marshaler.ProtocolConformanceof", false, ifaceType, concreteType)); var printer = CSFunctionCall.ConsoleWriteLine(confDescID.Dot(new CSIdentifier("Handle")) != new CSIdentifier("IntPtr.Zero")); var callingCode = CSCodeBlock.Create(confDescDecl, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "True\n"); }
public void CanGetAssociatedTypeFromAny (string swiftType, string csType, string initData, string nameSuffix = null) { nameSuffix = nameSuffix ?? swiftType; var swiftCode = $@" private class FooAny{nameSuffix} : IteratorProtocol {{ public init () {{ }} private var data : [{swiftType}] = {initData} private var x = -1 public func next () -> {swiftType}? {{ if x < data.count {{ x = x + 1 return data[x] }} else {{ return nil }} }} }} public func blindAssocFuncAny{nameSuffix} () -> Any {{ return FooAny{nameSuffix} () }} "; // var any = TopLevelEntities.BlindAssocFuncAny (); // var types = StructMarshal.Marshaler.GetAssociateTypes (any.ObjectMetadata, typeof (IIteratorProtocol<>), 1); // Console.WriteLine (types[0].Name); var anyID = new CSIdentifier ("any"); var anyDecl = CSVariableDeclaration.VarLine (anyID, new CSFunctionCall ($"TopLevelEntities.BlindAssocFuncAny{nameSuffix}", false)); var assocTypesID = new CSIdentifier ("assoc"); var typesID = new CSIdentifier ("tyypes"); var typesDecl = CSVariableDeclaration.VarLine (typesID, new CSFunctionCall ("StructMarshal.Marshaler.GetAssociatedTypes", false, anyID.Dot (new CSIdentifier ("ObjectMetadata")), new CSSimpleType ("IIteratorProtocol<>").Typeof (), CSConstant.Val (1))); var printer = CSFunctionCall.ConsoleWriteLine (new CSIndexExpression (typesID, false, CSConstant.Val (0)).Dot (new CSIdentifier ("Name"))); var callingCode = CSCodeBlock.Create (anyDecl, typesDecl, printer); TestRunning.TestAndExecute (swiftCode, callingCode, $"{csType}\n", testName: $"CanGetAssociatedTypeFromAny{nameSuffix}"); }