internal void Add (UsingTask usingTask) { if (usingTask == null) throw new ArgumentNullException ("usingTask"); if (usingTasks.Contains (usingTask)) throw new InvalidOperationException ("Task already registered."); usingTasks.Add (usingTask); }
internal void Add(UsingTask usingTask) { if (usingTask == null) { throw new ArgumentNullException("usingTask"); } if (usingTasks.Contains(usingTask)) { throw new InvalidOperationException("Task already registered."); } usingTasks.Add(usingTask); }
public void TestICollectionMethods() { Project project = ObjectModelHelpers.CreateInMemoryProject(string.Format(@" <Project xmlns=`msbuildnamespace`> <UsingTask TaskName=`Microsoft.Build.UnitTests.Project_Tests.WashCar` AssemblyFile=`{0}` Condition=` true == true `/> <UsingTask TaskName=`Microsoft.Build.UnitTests.Project_Tests.Message` AssemblyName=`{1}` Condition=` false == true `/> <Target Name=`Build`> <WashCar/> </Target> </Project> ", new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath, Assembly.GetExecutingAssembly().FullName)); UsingTaskCollection usingTasks = project.UsingTasks; Assertion.AssertEquals(2, usingTasks.Count); UsingTask[] array = new UsingTask[2]; usingTasks.CopyTo(array, 0); Assertion.AssertEquals(usingTasks[0], array[0]); Assertion.AssertEquals(usingTasks[1], array[1]); object[] arrayObjects = new object[2]; usingTasks.CopyTo(arrayObjects, 0); Assertion.AssertEquals(usingTasks[0], arrayObjects[0]); Assertion.AssertEquals(usingTasks[1], arrayObjects[1]); Assertion.AssertEquals("Microsoft.Build.UnitTests.Project_Tests.WashCar", usingTasks[0].TaskName); Assertion.AssertEquals("Microsoft.Build.UnitTests.Project_Tests.Message", usingTasks[1].TaskName); Assert.IsFalse(usingTasks.IsSynchronized, "Expected IsSynchronized to be false"); Assert.IsNotNull(usingTasks.SyncRoot, "Expected SynchRoot to not be null"); }
public void TestUsingTaskOrder1 () { Engine engine = new Engine (Consts.BinPath); Project proj = engine.CreateNewProject (); string documentString = @" <Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003""> <PropertyGroup> <Property>Test\resources\TestTasks.dll</Property> </PropertyGroup> <UsingTask AssemblyFile='$(Property)' TaskName='TrueTestTask' /> </Project> "; proj.LoadXml (documentString); UsingTask [] ut = new UsingTask [1]; proj.UsingTasks.CopyTo (ut, 0); Assert.AreEqual ("$(Property)", ut [0].AssemblyFile, "A1"); }
public void TestCopyTo7 () { string documentString = @" <Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003""> <UsingTask AssemblyFile='Test/resources/TestTasks.dll' TaskName='TrueTestTask' /> </Project> "; engine = new Engine (Consts.BinPath); project = engine.CreateNewProject (); project.LoadXml (documentString); UsingTask [] array = new UsingTask [1]; project.UsingTasks.CopyTo ((Array) array, 0); }
public void RegisterUsingTask(UsingTask ut) { usingTasksByFullName [ut.TaskName] = new UsingTaskInfo(GetShortName(ut.TaskName), ut); }
public UsingTaskInfo(string shortname, UsingTask task) { ShortName = shortname; Task = task; }
/// <summary> /// Adds a new UsingTask to this collection. Does not alter the parent project's XML. /// </summary> /// <param name="usingTask"></param> /// <owner>LukaszG</owner> internal void Add(UsingTask usingTask) { ErrorUtilities.VerifyThrow(this.usingTasks != null, "UsingTaskCollection's ArrayList not initialized!"); this.usingTasks.Add(usingTask); }
public void CopyTo_ZeroIndex() { Project p = new Project(new Engine()); p.AddNewUsingTaskFromAssemblyFile("TaskName1", "AssemblyFile1.dll"); p.AddNewUsingTaskFromAssemblyFile("TaskName2", "AssemblyFile2.dll"); UsingTask[] usingTasks = new UsingTask[p.UsingTasks.Count]; p.UsingTasks.CopyTo(usingTasks, 0); int i = 0; foreach (UsingTask usingTask in p.UsingTasks) { Assertion.AssertEquals(usingTasks[i].AssemblyFile, usingTask.AssemblyFile); i++; } }
public void RegisterUsingTask (UsingTask ut) { usingTasksByFullName [ut.TaskName] = new UsingTaskInfo (GetShortName (ut.TaskName), ut); }
public UsingTaskInfo (string shortname, UsingTask task) { ShortName = shortname; Task = task; }
/// <summary> /// Process each of the direct children beneath the >Project< element. /// These include things like <PropertyGroup>, <ItemGroup>, <Target>, etc. /// This method is simply capturing the data in the form of our own /// internal objects. It is not actually evaluating any of the properties /// or other data. /// </summary> /// <param name="projectElement"></param> /// <param name="projectDirectoryLocation"></param> /// <param name="importedProject"></param> /// <owner>RGoel</owner> private void ProcessProjectChildren ( XmlElement projectElement, string projectDirectoryLocation, bool importedProject ) { // Make sure the <Project> node has been given to us. error.VerifyThrow(projectElement != null, "Need an XML node representing the <project> element."); // Make sure this really is the <Project> node. ProjectXmlUtilities.VerifyThrowElementName(projectElement, XMakeElements.project); // Loop through all the direct children of the <project> element. // This verifies all the XML is legitimate, and creates ordered lists of objects // representing the top-level nodes (itemgroup, choose, etc.) // As this progresses, the Chooses and PropertyGroups are evaluated, so that conditions // on Imports involving properties can be evaluated too, because we need to know whether to // follow the imports. // All this comprises "Pass 1". List<XmlElement> childElements = ProjectXmlUtilities.GetValidChildElements(projectElement); string currentPerThreadProjectDirectory = Project.PerThreadProjectDirectory; try { // Make the correct project directory available. This is needed because it is // used for evaluating "exists" in conditional expressions, for example on <Import> elements. Project.PerThreadProjectDirectory = ProjectDirectory; foreach (XmlElement childElement in childElements) { switch (childElement.Name) { // Process the <ItemDefinitionGroup> element. case XMakeElements.itemDefinitionGroup: itemDefinitionLibrary.Add(childElement); break; // Process the <ItemGroup> element. case XMakeElements.itemGroup: BuildItemGroup newItemGroup = new BuildItemGroup(childElement, importedProject, /*parent project*/ this); this.rawItemGroups.InsertAtEnd(newItemGroup); break; // Process the <PropertyGroup> element. case XMakeElements.propertyGroup: BuildPropertyGroup newPropertyGroup = new BuildPropertyGroup(this, childElement, importedProject); newPropertyGroup.EnsureNoReservedProperties(); this.rawPropertyGroups.InsertAtEnd(newPropertyGroup); // PropertyGroups/Chooses are evaluated immediately during this scan, as they're needed to figure out whether // we include Imports. newPropertyGroup.Evaluate(this.evaluatedProperties, this.conditionedPropertiesTable, ProcessingPass.Pass1); break; // Process the <Choose> element. case XMakeElements.choose: Choose newChoose = new Choose(this, this.rawGroups, childElement, importedProject, 0 /* not nested in another <Choose> */); this.rawGroups.InsertAtEnd(newChoose); // PropertyGroups/Chooses are evaluated immediately during this scan, as they're needed to figure out whether // we include Imports. newChoose.Evaluate(this.evaluatedProperties, false, true, this.conditionedPropertiesTable, ProcessingPass.Pass1); break; // Process the <Target> element. case XMakeElements.target: XmlElement targetElement = childElement; Target newTarget = new Target(targetElement, this, importedProject); // If a target with this name already exists, log a low priority message. if (!ParentEngine.LoggingServices.OnlyLogCriticalEvents) { if (targets.Exists(newTarget.Name)) { ParentEngine.LoggingServices.LogComment(projectBuildEventContext, "OverridingTarget", targets[newTarget.Name].Name, targets[newTarget.Name].ProjectFileOfTargetElement, newTarget.Name, newTarget.ProjectFileOfTargetElement); } } this.targets.AddOverrideTarget(newTarget); if (this.nameOfFirstTarget == null) { this.nameOfFirstTarget = targetElement.GetAttribute(XMakeAttributes.name); } break; // Process the <UsingTask> element. case XMakeElements.usingTask: UsingTask usingTask = new UsingTask(childElement, importedProject); this.usingTasks.Add(usingTask); break; // Process the <ProjectExtensions> element. case XMakeElements.projectExtensions: if (!importedProject) { ProjectErrorUtilities.VerifyThrowInvalidProject(null == this.projectExtensionsNode, childElement, "DuplicateProjectExtensions"); this.projectExtensionsNode = childElement; // No attributes are legal on this element ProjectXmlUtilities.VerifyThrowProjectNoAttributes(childElement); } break; // Process the <Error>, <Warning>, and <Message> elements case XMakeElements.error: case XMakeElements.warning: case XMakeElements.message: ProjectErrorUtilities.VerifyThrowInvalidProject(false, childElement, "ErrorWarningMessageNotSupported", childElement.Name); break; case XMakeElements.importGroup: foreach (XmlElement importGroupChild in childElement.ChildNodes) { switch(importGroupChild.Name) { case XMakeElements.import: ProcessImportElement(importGroupChild, projectDirectoryLocation, importedProject); break; default: ProjectXmlUtilities.ThrowProjectInvalidChildElement(importGroupChild); break; } } break; // Process the <Import> element. case XMakeElements.import: ProcessImportElement(childElement, projectDirectoryLocation, importedProject); break; default: // We've encounted an unknown child element beneath <project>. ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement); break; } } } finally { // Reset back to the original value Project.PerThreadProjectDirectory = currentPerThreadProjectDirectory; } }
/// <summary> /// Copy the contents of this collection into a strongly typed array /// </summary> /// <param name="array"></param> /// <param name="index"></param> /// <owner>LukaszG</owner> public void CopyTo(UsingTask[] array, int index) { ErrorUtilities.VerifyThrow(this.usingTasks != null, "UsingTaskCollection's ArrayList not initialized!"); this.usingTasks.CopyTo(array, index); }
public void CopyTo_OffsetIndex() { int offSet = 3; Project p = new Project(new Engine()); p.AddNewUsingTaskFromAssemblyFile("TaskName1", "AssemblyFile1.dll"); p.AddNewUsingTaskFromAssemblyFile("TaskName2", "AssemblyFile2.dll"); UsingTask[] taskArray = new UsingTask[p.UsingTasks.Count + offSet]; p.UsingTasks.CopyTo(taskArray, offSet); int i = offSet - 1; Assertion.AssertNull(taskArray[offSet - 1]); foreach (UsingTask usingTask in p.UsingTasks) { Assertion.AssertEquals(taskArray[i].AssemblyFile, usingTask.AssemblyFile); i++; } }
public void CopyTo (UsingTask[] array, int index) { usingTasks.CopyTo (array, index); }
public void CopyTo_OffsetIndexArrayTooSmall() { int offSet = 3; Project p = new Project(new Engine()); p.AddNewUsingTaskFromAssemblyFile("TaskName1", "AssemblyFile1.dll"); p.AddNewUsingTaskFromAssemblyFile("TaskName2", "AssemblyFile2.dll"); UsingTask[] usingTasks = new UsingTask[p.UsingTasks.Count]; p.UsingTasks.CopyTo(usingTasks, offSet); }
/// <summary> /// Reads the given <UsingTask> tag and saves the task information specified in it. /// </summary> /// <param name="usingTask"></param> /// <param name="expander"></param> /// <param name="loggingServices"></param> /// <param name="buildEventContext"></param> public void RegisterTask(UsingTask usingTask, Expander expander, EngineLoggingServices loggingServices, BuildEventContext buildEventContext) { if ( // if the <UsingTask> tag doesn't have a condition on it (usingTask.Condition == null) || // or if the condition holds Utilities.EvaluateCondition(usingTask.Condition, usingTask.ConditionAttribute, expander, null, ParserOptions.AllowProperties | ParserOptions.AllowItemLists, loggingServices, buildEventContext) ) { // Lazily allocate the hashtables if they are needed if (registeredTasks == null) { cachedTaskClassesWithExactMatch = new Hashtable(StringComparer.OrdinalIgnoreCase); cachedTaskClassesWithFuzzyMatch = new Hashtable(StringComparer.OrdinalIgnoreCase); registeredTasks = new Hashtable(StringComparer.OrdinalIgnoreCase); } string assemblyName = null; string assemblyFile = null; if (usingTask.AssemblyName != null) { // expand out all embedded properties and items in the assembly name assemblyName = expander.ExpandAllIntoString(usingTask.AssemblyName, usingTask.AssemblyNameAttribute); ProjectErrorUtilities.VerifyThrowInvalidProject(assemblyName.Length > 0, usingTask.AssemblyNameAttribute, "InvalidEvaluatedAttributeValue", assemblyName, usingTask.AssemblyName, XMakeAttributes.assemblyName, XMakeElements.usingTask); } else { // expand out all embedded properties and items in the assembly file/path assemblyFile = expander.ExpandAllIntoString(usingTask.AssemblyFile, usingTask.AssemblyFileAttribute); ProjectErrorUtilities.VerifyThrowInvalidProject(assemblyFile.Length > 0, usingTask.AssemblyFileAttribute, "InvalidEvaluatedAttributeValue", assemblyFile, usingTask.AssemblyFile, XMakeAttributes.assemblyFile, XMakeElements.usingTask); // figure out the directory of the project in which this <UsingTask> node was defined string projectFile = XmlUtilities.GetXmlNodeFile(usingTask.TaskNameAttribute.OwnerElement, String.Empty); string projectDir = (projectFile.Length > 0) ? Path.GetDirectoryName(projectFile) : String.Empty; // ensure the assembly file/path is relative to the project in which this <UsingTask> node was defined -- we // don't want paths from imported projects being interpreted relative to the main project file try { assemblyFile = Path.Combine(projectDir, assemblyFile); } catch (ArgumentException ex) { // Invalid chars in AssemblyFile path ProjectErrorUtilities.VerifyThrowInvalidProject(false, usingTask.AssemblyFileAttribute, "InvalidAttributeValueWithException", assemblyFile, XMakeAttributes.assemblyFile, XMakeElements.usingTask, ex.Message); } } AssemblyLoadInfo taskAssembly = new AssemblyLoadInfo(assemblyName, assemblyFile); // expand out all embedded properties and items string taskName = expander.ExpandAllIntoString(usingTask.TaskName, usingTask.TaskNameAttribute); ProjectErrorUtilities.VerifyThrowInvalidProject(taskName.Length > 0, usingTask.TaskNameAttribute, "InvalidEvaluatedAttributeValue", taskName, usingTask.TaskName, XMakeAttributes.taskName, XMakeElements.usingTask); // since more than one task can have the same name, we want to keep track of all assemblies that are declared to // contain tasks with a given name... ArrayList taskAssemblies = (ArrayList)registeredTasks[taskName]; if (taskAssemblies == null) { taskAssemblies = new ArrayList(); registeredTasks[taskName] = taskAssemblies; } taskAssemblies.Add(taskAssembly); } }