/// <summary> /// Provides an enumerator over property definitions for a specified tools version /// </summary> /// <param name="toolsVersion"></param> /// <returns></returns> protected override IEnumerable <PropertyDefinition> GetPropertyDefinitions(string toolsVersion) { ToolsetElement toolsetElement = ConfigurationSection.Toolsets.GetElement(toolsVersion); if (toolsetElement == null) { yield break; } foreach (ToolsetElement.PropertyElement propertyElement in toolsetElement.PropertyElements) { string location = ResourceUtilities.FormatResourceString ( "ConfigFileLocation", propertyElement.ElementInformation.Source, propertyElement.ElementInformation.LineNumber ); if (propertyElement.Name != null && propertyElement.Name.Length == 0) { InvalidToolsetDefinitionException.Throw("InvalidToolsetValueInConfigFileValue", location); } yield return(new PropertyDefinition(propertyElement.Name, propertyElement.Value, location)); } }
/// <summary> /// Provides an enumerator over property definitions for a specified tools version /// </summary> /// <param name="toolsVersion"></param> /// <returns></returns> protected override IEnumerable <PropertyDefinition> GetPropertyDefinitions(string toolsVersion) { RegistryKeyWrapper toolsVersionWrapper = null; try { toolsVersionWrapper = msbuildRegistryWrapper.OpenSubKey("ToolsVersions\\" + toolsVersion); } catch (RegistryException ex) { InvalidToolsetDefinitionException.Throw(ex, "RegistryReadError", ex.Source, ex.Message); } foreach (string propertyName in toolsVersionWrapper.GetValueNames()) { string propertyValue = null; if (propertyName?.Length == 0) { InvalidToolsetDefinitionException.Throw("PropertyNameInRegistryHasZeroLength", toolsVersionWrapper.Name); } try { propertyValue = GetValue(toolsVersionWrapper, propertyName); } catch (RegistryException ex) { InvalidToolsetDefinitionException.Throw(ex, "RegistryReadError", ex.Source, ex.Message); } yield return(new PropertyDefinition(propertyName, propertyValue, toolsVersionWrapper.Name + "@" + propertyName)); } }
/// <summary> /// Reads a string value from the specified registry key /// </summary> /// <param name="baseKeyWrapper">wrapper around key</param> /// <param name="valueName">name of the value</param> /// <returns>string data in the value</returns> private static string GetValue(RegistryKeyWrapper wrapper, string valueName) { if (wrapper.Exists()) { object result = wrapper.GetValue(valueName); // RegistryKey.GetValue returns null if the value is not present // and String.Empty if the value is present and no data is defined. // We preserve this distinction, because a string property in the registry with // no value really has an empty string for a value (which is a valid property value) // rather than null for a value (which is an invalid property value) if (result != null) { // Must be a value of string type if (!(result is string)) { InvalidToolsetDefinitionException.Throw("NonStringDataInRegistry", wrapper.Name + "@" + valueName); } return(result.ToString()); } } return(null); }
/// <summary> /// Expands the given unexpanded property expression using the properties in the /// given BuildPropertyGroup. /// </summary> /// <param name="unexpandedProperty"></param> /// <param name="properties"></param> /// <returns></returns> private string ExpandProperty(PropertyDefinition property, Expander expander) { try { return(expander.ExpandAllIntoStringLeaveEscaped(property.Value, null)); } catch (InvalidProjectFileException ex) { InvalidToolsetDefinitionException.Throw(ex, "ErrorEvaluatingToolsetPropertyExpression", property.Value, property.Source, ex.Message); } return(string.Empty); }
/// <summary> /// Sets the given property in the given property group. /// </summary> /// <param name="property"></param> /// <param name="propertyGroup"></param> /// <param name="globalProperties"></param> private void SetProperty(PropertyDefinition property, BuildPropertyGroup propertyGroup, BuildPropertyGroup globalProperties) { try { // Global properties cannot be overwritten if (globalProperties[property.Name] == null) { propertyGroup.SetProperty(property.Name, property.Value); } } catch (ArgumentException ex) { InvalidToolsetDefinitionException.Throw(ex, "InvalidPropertyNameInToolset", property.Name, property.Source, ex.Message); } }
public void CtorArity3() { InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException("Message", "Error", new Exception("Inner")); Assertion.AssertEquals("Message", toolSetException.Message); Assertion.AssertEquals("Error", toolSetException.ErrorCode); Assertion.AssertEquals("Inner", toolSetException.InnerException.Message); }
/// <summary> /// Reads the settings for a specified tools version /// </summary> /// <param name="toolsVersion"></param> /// <param name="globalProperties"></param> /// <param name="initialProperties"></param> /// <param name="accumulateProperties"></param> /// <returns></returns> private Toolset ReadToolset(PropertyDefinition toolsVersion, BuildPropertyGroup globalProperties, BuildPropertyGroup initialProperties, bool accumulateProperties) { // Initial properties is the set of properties we're going to use to expand property expressions like $(foo) // in the values we read out of the registry or config file. We'll add to it as we pick up properties (including binpath) // from the registry or config file, so that properties there can be referenced in values below them. // After processing all the properties, we don't need initialProperties anymore. string toolsPath = null; string binPath = null; BuildPropertyGroup properties = new BuildPropertyGroup(); IEnumerable <PropertyDefinition> rawProperties = GetPropertyDefinitions(toolsVersion.Name); Expander expander = new Expander(initialProperties); foreach (PropertyDefinition property in rawProperties) { if (String.Equals(property.Name, ReservedPropertyNames.toolsPath, StringComparison.OrdinalIgnoreCase)) { toolsPath = ExpandProperty(property, expander); toolsPath = ExpandRelativePathsRelativeToExeLocation(toolsPath); if (accumulateProperties) { SetProperty ( new PropertyDefinition(ReservedPropertyNames.toolsPath, toolsPath, property.Source), initialProperties, globalProperties ); } } else if (String.Equals(property.Name, ReservedPropertyNames.binPath, StringComparison.OrdinalIgnoreCase)) { binPath = ExpandProperty(property, expander); binPath = ExpandRelativePathsRelativeToExeLocation(binPath); if (accumulateProperties) { SetProperty ( new PropertyDefinition(ReservedPropertyNames.binPath, binPath, property.Source), initialProperties, globalProperties ); } } else if (ReservedPropertyNames.IsReservedProperty(property.Name)) { // We don't allow toolsets to define reserved properties string baseMessage = ResourceUtilities.FormatResourceString("CannotModifyReservedProperty", property.Name); InvalidToolsetDefinitionException.Throw("InvalidPropertyNameInToolset", property.Name, property.Source, baseMessage); } else { // It's an arbitrary property string propertyValue = ExpandProperty(property, expander); PropertyDefinition expandedProperty = new PropertyDefinition(property.Name, propertyValue, property.Source); SetProperty(expandedProperty, properties, globalProperties); if (accumulateProperties) { SetProperty(expandedProperty, initialProperties, globalProperties); } } if (accumulateProperties) { expander = new Expander(initialProperties); } } // All tools versions must specify a value for MSBuildToolsPath (or MSBuildBinPath) if (String.IsNullOrEmpty(toolsPath) && String.IsNullOrEmpty(binPath)) { InvalidToolsetDefinitionException.Throw("MSBuildToolsPathIsNotSpecified", toolsVersion.Name, toolsVersion.Source); } // If both MSBuildBinPath and MSBuildToolsPath are present, they must be the same if (toolsPath != null && binPath != null && !toolsPath.Equals(binPath, StringComparison.OrdinalIgnoreCase)) { return(null); } Toolset toolset = null; try { toolset = new Toolset(toolsVersion.Name, toolsPath ?? binPath, properties); } catch (ArgumentException e) { InvalidToolsetDefinitionException.Throw("ErrorCreatingToolset", toolsVersion.Name, e.Message); } return(toolset); }
public void CtorMessage_Empty() { InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException(String.Empty); Assertion.AssertEquals(String.Empty, toolSetException.Message); }
public void CtorMessage_Null() { InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException(null); }
public void CtorMessage() { InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException("Message"); Assertion.AssertEquals("Message", toolSetException.Message); }
public void SerializationBinary() { MemoryStream memoryStream = null; InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException("Message", "errorCode"); try { memoryStream = new MemoryStream(); IFormatter binaryForamtter = new BinaryFormatter(); binaryForamtter.Serialize(memoryStream, toolSetException); memoryStream.Position = 0; // reset pointer into stream for read Object returnObj = binaryForamtter.Deserialize(memoryStream); Assertion.Assert(returnObj is InvalidToolsetDefinitionException); Assertion.AssertEquals("Message", ((InvalidToolsetDefinitionException)returnObj).Message); } finally { memoryStream.Close(); } }
public void SerializationXML() { InvalidToolsetDefinitionException toolSetException = new InvalidToolsetDefinitionException("Message", "errorCode"); MemoryStream memoryStream = null; try { memoryStream = new MemoryStream(); XmlSerializer xs = new XmlSerializer(typeof(InvalidToolsetDefinitionException)); XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8); xs.Serialize(xmlTextWriter, toolSetException); memoryStream = (MemoryStream)xmlTextWriter.BaseStream; } finally { memoryStream.Close(); } }