public void ReferenceFiles() { var t = new ResolveComReference.TlbImp(); Assert.Null(t.ReferenceFiles); // "ReferenceFiles should be null by default" t.ReferenceFiles = new string[] { "File1.dll", "File2.dll" }; CommandLine.ValidateHasParameter(t, "/reference:File1.dll", false /* no response file */); CommandLine.ValidateHasParameter(t, "/reference:File2.dll", false /* no response file */); }
public void Machine() { var t = new ResolveComReference.TlbImp(); Assert.Null(t.Machine); // "Machine should be null by default" t.Machine = "Agnostic"; Assert.Equal("Agnostic", t.Machine); // "New TypeLibName value should be set" CommandLine.ValidateHasParameter(t, "/machine:Agnostic", false /* no response file */); }
public void TypeLibNameWithSpaces() { var t = new ResolveComReference.TlbImp(); string testParameterValue = @"c:\Program Files\Interop.Foo.dll"; Assert.Null(t.TypeLibName); // "TypeLibName should be null by default" t.TypeLibName = testParameterValue; Assert.Equal(testParameterValue, t.TypeLibName); // "New TypeLibName value should be set" CommandLine.ValidateHasParameter(t, testParameterValue, false /* no response file */); }
public void TypeLibName() { var t = new ResolveComReference.TlbImp(); string testParameterValue = "Interop.Foo.dll"; Assert.IsNull(t.TypeLibName, "TypeLibName should be null by default"); t.TypeLibName = testParameterValue; Assert.AreEqual(testParameterValue, t.TypeLibName, "New TypeLibName value should be set"); CommandLine.ValidateHasParameter(t, testParameterValue, false /* no response file */); }
public void AssemblyNamespace() { var t = new ResolveComReference.TlbImp(); string testParameterValue = "Microsoft.Build.Foo"; Assert.Null(t.AssemblyNamespace); // "AssemblyNamespace should be null by default" CommandLine.ValidateNoParameterStartsWith(t, @"/namespace:", false /* no response file */); t.AssemblyNamespace = testParameterValue; Assert.Equal(testParameterValue, t.AssemblyNamespace); // "New AssemblyNamespace value should be set" CommandLine.ValidateHasParameter(t, @"/namespace:" + testParameterValue, false /* no response file */); }
public void KeyContainer() { var t = new ResolveComReference.TlbImp(); t.TypeLibName = "FakeTlb.tlb"; string badParameterValue = "badKeyContainer"; string goodParameterValue = "myKeyContainer"; try { t.ToolPath = Path.GetTempPath(); Assert.Null(t.KeyContainer); // "KeyContainer should be null by default" CommandLine.ValidateNoParameterStartsWith(t, @"/keycontainer:", false /* no response file */); t.KeyContainer = badParameterValue; Assert.Equal(badParameterValue, t.KeyContainer); // "New KeyContainer value should be set" CommandLine.ValidateHasParameter(t, @"/keycontainer:" + badParameterValue, false /* no response file */); Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.StrongNameUtils.NoKeyPairInContainer", t.KeyContainer); //ensure the key does not exist in the CSP StrongNameHelpers.StrongNameKeyDelete(goodParameterValue); IntPtr publicKeyBlob = IntPtr.Zero; int publicKeyBlobSize = 0; //add key to CSP if (StrongNameHelpers.StrongNameKeyGen(goodParameterValue, 1 /* leave key registered */, out publicKeyBlob, out publicKeyBlobSize) && publicKeyBlob != IntPtr.Zero) { StrongNameHelpers.StrongNameFreeBuffer(publicKeyBlob); t.KeyContainer = goodParameterValue; Assert.Equal(goodParameterValue, t.KeyContainer); // "New KeyContainer value should be set" CommandLine.ValidateHasParameter(t, @"/keycontainer:" + goodParameterValue, false /* no response file */); Utilities.ExecuteTaskAndVerifyLogDoesNotContainErrorFromResource(t, "AxTlbBaseTask.StrongNameUtils.NoKeyPairInContainer", t.KeyContainer); } else { Assert.True(false, "Key container could not be created."); } } finally { //remove key from CSP StrongNameHelpers.StrongNameKeyDelete(goodParameterValue); // get rid of the generated temp file if (goodParameterValue != null) { File.Delete(goodParameterValue); } } }
/* * Method: GenerateWrapper * * Generates a wrapper for this reference. */ internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string rootNamespace = ReferenceInfo.typeLibName; string wrapperPath = GetWrapperPath(); bool generateWrapperSucceeded = true; if (ExecuteAsTool) { // delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST // HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK var tlbImp = new ResolveComReference.TlbImp(); tlbImp.BuildEngine = BuildEngine; tlbImp.EnvironmentVariables = EnvironmentVariables; tlbImp.DelaySign = DelaySign; tlbImp.KeyContainer = KeyContainer; tlbImp.KeyFile = KeyFile; tlbImp.OutputAssembly = wrapperPath; tlbImp.ToolPath = ToolPath; tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath; tlbImp.AssemblyNamespace = rootNamespace; tlbImp.AssemblyVersion = null; tlbImp.PreventClassMembers = _noClassMembers; tlbImp.SafeArrayAsSystemArray = true; tlbImp.Silent = Silent; tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals; if (_referenceFiles != null) { // Issue is that there may be reference dependencies that need to be passed in. It is possible // that the set of references will also contain the file that is meant to be written here (when reference resolution // found the file in the output folder). We need to filter out this case. var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file. tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray(); } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: tlbImp.Machine = "Agnostic"; break; case UtilitiesProcessorArchitecture.AMD64: tlbImp.Machine = "X64"; break; case UtilitiesProcessorArchitecture.IA64: tlbImp.Machine = "Itanium"; break; case UtilitiesProcessorArchitecture.X86: tlbImp.Machine = "X86"; break; case UtilitiesProcessorArchitecture.ARM: tlbImp.Machine = "ARM"; break; case null: break; default: // Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message. tlbImp.Machine = _targetProcessorArchitecture; break; } generateWrapperSucceeded = tlbImp.Execute(); // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; // Changed to ReflectionOnlyLoadFrom, related to bug: // RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform // The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we // have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code. // // Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not // where we are right now. // // If we really do need to load it then: // // wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath); } else { // use framework classes in-proc to generate the assembly TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; StrongNameKeyPair keyPair; byte[] publicKey; GetAndValidateStrongNameKey(out keyPair, out publicKey); try { TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals; if (_noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: flags |= TypeLibImporterFlags.ImportAsAgnostic; break; case UtilitiesProcessorArchitecture.AMD64: flags |= TypeLibImporterFlags.ImportAsX64; break; case UtilitiesProcessorArchitecture.IA64: flags |= TypeLibImporterFlags.ImportAsItanium; break; case UtilitiesProcessorArchitecture.X86: flags |= TypeLibImporterFlags.ImportAsX86; break; case UtilitiesProcessorArchitecture.ARM: flags |= TypeLibImporterFlags.ImportAsArm; break; default: // Let the type importer decide. break; } // Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs. assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, rootNamespace, null); } catch (COMException ex) { if (!Silent) { Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message); } throw new ComReferenceResolutionException(ex); } // if we're done, and this is not a temporary wrapper, write it out to disk if (!HasTemporaryWrapper) { WriteWrapperToDisk(assemblyBuilder, wrapperPath); } // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; } // ...and we're done! return generateWrapperSucceeded; }
public void Transform() { var t = new ResolveComReference.TlbImp(); var dispRet = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals; var serialize = ResolveComReference.TlbImpTransformFlags.SerializableValueClasses; var both = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals | ResolveComReference.TlbImpTransformFlags.SerializableValueClasses; t.TypeLibName = "SomeRandomControl.tlb"; t.ToolPath = Path.GetTempPath(); Assert.Equal(ResolveComReference.TlbImpTransformFlags.None, t.Transform); // "Transform should be TlbImpTransformFlags.None by default" CommandLine.ValidateNoParameterStartsWith(t, @"/transform:", false /* no response file */); t.Transform = dispRet; Assert.Equal(dispRet, t.Transform); // "New Transform value should be set" CommandLine.ValidateHasParameter(t, @"/transform:DispRet", false /* no response file */); t.Transform = serialize; Assert.Equal(serialize, t.Transform); // "New Transform value should be set" CommandLine.ValidateHasParameter(t, @"/transform:SerializableValueClasses", false /* no response file */); t.Transform = both; Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "TlbImp.InvalidTransformParameter", t.Transform); }
public void Silent() { var t = new ResolveComReference.TlbImp(); Assert.False(t.Silent); // "Silent should be false by default" CommandLine.ValidateNoParameterStartsWith(t, @"/silent", false /* no response file */); t.Silent = true; Assert.True(t.Silent); // "Silent should be true" CommandLine.ValidateHasParameter(t, @"/silent", false /* no response file */); }
public void SafeArrayAsSystemArray() { var t = new ResolveComReference.TlbImp(); Assert.False(t.SafeArrayAsSystemArray); // "SafeArrayAsSystemArray should be false by default" CommandLine.ValidateNoParameterStartsWith(t, @"/sysarray", false /* no response file */); t.SafeArrayAsSystemArray = true; Assert.True(t.SafeArrayAsSystemArray); // "SafeArrayAsSystemArray should be true" CommandLine.ValidateHasParameter(t, @"/sysarray", false /* no response file */); }
public void PreventClassMembers() { var t = new ResolveComReference.TlbImp(); Assert.False(t.PreventClassMembers); // "PreventClassMembers should be false by default" CommandLine.ValidateNoParameterStartsWith(t, @"/noclassmembers", false /* no response file */); t.PreventClassMembers = true; Assert.True(t.PreventClassMembers); // "PreventClassMembers should be true" CommandLine.ValidateHasParameter(t, @"/noclassmembers", false /* no response file */); }
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string typeLibName = this.ReferenceInfo.typeLibName; string wrapperPath = base.GetWrapperPath(); StrongNameKeyPair keyPair = null; byte[] publicKey = null; StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey); if (base.DelaySign) { keyPair = null; if (publicKey == null) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]); throw new StrongNameException(); } } else { publicKey = null; if (keyPair == null) { if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer }); throw new StrongNameException(); } if ((base.KeyFile != null) && (base.KeyFile.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile }); throw new StrongNameException(); } } } bool flag = true; if (!base.ExecuteAsTool) { TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; try { TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray; if (this.noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } string str4 = this.targetProcessorArchitecture; if (str4 != null) { if (!(str4 == "MSIL")) { if (str4 == "AMD64") { goto Label_0323; } if (str4 == "IA64") { goto Label_032F; } if (str4 == "x86") { goto Label_033B; } } else { flags |= TypeLibImporterFlags.ImportAsAgnostic; } } goto Label_0345; Label_0323: flags |= TypeLibImporterFlags.ImportAsX64; goto Label_0345; Label_032F: flags |= TypeLibImporterFlags.ImportAsItanium; goto Label_0345; Label_033B: flags |= TypeLibImporterFlags.ImportAsX86; Label_0345: assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null); } catch (COMException exception) { base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message }); throw new ComReferenceResolutionException(exception); } if (!this.HasTemporaryWrapper) { this.WriteWrapperToDisk(assemblyBuilder, wrapperPath); } wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; return flag; } ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp { BuildEngine = base.BuildEngine, EnvironmentVariables = base.EnvironmentVariables, DelaySign = base.DelaySign, KeyContainer = base.KeyContainer, KeyFile = base.KeyFile, OutputAssembly = wrapperPath, ToolPath = base.ToolPath, TypeLibName = this.ReferenceInfo.typeLibPath, AssemblyNamespace = typeLibName, AssemblyVersion = null, PreventClassMembers = this.noClassMembers, SafeArrayAsSystemArray = true, Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals }; if (this.referenceFiles != null) { string fullPathToOutput = Path.GetFullPath(wrapperPath); imp.ReferenceFiles = (from rf in this.referenceFiles where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0 select rf).ToArray<string>(); } string targetProcessorArchitecture = this.targetProcessorArchitecture; if (targetProcessorArchitecture != null) { if (!(targetProcessorArchitecture == "MSIL")) { if (targetProcessorArchitecture == "AMD64") { imp.Machine = "X64"; } else if (targetProcessorArchitecture == "IA64") { imp.Machine = "Itanium"; } else if (targetProcessorArchitecture == "x86") { imp.Machine = "X86"; } else { imp.Machine = this.targetProcessorArchitecture; } } else { imp.Machine = "Agnostic"; } } flag = imp.Execute(); wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; return flag; }
public void Verbose() { var t = new ResolveComReference.TlbImp(); Assert.False(t.Verbose); // "Verbose should be false by default" CommandLine.ValidateNoParameterStartsWith(t, @"/verbose", false /* no response file */); t.Verbose = true; Assert.True(t.Verbose); // "Verbose should be true" CommandLine.ValidateHasParameter(t, @"/verbose", false /* no response file */); }
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string typeLibName = this.ReferenceInfo.typeLibName; string wrapperPath = base.GetWrapperPath(); StrongNameKeyPair keyPair = null; byte[] publicKey = null; StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey); if (base.DelaySign) { keyPair = null; if (publicKey == null) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]); throw new StrongNameException(); } } else { publicKey = null; if (keyPair == null) { if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer }); throw new StrongNameException(); } if ((base.KeyFile != null) && (base.KeyFile.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile }); throw new StrongNameException(); } } } bool flag = true; if (!base.ExecuteAsTool) { TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; try { TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray; if (this.noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } string str4 = this.targetProcessorArchitecture; if (str4 != null) { if (!(str4 == "MSIL")) { if (str4 == "AMD64") { goto Label_0323; } if (str4 == "IA64") { goto Label_032F; } if (str4 == "x86") { goto Label_033B; } } else { flags |= TypeLibImporterFlags.ImportAsAgnostic; } } goto Label_0345; Label_0323: flags |= TypeLibImporterFlags.ImportAsX64; goto Label_0345; Label_032F: flags |= TypeLibImporterFlags.ImportAsItanium; goto Label_0345; Label_033B: flags |= TypeLibImporterFlags.ImportAsX86; Label_0345: assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null); } catch (COMException exception) { base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message }); throw new ComReferenceResolutionException(exception); } if (!this.HasTemporaryWrapper) { this.WriteWrapperToDisk(assemblyBuilder, wrapperPath); } wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; return(flag); } ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp { BuildEngine = base.BuildEngine, EnvironmentVariables = base.EnvironmentVariables, DelaySign = base.DelaySign, KeyContainer = base.KeyContainer, KeyFile = base.KeyFile, OutputAssembly = wrapperPath, ToolPath = base.ToolPath, TypeLibName = this.ReferenceInfo.typeLibPath, AssemblyNamespace = typeLibName, AssemblyVersion = null, PreventClassMembers = this.noClassMembers, SafeArrayAsSystemArray = true, Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals }; if (this.referenceFiles != null) { string fullPathToOutput = Path.GetFullPath(wrapperPath); imp.ReferenceFiles = (from rf in this.referenceFiles where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0 select rf).ToArray <string>(); } string targetProcessorArchitecture = this.targetProcessorArchitecture; if (targetProcessorArchitecture != null) { if (!(targetProcessorArchitecture == "MSIL")) { if (targetProcessorArchitecture == "AMD64") { imp.Machine = "X64"; } else if (targetProcessorArchitecture == "IA64") { imp.Machine = "Itanium"; } else if (targetProcessorArchitecture == "x86") { imp.Machine = "X86"; } else { imp.Machine = this.targetProcessorArchitecture; } } else { imp.Machine = "Agnostic"; } } flag = imp.Execute(); wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; return(flag); }
public void TaskFailsWhenImproperlySigned() { var t = new ResolveComReference.TlbImp(); t.TypeLibName = "Blah.tlb"; string tempKeyContainer = null; string tempKeyFile = null; try { tempKeyContainer = FileUtilities.GetTemporaryFile(); tempKeyFile = FileUtilities.GetTemporaryFile(); t.ToolPath = Path.GetTempPath(); // DelaySign is passed without a KeyFile or a KeyContainer t.DelaySign = true; Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.CannotSpecifyDelaySignWithoutEitherKeyFileOrKeyContainer"); // KeyContainer and KeyFile are both passed in t.KeyContainer = tempKeyContainer; t.KeyFile = tempKeyFile; Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.CannotSpecifyBothKeyFileAndKeyContainer"); // All the inputs are correct, but the KeyContainer passed in is bad t.DelaySign = false; t.KeyContainer = tempKeyContainer; t.KeyFile = null; Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.StrongNameUtils.NoKeyPairInContainer", t.KeyContainer); // All the inputs are correct, but the KeyFile passed in is bad t.KeyContainer = null; t.KeyFile = tempKeyFile; Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.StrongNameUtils.NoKeyPairInFile", t.KeyFile); } finally { if (tempKeyContainer != null) { File.Delete(tempKeyContainer); } if (tempKeyFile != null) { File.Delete(tempKeyContainer); } } }
public void SdkToolsPath() { var t = new ResolveComReference.TlbImp(); t.TypeLibName = "FakeLibrary.tlb"; string badParameterValue = @"C:\Program Files\Microsoft Visual Studio 10.0\My Fake SDK Path"; string goodParameterValue = Path.GetTempPath(); bool taskPassed; Assert.Null(t.SdkToolsPath); // "SdkToolsPath should be null by default" Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.SdkOrToolPathNotSpecifiedOrInvalid", t.SdkToolsPath, t.ToolPath); t.SdkToolsPath = badParameterValue; Assert.Equal(badParameterValue, t.SdkToolsPath); // "New SdkToolsPath value should be set" Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "AxTlbBaseTask.SdkOrToolPathNotSpecifiedOrInvalid", t.SdkToolsPath, t.ToolPath); MockEngine e = new MockEngine(); t.BuildEngine = e; t.SdkToolsPath = goodParameterValue; Assert.Equal(goodParameterValue, t.SdkToolsPath); // "New SdkToolsPath value should be set" taskPassed = t.Execute(); Assert.False(taskPassed); // "Task should still fail -- there are other things wrong with it." // but that particular error shouldn't be there anymore. string sdkToolsPathMessage = t.Log.FormatResourceString("AxTlbBaseTask.SdkOrToolPathNotSpecifiedOrInvalid", t.SdkToolsPath, t.ToolPath); string messageWithNoCode; string sdkToolsPathCode = t.Log.ExtractMessageCode(sdkToolsPathMessage, out messageWithNoCode); e.AssertLogDoesntContain(sdkToolsPathCode); }
public void KeyFileWithSpaces() { AxTlbBaseTask t = new ResolveComReference.TlbImp(); string testParameterValue = @"C:\Program Files\myKeyFile.key"; Assert.Null(t.KeyFile); // "KeyFile should be null by default" CommandLine.ValidateNoParameterStartsWith(t, @"/keyfile:", false /* no response file */); t.KeyFile = testParameterValue; Assert.Equal(testParameterValue, t.KeyFile); // "New KeyFile value should be set" CommandLine.ValidateHasParameter(t, @"/keyfile:" + testParameterValue, false /* no response file */); }
public void TaskFailsWithNoInputs() { var t = new ResolveComReference.TlbImp(); Utilities.ExecuteTaskAndVerifyLogContainsErrorFromResource(t, "TlbImp.NoInputFileSpecified"); }
/* * Method: GenerateWrapper * * Generates a wrapper for this reference. */ internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string rootNamespace = ReferenceInfo.typeLibName; string wrapperPath = GetWrapperPath(); bool generateWrapperSucceeded = true; if (ExecuteAsTool) { // delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST // HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK var tlbImp = new ResolveComReference.TlbImp(); tlbImp.BuildEngine = BuildEngine; tlbImp.EnvironmentVariables = EnvironmentVariables; tlbImp.DelaySign = DelaySign; tlbImp.KeyContainer = KeyContainer; tlbImp.KeyFile = KeyFile; tlbImp.OutputAssembly = wrapperPath; tlbImp.ToolPath = ToolPath; tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath; tlbImp.AssemblyNamespace = rootNamespace; tlbImp.AssemblyVersion = null; tlbImp.PreventClassMembers = _noClassMembers; tlbImp.SafeArrayAsSystemArray = true; tlbImp.Silent = Silent; tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals; if (_referenceFiles != null) { // Issue is that there may be reference dependencies that need to be passed in. It is possible // that the set of references will also contain the file that is meant to be written here (when reference resolution // found the file in the output folder). We need to filter out this case. var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file. tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray(); } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: tlbImp.Machine = "Agnostic"; break; case UtilitiesProcessorArchitecture.AMD64: tlbImp.Machine = "X64"; break; case UtilitiesProcessorArchitecture.IA64: tlbImp.Machine = "Itanium"; break; case UtilitiesProcessorArchitecture.X86: tlbImp.Machine = "X86"; break; case UtilitiesProcessorArchitecture.ARM: tlbImp.Machine = "ARM"; break; case null: break; default: // Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message. tlbImp.Machine = _targetProcessorArchitecture; break; } generateWrapperSucceeded = tlbImp.Execute(); // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; // Changed to ReflectionOnlyLoadFrom, related to bug: // RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform // The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we // have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code. // // Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not // where we are right now. // // If we really do need to load it then: // // wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath); } else { // use framework classes in-proc to generate the assembly TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; StrongNameKeyPair keyPair; byte[] publicKey; GetAndValidateStrongNameKey(out keyPair, out publicKey); try { TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals; if (_noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: flags |= TypeLibImporterFlags.ImportAsAgnostic; break; case UtilitiesProcessorArchitecture.AMD64: flags |= TypeLibImporterFlags.ImportAsX64; break; case UtilitiesProcessorArchitecture.IA64: flags |= TypeLibImporterFlags.ImportAsItanium; break; case UtilitiesProcessorArchitecture.X86: flags |= TypeLibImporterFlags.ImportAsX86; break; case UtilitiesProcessorArchitecture.ARM: flags |= TypeLibImporterFlags.ImportAsArm; break; default: // Let the type importer decide. break; } // Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs. assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, rootNamespace, null); } catch (COMException ex) { if (!Silent) { Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message); } throw new ComReferenceResolutionException(ex); } // if we're done, and this is not a temporary wrapper, write it out to disk if (!HasTemporaryWrapper) { WriteWrapperToDisk(assemblyBuilder, wrapperPath); } // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; } // ...and we're done! return(generateWrapperSucceeded); }
public void NoLogo() { var t = new ResolveComReference.TlbImp(); Assert.False(t.NoLogo); // "NoLogo should be false by default" CommandLine.ValidateNoParameterStartsWith(t, @"/nologo", false /* no response file */); t.NoLogo = true; Assert.True(t.NoLogo); // "NoLogo should be true" CommandLine.ValidateHasParameter(t, @"/nologo", false /* no response file */); }
public void OutputAssemblyWithSpaces() { var t = new ResolveComReference.TlbImp(); string testParameterValue = @"c:\Program Files\AxInterop.Foo.dll"; Assert.Null(t.OutputAssembly); // "OutputAssembly should be null by default" CommandLine.ValidateNoParameterStartsWith(t, @"/out:", false /* no response file */); t.OutputAssembly = testParameterValue; Assert.Equal(testParameterValue, t.OutputAssembly); // "New OutputAssembly value should be set" CommandLine.ValidateHasParameter(t, @"/out:" + testParameterValue, false /* no response file */); }
public void AssemblyVersion() { var t = new ResolveComReference.TlbImp(); Version testParameterValue = new Version(2, 12); Assert.Null(t.AssemblyVersion); // "AssemblyVersion should be null by default" CommandLine.ValidateNoParameterStartsWith(t, @"/asmversion:", false /* no response file */); t.AssemblyVersion = testParameterValue; Assert.Equal(testParameterValue, t.AssemblyVersion); // "New AssemblyNamespace value should be set" CommandLine.ValidateHasParameter(t, @"/asmversion:" + testParameterValue.ToString(), false /* no response file */); }
public void OutputAssembly() { var t = new ResolveComReference.TlbImp(); string testParameterValue = "AxInterop.Foo.dll"; Assert.IsNull(t.OutputAssembly, "OutputAssembly should be null by default"); CommandLine.ValidateNoParameterStartsWith(t, @"/out:", false /* no response file */); t.OutputAssembly = testParameterValue; Assert.AreEqual(testParameterValue, t.OutputAssembly, "New OutputAssembly value should be set"); CommandLine.ValidateHasParameter(t, @"/out:" + testParameterValue, false /* no response file */); }