public void TLDictionaryAddGet(string sKeyType, string sValType, string csKeyType, string csValType, string csKey, string csValue, string output) { string swiftCode = $"public func makeDictTLDAG{sKeyType}{sValType}() -> [{sKeyType}:{sValType}]\n {{\n return [{sKeyType}:{sValType}]() \n}}\n"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftDictionary", false, new CSSimpleType(csKeyType), new CSSimpleType(csValType)), new CSIdentifier("dict"), new CSFunctionCall($"TopLevelEntities.MakeDictTLDAG{sKeyType}{sValType}", false)); CSLine call = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("dict.Count")); CSLine addcall = CSFunctionCall.FunctionCallLine("dict.Add", false, new CSIdentifier(csKey), new CSIdentifier(csValue)); CSLine writeCall = CSFunctionCall.FunctionCallLine("Console.Write", false, CSConstant.Val(' ')); CSLine getLine = CSVariableDeclaration.VarLine(new CSSimpleType(csValType), "val", new CSArray1D("dict", new CSIdentifier(csKey))); CSLine valueWrite = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("val")); callingCode.Add(decl); callingCode.Add(call); callingCode.Add(addcall); callingCode.Add(writeCall); callingCode.Add(call); callingCode.Add(writeCall); callingCode.Add(getLine); callingCode.Add(valueWrite); TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"TLDictionaryAddGet{sKeyType}{sValType}"); }
void TLArrayMethodRemove(string swiftType, string csType, string csValue, string csNewValue, string output) { string swiftCode = $"public class FooTLAMR{swiftType} {{\n" + $"public init() {{ }}\n" + $"public func makeArray(a:{swiftType}) -> [{swiftType}]\n {{\n return [{swiftType}](repeating:a, count:2) \n}}\n" + $"}}"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftArray", false, new CSSimpleType(csType)), new CSIdentifier("arr"), new CSFunctionCall($"new FooTLAMR{swiftType}().MakeArray", false, new CSIdentifier(csValue))); CSLine addLine = CSFunctionCall.FunctionCallLine("arr.Insert", false, CSConstant.Val(1), new CSIdentifier(csNewValue)); CSLine remLine = CSFunctionCall.FunctionCallLine("arr.RemoveAt", false, CSConstant.Val(1)); CSLine call = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("arr.Count")); CSForEach feach = new CSForEach(new CSSimpleType(csType), "x", new CSIdentifier("arr"), null); feach.Body.Add(CSFunctionCall.FunctionCallLine("Console.Write", false, CSConstant.Val(" {0}"), feach.Ident)); callingCode.Add(decl); callingCode.Add(addLine); callingCode.Add(remLine); callingCode.Add(call); callingCode.Add(feach); TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"TLArrayMethodRemove{swiftType}"); }
public void TestSetRemove(string swiftType, string cstype, string val) { var variant = swiftType; var swiftCode = $"public func makeSetTR{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.MakeSetTR{variant}", false)); var valID = new CSIdentifier("theVal"); var valDecl = CSVariableDeclaration.VarLine(new CSSimpleType(cstype), valID, new CSIdentifier(val)); var containsLine = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("theSet.Contains", (CSIdentifier)val)); var addLine = CSFunctionCall.FunctionCallLine("theSet.Insert", false, valID); var removeLine = CSFunctionCall.FunctionCallLine("theSet.Remove", false, valID); callingCode.Add(setDecl); callingCode.Add(valDecl); callingCode.Add(containsLine); callingCode.Add(addLine); callingCode.Add(containsLine); callingCode.Add(removeLine); callingCode.Add(containsLine); TestRunning.TestAndExecute(swiftCode, callingCode, "False\nTrue\nFalse\n", testName: $"TestSetRemove{variant}"); }
public void TestCharacterCreation() { var swiftCode = @" public class CharacterHolder { public var C: Character; public init (c: Character) {C = c } }"; var callingCode = new CodeElementCollection <ICodeElement> (); StringBuilder expected = new StringBuilder(); foreach (string c in TestCases) { CSIdentifier testIdentifier = (CSIdentifier)$@"""{c}"""; Action <ICSExpression> testCharacter = creation => { CSCodeBlock block = new CSCodeBlock(); block.Add(CSVariableDeclaration.VarLine((CSSimpleType)"SwiftCharacter", (CSIdentifier)"Char", creation)); block.Add(CSVariableDeclaration.VarLine((CSSimpleType)"CharacterHolder", (CSIdentifier)"Foo", CSFunctionCall.Ctor("CharacterHolder", (CSIdentifier)"Char"))); block.Add(CSFunctionCall.FunctionLine("Console.Write", (CSIdentifier)"(string)Foo.C")); expected.Append(c); callingCode.Add(block); }; testCharacter(CSFunctionCall.Function("SwiftCharacter.FromCharacter", (testIdentifier))); testCharacter(new CSCastExpression((CSSimpleType)"SwiftCharacter", testIdentifier)); } TestRunning.TestAndExecute(swiftCode, callingCode, expected.ToString()); }
public void TestCharacterConstructors() { var swiftCode = @"public func Echo (c: Character) -> Character { return c; }"; var callingCode = new CodeElementCollection <ICodeElement> (); StringBuilder expected = new StringBuilder(); foreach (string c in TestCases) { CSIdentifier testIdentifier = (CSIdentifier)$@"""{c}"""; var ctorCall = CSFunctionCall.Ctor("SwiftCharacter", testIdentifier); var fromCall = CSFunctionCall.Function("SwiftCharacter.FromCharacter", testIdentifier); var implicitCall = new CSCastExpression((CSSimpleType)"SwiftCharacter", testIdentifier); foreach (var call in new CSBaseExpression [] { ctorCall, fromCall, implicitCall }) { CSLine print = CSFunctionCall.FunctionLine("Console.Write", CSFunctionCall.Function("TopLevelEntities.Echo", call)); callingCode.Add(print); expected.Append(c); } } TestRunning.TestAndExecute(swiftCode, callingCode, expected.ToString()); }
public void EnumInlinePrefixOperator() { var swiftCode = @" prefix operator ^+-+^ public enum CompassPoints4 { case North, East, South, West public static prefix func ^+-+^ (item: CompassPoints4) -> CompassPoints4 { switch item { case .North: return .West case .East: return .North case .South: return .East case .West: return .South } } } "; var itemID = new CSIdentifier("item"); var itemDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, itemID, new CSIdentifier("CompassPoints4.North")); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("CompassPoints4Extensions.PrefixOperatorHatPlusMinusPlusHat", false, itemID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID); var callingCode = new CodeElementCollection <ICodeElement> { itemDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "West\n"); }
public static void TestAndExecuteNoDevice(string swiftCode, CodeElementCollection <ICodeElement> callingCode, string expectedOutput, string testName = null, PlatformName platform = PlatformName.None, UnicodeMapper unicodeMapper = null) { SetInvokingTestNameIfUnset(ref testName, out string nameSpace); using (var provider = new DisposableTempDirectory()) { var compiler = Utils.CompileSwift(swiftCode, provider, nameSpace); var libName = $"lib{nameSpace}.dylib"; var tempDirectoryPath = Path.Combine(provider.DirectoryPath, "BuildDir"); Directory.CreateDirectory(tempDirectoryPath); File.Copy(Path.Combine(compiler.DirectoryPath, libName), Path.Combine(tempDirectoryPath, libName)); Utils.CompileToCSharp(provider, tempDirectoryPath, nameSpace, unicodeMapper: unicodeMapper); CSFile csFile = TestRunningCodeGenerator.GenerateTestEntry(callingCode, testName, nameSpace, platform); csFile.Namespaces.Add(CreateManagedConsoleRedirect()); CodeWriter.WriteToFile(Path.Combine(tempDirectoryPath, "NameNotImportant.cs"), csFile); var sourceFiles = Directory.GetFiles(tempDirectoryPath, "*.cs"); Compiler.CSCompile(tempDirectoryPath, sourceFiles, "NameNotImportant.exe", platform: platform); CopyTestReferencesTo(tempDirectoryPath, platform); var output = Execute(tempDirectoryPath, "NameNotImportant.exe", platform); Assert.AreEqual(expectedOutput, output); } }
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 EnumInlineInfixOperator() { var swiftCode = @" infix operator ^*=*^ public enum CompassPoints3 { case North, East, South, West public static func ^*=*^(left: CompassPoints3, right: CompassPoints3) -> Bool { return left == right } } "; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSIdentifier("CompassPoints3.North")); var rightID = new CSIdentifier("right"); var rightDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, rightID, new CSIdentifier("CompassPoints3.East")); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("CompassPoints3Extensions.InfixOperatorHatStarEqualsStarHat", false, leftID, rightID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, rightDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "False\n"); }
public void SuperSimpleEnumTest() { var swiftCode = @" import Foundation @objc public enum CompassPoints2 : Int { case North = 0, East, South, West } prefix operator ^*^ public prefix func ^*^(val: CompassPoints2) -> CompassPoints2 { switch val { case .North: return .South case .East: return .West case .South: return .North case .West: return .East } }"; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSIdentifier("CompassPoints2.North")); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("TopLevelEntities.PrefixOperatorHatStarHat", false, leftID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "South\n"); }
public static CSFile GenerateTestEntry(CodeElementCollection <ICodeElement> callingCode, string testName, string nameSpace, PlatformName platform, CSClass otherClass = null) { var use = GetTestEntryPointUsings(nameSpace, platform); var ns = new CSNamespace(nameSpace); if (otherClass != null) { ns.Block.Add(otherClass); } var mainBody = new CSCodeBlock(callingCode); mainBody.Add(CaptureSwiftOutputPostlude(testName)); var main = new CSMethod(CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, (CSIdentifier)"Main", new CSParameterList(new CSParameter(CSSimpleType.CreateArray("string"), "args")), mainBody); var mainClass = new CSClass(CSVisibility.Public, "NameNotImportant", new CSMethod [] { main }); AddSupportingCode(mainClass, platform); ns.Block.Add(mainClass); return(CSFile.Create(use, ns)); }
public void SimpleEnumPostfixOpTest() { var swiftCode = @" public enum CompassPoints1 { case North, East, South, West } postfix operator ^+^ public postfix func ^+^(val: CompassPoints1) -> CompassPoints1 { switch val { case .North: return .East case .East: return .South case .South: return .West case .West: return .North } } "; var leftID = new CSIdentifier("left"); var leftDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, leftID, new CSIdentifier("CompassPoints1.North")); var resultID = new CSIdentifier("result"); var resultDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, resultID, new CSFunctionCall("TopLevelEntities.PostfixOperatorHatPlusHat", false, leftID)); var printer = CSFunctionCall.ConsoleWriteLine(resultID); var callingCode = new CodeElementCollection <ICodeElement> { leftDecl, resultDecl, printer }; TestRunning.TestAndExecute(swiftCode, callingCode, "East\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 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 OperatorCompositionNoInvoke() { var swiftCode = "infix operator ∘\n" + " public func ∘<T>(left: @escaping (T) -> (T), right: @escaping (T) -> (T)) -> (T) -> (T) {\n" + " return { (x) in\n" + " left (right(x))\n" + " }\n" + "}\n"; var lbody1 = new CSCodeBlock(); var lid = new CSIdentifier("d"); lbody1.Add(CSReturn.ReturnLine(lid * CSConstant.Val(2.0))); var pl = new CSParameterList(); pl.Add(new CSParameter(CSSimpleType.Double, lid)); var lam1 = new CSLambda(pl, lbody1); var lbody2 = new CSCodeBlock(); lbody2.Add(CSReturn.ReturnLine(lid * CSConstant.Val(3.0))); var lam2 = new CSLambda(pl, lbody2); var compFunc = CSFunctionCall.FunctionCallLine("TopLevelEntities.InfixOperatorRing", false, lam1, lam2); var printIt = CSFunctionCall.ConsoleWriteLine(CSConstant.Val(12.0)); var callingCode = new CodeElementCollection <ICodeElement> { compFunc, printIt }; TestRunning.TestAndExecute(swiftCode, callingCode, "12\n"); }
public CSTryCatch(CSCodeBlock tryBlock, params CSCatch [] catchBlocks) { TryBlock = tryBlock ?? new CSCodeBlock(); CatchBlocks = new CodeElementCollection <CSCatch> (); CatchBlocks.AddRange(catchBlocks); Add(new SimpleElememt("try ", true)); Add(TryBlock); Add(CatchBlocks); }
public SLDo(SLCodeBlock doBlock, params SLCatch [] catchBlocks) { DoBlock = doBlock ?? new SLCodeBlock(null); CatchBlocks = new CodeElementCollection <SLCatch> (); CatchBlocks.AddRange(catchBlocks); Add(new SimpleElememt("do ", true)); Add(DoBlock); Add(CatchBlocks); }
public void TheEpsilonIssue() { string swiftCode = "public let 𝑒 = 2.718\n"; var callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSFunctionCall.ConsoleWriteLine((CSIdentifier)"TopLevelEntities.LittleEpsilon")); TestRunning.TestAndExecute(swiftCode, callingCode, "2.718\n"); }
public void TopLevelPropertyAllUnicode1() { string swiftCode = "public var v\x3004:Int = 3\n"; var callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSFunctionCall.ConsoleWriteLine((CSIdentifier)"TopLevelEntities.VU3004")); TestRunning.TestAndExecute(swiftCode, callingCode, "3\n"); }
void WrapMultipleMethod(string type, string return1, string return2, string expected) { string swiftCode = String.Format("public final class MontyWMM{3} {{ public init() {{ }}\n public func val() -> {0} {{ return {1}; }}; public func val1() -> {0} {{ return {2}; }}}}", type, return1, return2, type); CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSFunctionCall.ConsoleWriteLine(CSConstant.Val("{0} {1}"), CSFunctionCall.Ctor($"MontyWMM{type}").Dot(CSFunctionCall.Function("Val")), CSFunctionCall.Ctor($"MontyWMM{type}").Dot(CSFunctionCall.Function("Val1")))); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapMultiMethod{type}"); }
void WrapSingleMethod(string type, string returnVal, string expected) { string swiftCode = String.Format("public final class MontyWSM{2} {{ class InnerMonty {{\n}}\npublic init() {{}}\n public func val() -> {0} {{ return {1}; }} }}", type, returnVal, type); CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Ctor($"MontyWSM{type}").Dot(CSFunctionCall.Function("Val")))); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleMethod{type}"); }
public void TopLevelFunctionAllUnicode1() { string swiftCode = "public func f\x3004() -> Int {\n" + " return 3\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.FU3004"))); TestRunning.TestAndExecute(swiftCode, callingCode, "3\n"); }
/// <summary>コードリストを生成します</summary> private void Generate(CodeElementCollection codeList, StringWriter writer) { string indent = codeList.Indent; foreach (ICodeElement element in codeList) { if (element.PhraseType == PhraseTypes.改行字句) { continue; } Generate(element, writer, indent); } }
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); }
public void UnicodeInOperatorName() { string swiftCode = "infix operator \x2295\x2295\n" + "public func \x2295\x2295 (left:Int, right: Int) -> Int {\n" + " return left + right\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> { CSVariableDeclaration.VarLine((CSSimpleType)"nint", "x", CSFunctionCall.Function("TopLevelEntities.InfixOperatorCirclePlusCirclePlus", CSConstant.Val(3), CSConstant.Val(4))), CSFunctionCall.ConsoleWriteLine((CSIdentifier)"x") }; TestRunning.TestAndExecute(swiftCode, callingCode, "7\n"); }
void WrapSingleProperty(string type, string returnVal, string reassignVal, string expected) { string swiftCode = String.Format("public final class MontyWSP{2} {{ public init() {{ }}\npublic var val:{0} = {1}; }}", type, returnVal, type); CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> { CSAssignment.Assign("var nothing", CSFunctionCall.Ctor($"MontyWSP{type}")), CSFunctionCall.ConsoleWriteLine(CSIdentifier.Create("nothing").Dot((CSIdentifier)"Val")), CSAssignment.Assign("nothing.Val", new CSConstant(reassignVal)), CSFunctionCall.ConsoleWriteLine(CSIdentifier.Create("nothing").Dot((CSIdentifier)"Val")) }; TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleProperty{type}"); }
public void WrapClassReturningClass() { string classOne = "public final class GarbleWCRC { public init() { }\npublic func success() { var s = \"\"\n print(\"success\", to:&s)\nwriteToFile(s, \"WrapClassReturningClass\")\n } }\n"; string classTwo = "public final class MontyWCRC { public init() { }\npublic func doIt() -> GarbleWCRC { return GarbleWCRC(); } }"; string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + classOne + classTwo; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSAssignment.Assign("var monty", new CSFunctionCall("MontyWCRC", true))); callingCode.Add(CSAssignment.Assign("var garb", new CSFunctionCall("monty.DoIt", false))); callingCode.Add(CSFunctionCall.FunctionCallLine("garb.Success", false)); TestRunning.TestAndExecute(swiftCode, callingCode, "success\n"); }
public void OperatorSmokeTest2() { var swiftCode = "postfix operator -*\n" + "public postfix func -* (arg: Int) -> Int {\n" + " return -1 * arg\n" + "}\n"; var printIt = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.PostfixOperatorMinusStar", CSConstant.Val(88))); var callingCode = new CodeElementCollection <ICodeElement> { printIt }; TestRunning.TestAndExecute(swiftCode, callingCode, "-88\n"); }
public void OperatorSmokeTest1() { var swiftCode = "prefix operator *-\n" + "public prefix func *- (arg: Int) -> Int {\n" + " return -1 * arg\n" + "}\n"; var printIt = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.PrefixOperatorStarMinus", CSConstant.Val(47))); var callingCode = new CodeElementCollection <ICodeElement> { printIt }; TestRunning.TestAndExecute(swiftCode, callingCode, "-47\n"); }
public void UnicodeInClassNameAndProperty() { string swiftCode = "public class cd1\x1800 {\n" + " public init() { }\n" + " public var v\x3004:Int = 3\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> { CSVariableDeclaration.VarLine((CSSimpleType)"Cd1U1800", "cl", CSFunctionCall.Ctor("Cd1U1800")), CSFunctionCall.ConsoleWriteLine((CSIdentifier)"cl.VU3004") }; TestRunning.TestAndExecute(swiftCode, callingCode, "3\n"); }