public void TestSizeof(string typeName, string expected)
{
using (DisposableTempDirectory temp = new DisposableTempDirectory(null, true)) {
string csFile = Path.Combine(temp.DirectoryPath, temp.UniqueName("CS", "", "cs"));
string source = $@"using System;
using SwiftRuntimeLibrary;
using SwiftRuntimeLibrary.SwiftMarshal;
namespace dlopentest
{{
class MainClass
{{
public static void Main (string[] args)
{{
var size = StructMarshal.Marshaler.Sizeof(typeof({typeName}));
Console.WriteLine(size);
}}
}}
}}";
source += TestRunning.GetManagedConsoleRedirectCode();
File.WriteAllText(csFile, source);
Compiler.CSCompile(temp.DirectoryPath, new string [] { csFile }, "TestIt.exe", $"-lib:{Compiler.CompilerLocation.SwiftCompilerLib}");
TestRunning.CopyTestReferencesTo(temp.DirectoryPath);
string output = Compiler.RunWithMono(Path.Combine(temp.DirectoryPath, "TestIt.exe"), temp.DirectoryPath);
Assert.AreEqual(expected, output);
}
}
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 CustomSwiftCompiler(SwiftTargetCompilerInfo compilerInfo,
DisposableTempDirectory fileProvider, // can be null
bool disposeSuppliedDirectory)
{
CompilerInfo = compilerInfo;
tempDirectory = fileProvider ?? new DisposableTempDirectory(null, true);
disposeTempDirectory = fileProvider != null ? disposeSuppliedDirectory : true;
}
public void WrapSingleMethod(string type, string returnVal)
{
string simpleClass = String.Format("public final class Monty {{ public init() {{ }}\n public func val() -> {0} {{ return {1}; }} }}", type, returnVal);
using (DisposableTempDirectory provider = new DisposableTempDirectory(null, false)) {
Utils.CompileSwift(simpleClass, provider);
Utils.CompileToCSharp(provider);
}
}
void CheckName(string typeName, string expected)
{
using (DisposableTempDirectory temp = new DisposableTempDirectory(null, true)) {
string csFile = Path.Combine(temp.DirectoryPath, temp.UniqueName("CS", "", "cs"));
string source = $@"using System;
using SwiftRuntimeLibrary;
using SwiftRuntimeLibrary.SwiftMarshal;
namespace dlopentest
{{
class MainClass
{{
public static void Main (string[] args)
{{
SwiftNominalTypeDescriptor nt = StructMarshal.Marshaler.Metatypeof(typeof({typeName})).GetNominalTypeDescriptor();
Console.WriteLine(nt.GetFullName());
}}
}}
}}";
source += TestRunning.GetManagedConsoleRedirectCode();
File.WriteAllText(csFile, source);
Compiler.CSCompile(temp.DirectoryPath, new string [] { csFile }, "TestIt.exe", $"-lib:{Compiler.CompilerLocation.SwiftCompilerLib}", PlatformName.macOS);
TestRunning.CopyTestReferencesTo(temp.DirectoryPath);
string output = Compiler.RunWithMono(Path.Combine(temp.DirectoryPath, "TestIt.exe"), temp.DirectoryPath, platform: PlatformName.macOS);
Assert.AreEqual(expected, output);
string tsource = $@"using System;
using NewClassCompilerTests;
using SwiftRuntimeLibrary;
using TomTest;
using SwiftRuntimeLibrary.SwiftMarshal;
namespace MetatypeTests
{{
public class CheckName{typeName} : ITomTest
{{
public void Run()
{{
SwiftNominalTypeDescriptor nt = StructMarshal.Marshaler.Metatypeof(typeof({typeName})).GetNominalTypeDescriptor();
Console.WriteLine(nt.GetMangledName());
}}
public string TestName {{ get {{ return ""CheckName{typeName}""; }} }}
public string ExpectedOutput {{ get {{ return {ToStringLiteral (expected)}; }} }}
}}
}}";
string thisTestPath = Path.Combine(Compiler.kSwiftDeviceTestRoot, "MetatypeTests");
Directory.CreateDirectory(thisTestPath);
string tpath = Path.Combine(thisTestPath, $"CheckName{typeName}.cs");
File.WriteAllText(tpath, tsource);
}
}
public void GetDirectLayoutModuleName()
{
using (var tmp = new DisposableTempDirectory()) {
CreateFileAtLocation(tmp.DirectoryPath, "Foo");
Assert.IsNull(SwiftModuleFinder.GetDirectLayoutModuleName(Path.Combine(tmp.DirectoryPath, "Foo")));
CreateFileAtLocation(tmp.DirectoryPath, "Bar.swiftmodule");
Assert.AreEqual("Bar", SwiftModuleFinder.GetDirectLayoutModuleName(Path.Combine(tmp.DirectoryPath, "Bar.swiftmodule")));
}
}
public void GetAppleModuleName_RequiresValidName()
{
using (var tmp = new DisposableTempDirectory()) {
CreateFileAtLocation(tmp.DirectoryPath, "Foo", "Modules", "Foo.swiftmodule");
Assert.IsNull(SwiftModuleFinder.GetAppleModuleName(Path.Combine(tmp.DirectoryPath, "Foo")));
CreateFileAtLocation(tmp.DirectoryPath, ".framework", "Modules", ".swiftmodule");
Assert.IsNull(SwiftModuleFinder.GetAppleModuleName(Path.Combine(tmp.DirectoryPath, ".framework")));
}
}
public static string CompileToCSharp(DisposableTempDirectory provider, string outputDirectory = null, string moduleName = "Xython", string target = "x86_64-apple-macosx10.9", IEnumerable <string> additionalTypeDatabases = null, bool separateProcess = false, UnicodeMapper unicodeMapper = null, int expectedErrorCount = -1)
{
NewClassCompiler ncc = DefaultCSharpCompiler(unicodeMapper);
List <string> typeDatabases = Compiler.kTypeDatabases;
if (additionalTypeDatabases != null)
{
typeDatabases.AddRange(additionalTypeDatabases);
}
ClassCompilerLocations classCompilerLocations = new ClassCompilerLocations(new List <string> {
provider.DirectoryPath, Compiler.kSwiftRuntimeGlueDirectory
},
new List <string> {
provider.DirectoryPath, Compiler.kSwiftRuntimeGlueDirectory
},
typeDatabases);
ClassCompilerNames compilerNames = new ClassCompilerNames(moduleName, null);
if (separateProcess)
{
var args = new StringBuilder();
args.Append($"--debug ");
args.Append($"{Path.Combine (Path.GetDirectoryName (ncc.GetType ().Assembly.Location), "tom-swifty.exe")} ");
args.Append($"--swift-bin-path={StringUtils.Quote (Compiler.CompilerLocation.SwiftCompilerBin)} ");
args.Append($"--swift-lib-path={StringUtils.Quote (Path.GetDirectoryName (Compiler.CompilerLocation.SwiftCompilerLib))} ");
args.Append($"--retain-xml-reflection ");
foreach (var db in typeDatabases)
{
args.Append($"--type-database-path={StringUtils.Quote (db)} ");
}
args.Append($"--retain-swift-wrappers ");
args.Append($"--wrapping-module-name={StringUtils.Quote (moduleName)}Wrapping ");
foreach (var l in classCompilerLocations.LibraryDirectories)
{
args.Append($"-L {StringUtils.Quote (l)} ");
}
foreach (var m in classCompilerLocations.ModuleDirectories)
{
args.Append($"-M {StringUtils.Quote (m)} ");
}
args.Append($"-o {StringUtils.Quote (outputDirectory ?? provider.DirectoryPath)} ");
args.Append($"--module-name={StringUtils.Quote (moduleName)} ");
return(ExecAndCollect.Run("mono", args.ToString()));
}
else
{
ErrorHandling errors = ncc.CompileToCSharp(classCompilerLocations, compilerNames, new List <string> {
target
}, outputDirectory ?? provider.DirectoryPath);
CheckErrors(errors, expectedErrorCount);
return(null);
}
}
public void RelativePathsInSymlinks2()
{
using (var dir = new DisposableTempDirectory()) {
var expectedPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(dir.DirectoryPath)));
var link2 = Path.Combine(dir.DirectoryPath, "link2");
symlink(Path.Combine(dir.DirectoryPath, "..", "..", ".."), link2);
var finalPath = PosixHelpers.RealPath(link2);
Assert.AreEqual(expectedPath, finalPath, "2");
}
}
public void GetAppleModuleName_OnlyWorksWithValidStructure()
{
using (var tmp = new DisposableTempDirectory()) {
string framework = Path.Combine(tmp.DirectoryPath, "Foo.framework");
Directory.CreateDirectory(Path.Combine(framework, "Modules"));
Assert.IsNull(SwiftModuleFinder.GetAppleModuleName(framework));
File.Create(Path.Combine(framework, "Modules", "Foo.swiftmodule"));
Assert.AreEqual("Foo", SwiftModuleFinder.GetAppleModuleName(framework));
}
}
public void GetXamarinModuleName_OnlyWorksWithValidStructure()
{
const string Arch = "x86_64";
using (var tmp = new DisposableTempDirectory()) {
string folder = Path.Combine(tmp.DirectoryPath, "Foo");
Directory.CreateDirectory(Path.Combine(folder, Arch));
Assert.IsNull(SwiftModuleFinder.GetXamarinModuleName(folder, Arch));
CreateFileAtLocation(folder, "x86_64", "Foo.swiftmodule");
Assert.AreEqual("Foo", SwiftModuleFinder.GetXamarinModuleName(folder, Arch));
}
}
string RunBindingToolsForSwift(string swiftCode, string testName = null)
{
var nameSpace = "OutputTests";
using (TempDirectoryFilenameProvider provider = new TempDirectoryFilenameProvider()) {
var compiler = Utils.CompileSwift(swiftCode, provider, nameSpace);
var libName = $"lib{nameSpace}.dylib";
using (DisposableTempDirectory temp = new DisposableTempDirectory()) {
File.Copy(Path.Combine(compiler.DirectoryPath, libName), Path.Combine(temp.DirectoryPath, libName));
return(Utils.CompileToCSharp(provider, temp.DirectoryPath, nameSpace, separateProcess: true));
}
}
}
static void Compile(SwiftyOptions options, UnicodeMapper unicodeMapper, ErrorHandling errors)
{
try {
using (DisposableTempDirectory temp = new DisposableTempDirectory(null, true)) {
SwiftCompilerLocation compilerLocation = new SwiftCompilerLocation(options.SwiftBinPath, options.SwiftLibPath);
ClassCompilerOptions compilerOptions = new ClassCompilerOptions(options.TargetPlatformIs64Bit, options.Verbose, options.RetainXmlReflection, options.RetainSwiftWrappingCode);
NewClassCompiler classCompiler = new NewClassCompiler(compilerLocation, compilerOptions, unicodeMapper);
ClassCompilerNames compilerNames = new ClassCompilerNames(options.ModuleName, options.WrappingModuleName);
ClassCompilerLocations classCompilerLocations = new ClassCompilerLocations(options.ModulePaths, options.DylibPaths, options.TypeDatabasePaths);
var compileErrors = classCompiler.CompileToCSharp(classCompilerLocations, compilerNames, options.Targets, options.OutputDirectory);
errors.Add(compileErrors);
}
} catch (Exception err) {
errors.Add(err);
}
}
public static CustomSwiftCompiler CompileSwift(string swiftCode, DisposableTempDirectory provider = null, string moduleName = "Xython", string target = "x86_64-apple-macosx10.9")
{
CustomSwiftCompiler compiler = DefaultSwiftCompiler(provider, target: target);
string [] includeDirectories = null;
List <string> libraryDirectories = new List <string> {
compiler.DirectoryPath, Compiler.kSwiftRuntimeGlueDirectory
};
if (provider != null)
{
includeDirectories = new string [] { provider.DirectoryPath };
libraryDirectories.Add(provider.DirectoryPath);
}
SwiftCompilerOptions options = new SwiftCompilerOptions(moduleName, includeDirectories, libraryDirectories.ToArray(), new string [] { "XamGlue" });
compiler.CompileString(options, swiftCode);
return(compiler);
}
public FileResult Download(RegionalSubbasinRevisionRequestPrimaryKey regionalSubbasinRevisionRequestPrimaryKey)
{
var geometry = regionalSubbasinRevisionRequestPrimaryKey.EntityObject
.RegionalSubbasinRevisionRequestGeometry;
var reprojectedGeometry = CoordinateSystemHelper.ProjectWebMercatorTo2230(geometry);
var geoJson = DbGeometryToGeoJsonHelper.FromDbGeometryWithNoReproject(reprojectedGeometry);
var serializedGeoJson = JsonConvert.SerializeObject(geoJson);
var outputLayerName = $"BMP_{regionalSubbasinRevisionRequestPrimaryKey.EntityObject.TreatmentBMP.TreatmentBMPID}_RevisionRequest";
using (var workingDirectory = new DisposableTempDirectory())
{
var outputPathForLayer =
Path.Combine(workingDirectory.DirectoryInfo.FullName, outputLayerName);
var ogr2OgrCommandLineRunner = new Ogr2OgrCommandLineRunner(NeptuneWebConfiguration.Ogr2OgrExecutable,
CoordinateSystemHelper.NAD_83_CA_ZONE_VI_SRID,
NeptuneWebConfiguration.HttpRuntimeExecutionTimeout.TotalMilliseconds);
ogr2OgrCommandLineRunner.ImportGeoJsonToFileGdb(serializedGeoJson, outputPathForLayer,
outputLayerName, false, true);
using (var zipFile = DisposableTempFile.MakeDisposableTempFileEndingIn(".zip"))
{
ZipFile.CreateFromDirectory(workingDirectory.DirectoryInfo.FullName, zipFile.FileInfo.FullName);
var fileStream = zipFile.FileInfo.OpenRead();
var bytes = fileStream.ReadFully();
fileStream.Close();
fileStream.Dispose();
return(File(bytes, "application/zip", $"{outputLayerName}.zip"));
}
}
}
public static CustomSwiftCompiler DefaultSwiftCompiler(DisposableTempDirectory provider = null, string target = "x86_64-apple-macosx10.9")
{
var targetInfo = Compiler.CompilerLocation.GetTargetInfo(target);
return(new CustomSwiftCompiler(targetInfo, provider, false));
}
public static void TestAndExecute(string swiftCode, CodeElementCollection <ICodeElement> callingCode,
string expectedOutput,
string testName = null,
CSClass otherClass = null, string skipReason = null,
string iosExpectedOutput = null,
PlatformName platform = PlatformName.None,
UnicodeMapper unicodeMapper = null, int expectedErrorCount = 0,
Action <string> postCompileCheck = null,
string[] expectedOutputContains = null)
{
SetInvokingTestNameIfUnset(ref testName, out string nameSpace);
string testClassName = "TomTest" + testName;
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, expectedErrorCount: expectedErrorCount);
if (postCompileCheck != null)
{
postCompileCheck(tempDirectoryPath);
}
Tuple <CSNamespace, CSUsingPackages> testClassParts = TestRunningCodeGenerator.CreateTestClass(callingCode, testName, iosExpectedOutput ?? expectedOutput, nameSpace,
testClassName, otherClass, skipReason, platform);
var thisTestPath = Path.Combine(Compiler.kSwiftDeviceTestRoot, nameSpace);
Directory.CreateDirectory(thisTestPath);
var thisTestPathSwift = Path.Combine(thisTestPath, "swiftsrc");
Directory.CreateDirectory(thisTestPathSwift);
var swiftPrefix = string.Empty;
var swiftSuffix = string.Empty;
var csPrefix = string.Empty;
var csSuffix = string.Empty;
var nameSuffix = string.Empty;
switch (platform)
{
case PlatformName.macOS:
swiftPrefix = "#if os(OSX)\n";
swiftSuffix = "#endif\n";
csPrefix = "#if __MACOS__\n";
csSuffix = "\n#endif\n";
nameSuffix = "_macOS";
break;
case PlatformName.iOS:
swiftPrefix = "#if os(iOS)\n";
swiftSuffix = "#endif\n";
csPrefix = "#if __IOS__\n";
csSuffix = "\n#endif\n";
nameSuffix = "_iOS";
break;
case PlatformName.tvOS:
swiftPrefix = "#if os(tvOS)\n";
swiftSuffix = "#endif\n";
csPrefix = "#if __TVOS__\n";
csSuffix = "\n#endif\n";
nameSuffix = "_tvOS";
break;
case PlatformName.watchOS:
swiftPrefix = "#if os(watchOS)\n";
swiftSuffix = "#endif\n";
csPrefix = "#if __WATCHOS__\n";
csSuffix = "\n#endif\n";
nameSuffix = "_watchOS";
break;
case PlatformName.None:
break;
default:
throw new NotImplementedException(platform.ToString());
}
File.WriteAllText(Path.Combine(thisTestPathSwift, $"{testClassName}{testName}{nameSuffix}.swift"), swiftPrefix + swiftCode + swiftSuffix);
CSFile csTestFile = CSFile.Create(testClassParts.Item2, testClassParts.Item1);
var csTestFilePath = Path.Combine(thisTestPath, $"{testClassName}{testName}{nameSuffix}.cs");
// Write out the file without csPrefix/csSuffix
CodeWriter.WriteToFile(csTestFilePath, csTestFile);
if (!string.IsNullOrEmpty(csPrefix) || !string.IsNullOrEmpty(csSuffix))
{
// Read the C# code, and prepend/append the csPrefix/csSuffix blobs, then save the modified contents again.
File.WriteAllText(csTestFilePath, csPrefix + File.ReadAllText(csTestFilePath) + csSuffix);
}
var csFile = TestRunningCodeGenerator.GenerateTestEntry(callingCode, testName, nameSpace, platform, otherClass);
csFile.Namespaces.Add(CreateManagedConsoleRedirect());
CodeWriter.WriteToFile(Path.Combine(tempDirectoryPath, "NameNotImportant.cs"), csFile);
var sourceFiles = Directory.GetFiles(tempDirectoryPath, "*.cs");
var objcRuntimePath = Path.Combine(tempDirectoryPath, "ObjCRuntime");
if (Directory.Exists(objcRuntimePath))
{
sourceFiles = sourceFiles.And(Directory.GetFiles(objcRuntimePath, "*.cs"));
}
var compilerWarnings = Compiler.CSCompile(tempDirectoryPath, sourceFiles, "NameNotImportant.exe", platform: platform);
if (compilerWarnings.Contains("warning"))
{
FailOnBadWarnings(compilerWarnings);
}
CopyTestReferencesTo(tempDirectoryPath, platform);
var output = Execute(tempDirectoryPath, "NameNotImportant.exe", platform);
if (expectedOutput != null)
{
Assert.AreEqual(expectedOutput, output);
}
else
{
foreach (var s in expectedOutputContains)
{
Assert.IsTrue(output.Contains(s), $"Expected to find string {s} in {output}");
}
}
}
}
