public void BasicProxying() { BuildItemGroup ig = new BuildItemGroup(); BuildItem i1 = new BuildItem("name1", "value1"); i1.SetMetadata("myMetaName", "myMetaValue"); BuildItem i2 = new BuildItem("name2", "value2"); ig.AddItem(i1); ig.AddItem(i2); BuildItemGroupProxy proxy = new BuildItemGroupProxy(ig); // Gather everything into our own table Hashtable list = new Hashtable(StringComparer.OrdinalIgnoreCase); foreach (DictionaryEntry item in proxy) { list.Add(item.Key, item.Value); } // Check we got all the items Assertion.AssertEquals(2, list.Count); Assertion.AssertEquals("value1", ((TaskItem)list["name1"]).ItemSpec); Assertion.AssertEquals("value2", ((TaskItem)list["name2"]).ItemSpec); // Check they have all their metadata int builtInMetadata = FileUtilities.ItemSpecModifiers.All.Length; Assertion.AssertEquals(1 + builtInMetadata, ((TaskItem)list["name1"]).MetadataCount); Assertion.AssertEquals(0 + builtInMetadata, ((TaskItem)list["name2"]).MetadataCount); Assertion.AssertEquals("myMetaValue", ((TaskItem)list["name1"]).GetMetadata("myMetaName")); }
public static BuildItemGroup ToBuildItemGroup(object o, Type t, string name) { BuildItemGroup big = new BuildItemGroup(); if (t == typeof(ITaskItem)) { big.AddItem(name, (ITaskItem)o); } else if (t == typeof(ITaskItem [])) { foreach (ITaskItem i in (ITaskItem [])o) { big.AddItem(name, i); } } else if (t.IsArray) { return(ToBuildItemGroup(name, ToString((object [])o, t), true)); } else { return(ToBuildItemGroup(name, ToString(o), false)); } return(big); }
public void ExpandAllIntoTaskItems3() { BuildPropertyGroup pg = new BuildPropertyGroup(); BuildItemGroup ig = new BuildItemGroup(); ig.AddItem(new BuildItem("Compile", "foo.cs")); ig.AddItem(new BuildItem("Compile", "bar.cs")); BuildItemGroup ig2 = new BuildItemGroup(); ig2.AddItem(new BuildItem("Resource", "bing.resx")); Hashtable itemsByType = new Hashtable(StringComparer.OrdinalIgnoreCase); itemsByType["Compile"] = ig; itemsByType["Resource"] = ig2; Expander expander = new Expander(pg, itemsByType); List<TaskItem> itemsOut = expander.ExpandAllIntoTaskItems("foo;bar;@(compile);@(resource)", null); ObjectModelHelpers.AssertItemsMatch(@" foo bar foo.cs bar.cs bing.resx ", itemsOut.ToArray()); }
/// <summary> /// Removes all Items of a given typoe from the collection. /// Recurses into Chooses in the collection removing Items as well. /// </summary> /// <remarks> /// </remarks> /// <owner>DavidLe</owner> /// <param name="itemName"></param> internal void RemoveItemsByName(string itemName) { BuildItemGroup itemsToRemove = new BuildItemGroup(); foreach (BuildItemGroup itemGroup in this.ItemGroupsAll) { // Now loop through the Items in the BuildItemGroup, and keep track of the // ones that are of the requested item type. foreach (BuildItem item in itemGroup) { if ((String.Equals(item.Name, itemName, StringComparison.OrdinalIgnoreCase)) && !item.IsImported ) { // We're not allowed to remove an item from a collection while // the collection is being enumerated. So we have to track it // in a separate list. itemsToRemove.AddItem(item); } } } foreach (BuildItem itemToRemove in itemsToRemove) { itemToRemove.ParentPersistedItemGroup.ParentProject.RemoveItem(itemToRemove); } }
// FIXME: cleanup + test void PublishItemGroup(PropertyInfo propertyInfo, object o, string itemName) { BuildItemGroup newItems = ChangeType.ToBuildItemGroup(o, propertyInfo.PropertyType, itemName); newItems.ParentProject = parentProject; if (parentProject.EvaluatedItemsByName.ContainsKey(itemName)) { BuildItemGroup big = parentProject.EvaluatedItemsByName [itemName]; foreach (BuildItem item in newItems) { big.AddItem(item); } } else { parentProject.EvaluatedItemsByName.Add(itemName, newItems); } foreach (BuildItem bi in newItems) { parentProject.EvaluatedItems.AddItem(bi); } }
/// <summary> /// Verify item is not in the table /// </summary> private void MustNotBeInTable(Hashtable table, BuildItem item) { BuildItemGroup group = new BuildItemGroup(); group.AddItem(item); MustNotBeInTable(table, item.Name, group); }
static BuildItemGroup ToBuildItemGroup(string name, string items, bool split) { BuildItemGroup big = new BuildItemGroup(); if (split) { string [] splitItems = items.Split(';'); foreach (string item in splitItems) { big.AddItem(name, new TaskItem(item)); } } else { big.AddItem(name, new TaskItem(items)); } return(big); }
// FIXME: cleanup + test void PublishItemGroup(PropertyInfo propertyInfo, object o, string itemName) { if (o == null) { return; } BuildItemGroup newItems; try { newItems = ChangeType.ToBuildItemGroup(o, propertyInfo.PropertyType, itemName); } catch (Exception e) { throw new Exception(String.Format("Error publishing Output from task property '{0} {1}' to item named '{2}' : {3}", propertyInfo.PropertyType, propertyInfo.Name, itemName, e.Message), e); } newItems.ParentProject = parentProject; if (parentProject.EvaluatedItemsByName.ContainsKey(itemName)) { BuildItemGroup big = parentProject.EvaluatedItemsByName [itemName]; foreach (BuildItem item in newItems) { big.AddItem(item); } } else { parentProject.EvaluatedItemsByName.Add(itemName, newItems); } foreach (BuildItem bi in newItems) { parentProject.EvaluatedItems.AddItem(bi); } }
public void CantModifyThroughEnumerator() { BuildItemGroup ig = new BuildItemGroup(); BuildItem i1 = new BuildItem("name1", "value1"); i1.SetMetadata("myMetaName", "myMetaValue"); ig.AddItem(i1); BuildItemGroupProxy proxy = new BuildItemGroupProxy(ig); Hashtable list = new Hashtable(StringComparer.OrdinalIgnoreCase); foreach (DictionaryEntry item in proxy) { list.Add(item.Key, item.Value); } // Change the item Assertion.AssertEquals("value1", ((TaskItem)list["name1"]).ItemSpec); ((TaskItem)list["name1"]).ItemSpec = "newItemSpec"; ((TaskItem)list["name1"]).SetMetadata("newMetadata", "newMetadataValue"); // We did change our copy Assertion.AssertEquals("newItemSpec", ((TaskItem)list["name1"]).ItemSpec); Assertion.AssertEquals("newMetadataValue", ((TaskItem)list["name1"]).GetMetadata("newMetadata")); Assertion.AssertEquals("myMetaValue", ((TaskItem)list["name1"]).GetMetadata("myMetaName")); // But get the item again list = new Hashtable(StringComparer.OrdinalIgnoreCase); foreach (DictionaryEntry item in proxy) { list.Add(item.Key, item.Value); } // Item value and metadata hasn't changed Assertion.AssertEquals("value1", ((TaskItem)list["name1"]).ItemSpec); Assertion.AssertEquals("", ((TaskItem)list["name1"]).GetMetadata("newMetadata")); Assertion.AssertEquals("myMetaValue", ((TaskItem)list["name1"]).GetMetadata("myMetaName")); }
/// <summary> /// Removes all Items of a given typoe from the collection. /// Recurses into Chooses in the collection removing Items as well. /// </summary> /// <remarks> /// </remarks> /// <owner>DavidLe</owner> /// <param name="itemName"></param> internal void RemoveItemsByName(string itemName) { BuildItemGroup itemsToRemove = new BuildItemGroup(); foreach (BuildItemGroup itemGroup in this.ItemGroupsAll) { // Now loop through the Items in the BuildItemGroup, and keep track of the // ones that are of the requested item type. foreach (BuildItem item in itemGroup) { if ((0 == String.Compare(item.Name, itemName, StringComparison.OrdinalIgnoreCase)) && !item.IsImported ) { // We're not allowed to remove an item from a collection while // the collection is being enumerated. So we have to track it // in a separate list. itemsToRemove.AddItem(item); } } } foreach (BuildItem itemToRemove in itemsToRemove) { itemToRemove.ParentPersistedItemGroup.ParentProject.RemoveItem(itemToRemove); } }
private static Lookup GenerateLookup(BuildPropertyGroup properties) { BuildItemGroup items = new BuildItemGroup(); BuildItem item1 = new BuildItem("i0", "a1"); BuildItem item2 = new BuildItem("i0", "a2"); BuildItem item3 = new BuildItem("i0", "a3"); BuildItem item4 = new BuildItem("i0", "a4"); item1.SetMetadata("m", "m1"); item1.SetMetadata("n", "n1"); item2.SetMetadata("m", "m2"); item2.SetMetadata("n", "n2"); item3.SetMetadata("m", "m2"); item3.SetMetadata("n", "n2"); item4.SetMetadata("m", "m3"); item4.SetMetadata("n", "n3"); items.AddItem(item1); items.AddItem(item2); items.AddItem(item3); items.AddItem(item4); Hashtable itemsByName = new Hashtable(StringComparer.OrdinalIgnoreCase); itemsByName.Add("i0", items); Lookup lookup = LookupHelpers.CreateLookup(properties, itemsByName); return lookup; }
public void ConditionedPropertyUpdateTests() { Parser p = new Parser(); BuildPropertyGroup propertyBag = new BuildPropertyGroup(); Hashtable conditionedProperties = new Hashtable(StringComparer.OrdinalIgnoreCase); BuildItemGroup myNewItemGroup = new BuildItemGroup(); myNewItemGroup.AddItem(new BuildItem("Compile", "foo.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "bar.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "baz.cs")); Hashtable itemBag = new Hashtable(StringComparer.OrdinalIgnoreCase); itemBag["Compile"] = myNewItemGroup; Expander expander = new Expander(LookupHelpers.CreateLookup(itemBag).ReadOnlyLookup); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, conditionedProperties, string.Empty); StringCollection sc; AssertParseEvaluate(p, "'0' == '1'", state, false); Assertion.Assert(conditionedProperties.Count == 0); AssertParseEvaluate(p, "$(foo) == foo", state, false); Assertion.Assert(conditionedProperties.Count == 1); sc = (StringCollection)conditionedProperties["foo"]; Assertion.Assert(sc.Count == 1); AssertParseEvaluate(p, "'$(foo)' != 'bar'", state, true); Assertion.Assert(conditionedProperties.Count == 1); sc = (StringCollection)conditionedProperties["foo"]; Assertion.Assert(sc.Count == 2); AssertParseEvaluate(p, "'$(branch)|$(build)|$(platform)' == 'lab22dev|debug|x86'", state, false); Assertion.Assert(conditionedProperties.Count == 4); sc = (StringCollection)conditionedProperties["foo"]; Assertion.Assert(sc.Count == 2); sc = (StringCollection)conditionedProperties["branch"]; Assertion.Assert(sc.Count == 1); sc = (StringCollection)conditionedProperties["build"]; Assertion.Assert(sc.Count == 1); sc = (StringCollection)conditionedProperties["platform"]; Assertion.Assert(sc.Count == 1); AssertParseEvaluate(p, "'$(branch)|$(build)|$(platform)' == 'lab21|debug|x86'", state, false); Assertion.Assert(conditionedProperties.Count == 4); sc = (StringCollection)conditionedProperties["foo"]; Assertion.Assert(sc.Count == 2); sc = (StringCollection)conditionedProperties["branch"]; Assertion.Assert(sc.Count == 2); sc = (StringCollection)conditionedProperties["build"]; Assertion.Assert(sc.Count == 1); sc = (StringCollection)conditionedProperties["platform"]; Assertion.Assert(sc.Count == 1); AssertParseEvaluate(p, "'$(branch)|$(build)|$(platform)' == 'lab23|retail|ia64'", state, false); Assertion.Assert(conditionedProperties.Count == 4); sc = (StringCollection)conditionedProperties["foo"]; Assertion.Assert(sc.Count == 2); sc = (StringCollection)conditionedProperties["branch"]; Assertion.Assert(sc.Count == 3); sc = (StringCollection)conditionedProperties["build"]; Assertion.Assert(sc.Count == 2); sc = (StringCollection)conditionedProperties["platform"]; Assertion.Assert(sc.Count == 2); DumpHashtable(conditionedProperties); }
public void PropertyFunctionConsumingItemMetadata() { MockLogger logger = new MockLogger(); Project project = ObjectModelHelpers.CreateInMemoryProject(@" <Project ToolsVersion=`3.5` xmlns=`msbuildnamespace`> </Project> ", logger); BuildPropertyGroup pg = new BuildPropertyGroup(); pg.SetProperty("SomePath", @"c:\some\path"); BuildItemGroup ig = new BuildItemGroup(); BuildItem item = new BuildItem("Compile", "fOo.Cs"); item.SetMetadata("SomeMeta", "fOo.Cs"); ig.AddItem(item); Hashtable itemsByType = new Hashtable(StringComparer.OrdinalIgnoreCase); itemsByType["Compile"] = ig; Expander expander = new Expander(pg, itemsByType, ExpanderOptions.ExpandAll); expander.SetMetadataInMetadataTable("Compile", "SomeMeta", "fOo.Cs"); string result = expander.ExpandAllIntoStringLeaveEscaped(@"$([System.IO.Path]::Combine($(SomePath),%(Compile.SomeMeta)))", null); Assertion.AssertEquals(@"c:\some\path\fOo.Cs", result); }
public void AddItemEmptyPersistedGroup() { XmlDocument doc = new XmlDocument(); XmlElement ig = doc.CreateElement("ItemGroup", XMakeAttributes.defaultXmlNamespace); BuildItemGroup group = new BuildItemGroup(ig, false, new Project()); BuildItem item = CreatePersistedBuildItem(ig, "i", "i3"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 0); }
static BuildItemGroup ToBuildItemGroup (string name, string items, bool split) { BuildItemGroup big = new BuildItemGroup (); if (split) { string [] splitItems = items.Split (';'); foreach (string item in splitItems) big.AddItem (name, new TaskItem (item)); } else { big.AddItem (name, new TaskItem (items)); } return big; }
public void StringExpansionTests() { Parser p = new Parser(); BuildPropertyGroup propertyBag = new BuildPropertyGroup(); Hashtable conditionedProperties = null; BuildItemGroup myNewItemGroup = new BuildItemGroup(); myNewItemGroup.AddItem(new BuildItem("Compile", "foo.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "bar.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "baz.cs")); Hashtable itemBag = new Hashtable(StringComparer.OrdinalIgnoreCase); itemBag["COMPILE"] = myNewItemGroup; propertyBag = new BuildPropertyGroup(); propertyBag.SetProperty("foo", "true"); propertyBag.SetProperty("bar", "yes"); propertyBag.SetProperty("one", "1"); propertyBag.SetProperty("onepointzero", "1.0"); propertyBag.SetProperty("two", "2"); propertyBag.SetProperty("simple", "simplestring"); propertyBag.SetProperty("complex", "This is a complex string"); propertyBag.SetProperty("c1", "Another (complex) one."); propertyBag.SetProperty("c2", "Another (complex) one."); propertyBag.SetProperty("TestQuote", "Contains'Quote'"); propertyBag.SetProperty("AnotherTestQuote", "Here's Johnny!"); propertyBag.SetProperty("Atsign", "Test the @ replacement"); Expander expander = new Expander(propertyBag, itemBag); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, conditionedProperties, string.Empty); AssertParseEvaluate(p, "'simplestring: true foo.cs;bar.cs;baz.cs' == '$(simple): $(foo) @(compile)'", state, true); AssertParseEvaluate(p, "'$(c1) $(c2)' == 'Another (complex) one. Another (complex) one.'", state, true); AssertParseEvaluate(p, "'CONTAINS%27QUOTE%27' == '$(TestQuote)'", state, true); AssertParseEvaluate(p, "'Here%27s Johnny!' == '$(AnotherTestQuote)'", state, true); AssertParseEvaluate(p, "'Test the %40 replacement' == $(Atsign)", state, true);}
public void ShallowCloneOfVirtualItemGroup() { BuildItemGroup group = new BuildItemGroup(); group.AddNewItem("i", "i1"); BuildItem i2 = new BuildItem("i", "i2"); group.AddItem(i2); BuildItemGroup group2 = group.Clone(false /*shallow*/); Assertion.AssertEquals(2, group2.Count); Assertion.AssertEquals("i1", group2[0].FinalItemSpec); Assertion.Assert(i2.Equals(group2[1])); }
public void ModifyItemTwiceInSameScope2() { Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); Lookup lookup = LookupHelpers.CreateLookup(table1); // Add an item with m=m1 and n=n1 and o=o1 BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); item1.SetMetadata("n", "n1"); item1.SetMetadata("o", "o1"); lookup.PopulateWithItem(item1); lookup.EnterScope(); // It's still m=m1, n=n1, o=o1 BuildItemGroup group = lookup.GetItems("i1"); Assertion.AssertEquals(1, group.Count); Assertion.AssertEquals("m1", group[0].GetMetadata("m")); Assertion.AssertEquals("n1", group[0].GetMetadata("n")); Assertion.AssertEquals("o1", group[0].GetMetadata("o")); // Make a modification to the item to be m=m2 and n=n2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); newMetadata.Add("n", "n2"); group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems("i1", group, newMetadata); // It's now m=m2, n=n2, o=o1 BuildItemGroup foundGroup = lookup.GetItems("i1"); Assertion.AssertEquals(1, foundGroup.Count); Assertion.AssertEquals("m2", foundGroup[0].GetMetadata("m")); Assertion.AssertEquals("n2", foundGroup[0].GetMetadata("n")); Assertion.AssertEquals("o1", foundGroup[0].GetMetadata("o")); // Make a modification to the item to be n=n3 newMetadata = new Dictionary<string, string>(); newMetadata.Add("n", "n3"); lookup.ModifyItems("i1", group, newMetadata); // It's now m=m2, n=n3, o=o1 foundGroup = lookup.GetItems("i1"); Assertion.AssertEquals(1, foundGroup.Count); Assertion.AssertEquals("m2", foundGroup[0].GetMetadata("m")); Assertion.AssertEquals("n3", foundGroup[0].GetMetadata("n")); Assertion.AssertEquals("o1", foundGroup[0].GetMetadata("o")); // But the original item hasn't changed yet Assertion.AssertEquals("m1", item1.GetMetadata("m")); Assertion.AssertEquals("n1", item1.GetMetadata("n")); Assertion.AssertEquals("o1", item1.GetMetadata("o")); lookup.LeaveScope(); // It's still m=m2, n=n3, o=o1 foundGroup = lookup.GetItems("i1"); Assertion.AssertEquals(1, foundGroup.Count); Assertion.AssertEquals("m2", foundGroup[0].GetMetadata("m")); Assertion.AssertEquals("n3", foundGroup[0].GetMetadata("n")); Assertion.AssertEquals("o1", foundGroup[0].GetMetadata("o")); // And the original item has changed Assertion.AssertEquals("m2", item1.GetMetadata("m")); Assertion.AssertEquals("n3", item1.GetMetadata("n")); Assertion.AssertEquals("o1", item1.GetMetadata("o")); }
public void ModifyItemTwiceInSameScope1() { Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); Lookup lookup = LookupHelpers.CreateLookup(table1); // Add an item with m=m1 and n=n1 BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); lookup.PopulateWithItem(item1); lookup.EnterScope(); // Make a modification to the item to be m=m2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems(item1.Name, group, newMetadata); // Make an unrelated modification to the item newMetadata = new Dictionary<string, string>(); newMetadata.Add("n", "n1"); lookup.ModifyItems(item1.Name, group, newMetadata); // It's now m=m2 group = lookup.GetItems("i1"); Assertion.AssertEquals(1, group.Count); Assertion.AssertEquals("m2", group[0].GetMetadata("m")); }
public void RemoveBeforeModifyShouldBeInvalid() { Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); Lookup lookup = LookupHelpers.CreateLookup(table1); // Start a target lookup.EnterScope(); // Start a task (eg) lookup.EnterScope(); BuildItem item1 = new BuildItem("i1", "a2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); // Remove an item then modify it lookup.RemoveItem(item1); Dictionary<string, string> metadataChanges = new Dictionary<string, string>(); metadataChanges.Add("x", "y"); lookup.ModifyItems("i1", group, metadataChanges); }
public void Removes() { // One item in the project BuildItemGroup group1 = new BuildItemGroup(); BuildItem item1 = new BuildItem("i1", "a1"); group1.AddItem(item1); Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); table1.Add("i1", group1); Lookup lookup = LookupHelpers.CreateLookup(table1); // Start a target lookup.EnterScope(); // Start a task (eg) and add a new item lookup.EnterScope(); BuildItem item2 = new BuildItem("i1", "a2"); lookup.AddNewItem(item2); // Remove one item lookup.RemoveItem(item1); // We see one item Assertion.AssertEquals(1, lookup.GetItems("i1").Count); Assertion.AssertEquals("a2", lookup.GetItems("i1")[0].FinalItemSpec); // Remove the other item lookup.RemoveItem(item2); // We see no items Assertion.AssertEquals(0, lookup.GetItems("i1").Count); // Finish the task lookup.LeaveScope(); // We still see no items Assertion.AssertEquals(0, lookup.GetItems("i1").Count); // But there's still one item in the project Assertion.AssertEquals("a1", group1[0].FinalItemSpec); Assertion.AssertEquals(1, group1.Count); // Finish the target lookup.LeaveScope(); // We still see no items Assertion.AssertEquals(0, lookup.GetItems("i1").Count); // And now there are no items in the project either Assertion.AssertEquals(0, group1.Count); }
public void AddItemEmptyNonPersistedGroup() { BuildItemGroup group = new BuildItemGroup(); BuildItem item = new BuildItem("i", "i1"); group.AddItem(item); Assertion.AssertEquals(item, group[0]); // should be last item = new BuildItem("i", "i0"); group.AddItem(item); Assertion.AssertEquals(item, group[1]); // should be last again }
public void OldSyntaxTests() { Parser p = new Parser(); BuildPropertyGroup propertyBag = new BuildPropertyGroup(); Hashtable conditionedProperties = null; BuildItemGroup myNewItemGroup = new BuildItemGroup(); myNewItemGroup.AddItem(new BuildItem("Compile", "foo.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "bar.cs")); myNewItemGroup.AddItem(new BuildItem("Compile", "baz.cs")); Hashtable itemBag = new Hashtable(StringComparer.OrdinalIgnoreCase); itemBag["COMPILE"] = myNewItemGroup; propertyBag = new BuildPropertyGroup(); propertyBag.SetProperty("foo", "true"); propertyBag.SetProperty("bar", "yes"); propertyBag.SetProperty("one", "1"); propertyBag.SetProperty("onepointzero", "1.0"); propertyBag.SetProperty("two", "2"); propertyBag.SetProperty("simple", "simplestring"); propertyBag.SetProperty("complex", "This is a complex string"); propertyBag.SetProperty("c1", "Another (complex) one."); propertyBag.SetProperty("c2", "Another (complex) one."); Expander expander = new Expander(propertyBag, itemBag); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, conditionedProperties, string.Empty); AssertParseEvaluate(p, "(($(foo) != 'two' and $(bar)) and 5 >= 1) or $(one) == 1", state, true);}
public static BuildItemGroup ToBuildItemGroup (object o, Type t, string name) { BuildItemGroup big = new BuildItemGroup (); if (t == typeof (ITaskItem)) { big.AddItem (name, (ITaskItem) o); } else if (t == typeof (ITaskItem [])) { foreach (ITaskItem i in (ITaskItem []) o) big.AddItem (name, i); } else if (t.IsArray) { return ToBuildItemGroup (name, ToString ((object []) o, t), true); } else { return ToBuildItemGroup (name, ToString (o), false); } return big; }
/// <summary> /// A whole bunch of conditionals, that should be true, false, or error /// (many coincidentally like existing QA tests) to give breadth coverage. /// Please add more cases as they arise. /// </summary> /// <owner>danmose</owner> private void EvaluateAVarietyOfExpressions() { string[] files = { "a", "a;b", "a'b", ";", "'" }; try { foreach (string file in files) { using (StreamWriter sw = File.CreateText(file)) { ; } } Parser p = new Parser(); GenericExpressionNode tree; BuildItemGroup itemGroupU = new BuildItemGroup(); BuildItemGroup itemGroupV = new BuildItemGroup(); BuildItemGroup itemGroupW = new BuildItemGroup(); BuildItemGroup itemGroupX = new BuildItemGroup(); BuildItemGroup itemGroupY = new BuildItemGroup(); BuildItemGroup itemGroupZ = new BuildItemGroup(); itemGroupU.AddItem(new BuildItem("u", "a'b;c")); itemGroupV.AddItem(new BuildItem("w", "a")); itemGroupW.AddItem(new BuildItem("w", "1")); itemGroupX.AddItem(new BuildItem("x", "true")); itemGroupY.AddItem(new BuildItem("y", "xxx")); itemGroupZ.AddItem(new BuildItem("z", "xxx")); itemGroupZ.AddItem(new BuildItem("z", "yyy")); Hashtable itemBag = new Hashtable(StringComparer.OrdinalIgnoreCase); itemBag["u"] = itemGroupU; itemBag["v"] = itemGroupV; itemBag["w"] = itemGroupW; itemBag["x"] = itemGroupX; itemBag["y"] = itemGroupY; itemBag["z"] = itemGroupZ; BuildPropertyGroup propertyBag = new BuildPropertyGroup(); propertyBag.SetProperty("a", "no"); propertyBag.SetProperty("b", "true"); propertyBag.SetProperty("c", "1"); propertyBag.SetProperty("d", "xxx"); propertyBag.SetProperty("e", "xxx"); propertyBag.SetProperty("and", "and"); propertyBag.SetProperty("a_semi_b", "a;b"); propertyBag.SetProperty("a_apos_b", "a'b"); propertyBag.SetProperty("foo_apos_foo", "foo'foo"); propertyBag.SetProperty("a_escapedsemi_b", "a%3bb"); propertyBag.SetProperty("a_escapedapos_b", "a%27b"); propertyBag.SetProperty("has_trailing_slash", @"foo\"); Dictionary<string, string> itemMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); itemMetadata["Culture"] = "french"; Expander expander = new Expander(new ReadOnlyLookup(itemBag, propertyBag), itemMetadata); string[] trueTests = { "true or (SHOULDNOTEVALTHIS)", // short circuit "(true and false) or true", "false or true or false", "(true) and (true)", "false or !false", "($(a) or true)", "('$(c)'==1 and (!false))", "@(z -> '%(filename).z', '$')=='xxx.z$yyy.z'", "false or (false or (false or (false or (false or (true)))))", "!(true and false)", "$(and)=='and'", "0x1==1.0", "0xa==10", "0<0.1", "+4>-4", "'-$(c)'==-1", "$(a)==faLse", "$(a)==oFF", "$(a)==no", "$(a)!=true", "$(b)== True", "$(b)==on", "$(b)==yes", "$(b)!=1", "$(c)==1", "$(d)=='xxx'", "$(d)==$(e)", "$(d)=='$(e)'", "@(y)==$(d)", "'@(z)'=='xxx;yyy'", "$(a)==$(a)", "'1'=='1'", "'1'==1", "1\n==1", "1\t==\t\r\n1", "123=='0123.0'", "123==123", "123==0123", "123==0123.0", "123!=0123.01", "00==0", "0==0.0", "1\n\t==1", "+4==4", "44==+44.0 and -44==-44.0", "false==no", "true==yes", "true==!false", "yes!=no", "false!=1", "$(c)>0", "!$(a)", "$(b)", "($(d)==$(e))", "!true==false", "a_a==a_a", "a_a=='a_a'", "_a== _a", "@(y -> '%(filename)')=='xxx'", "@(z -> '%(filename)', '!')=='xxx!yyy'", "'xxx!yyy'==@(z -> '%(filename)', '!')", "'$(a)'==(false)", "('$(a)'==(false))", "1>0", "2<=2", "2<=3", "1>=1", "1>=-1", "-1==-1", "-1 < 0", "(1==1)and('a'=='a')", "(true) and ($(a)==off)", "(true) and ($(d)==xxx)", "(false) or($(d)==xxx)", "!(false)and!(false)", "'and'=='AND'", "$(d)=='XxX'", "true or true or false", "false or true or !true or'1'", "$(a) or $(b)", "$(a) or true", "!!true", "'$(e)1@(y)'=='xxx1xxx'", "0x11==17", "0x01a==26", "0xa==0x0A", "@(x)", "'%77'=='w'", "'%zz'=='%zz'", "true or 1", "true==!false", "(!(true))=='off'", "@(w)>0", "1<=@(w)", "%(culture)=='FRENCH'", "'%(culture) fries' == 'FRENCH FRIES' ", @"'%(HintPath)' == ''", @"%(HintPath) != 'c:\myassemblies\foo.dll'", "exists('a')", "exists(a)", "exists('a%3bb')", /* semicolon */ "exists('a%27b')", /* apostrophe */ "exists($(a_escapedsemi_b))", "exists('$(a_escapedsemi_b)')", "exists($(a_escapedapos_b))", "exists('$(a_escapedapos_b)')", "exists($(a_apos_b))", "exists('$(a_apos_b)')", "exists(@(v))", "exists('@(v)')", "exists('%3b')", "exists('%27')", "exists('@(v);@(nonexistent)')", @"HASTRAILINGSLASH('foo\')", @"!HasTrailingSlash('foo')", @"HasTrailingSlash('foo/')", @"HasTrailingSlash($(has_trailing_slash))", "'59264.59264' == '59264.59264'", "1" + new String('0', 500) + "==" + "1" + new String('0', 500), /* too big for double, eval as string */ "'1" + new String('0', 500) + "'=='" + "1" + new String('0', 500) + "'" /* too big for double, eval as string */ }; string[] falseTests = { "false and SHOULDNOTEVALTHIS", // short circuit "$(a)!=no", "$(b)==1.1", "$(c)==$(a)", "$(d)!=$(e)", "!$(b)", "false or false or false", "false and !((true and false))", "on and off", "(true) and (false)", "false or (false or (false or (false or (false or (false)))))", "!$(b)and true", "1==a", "!($(d)==$(e))", "$(a) and true", "true==1", "false==0", "(!(true))=='x'", "oops==false", "oops==!false", "%(culture) == 'english'", "'%(culture) fries' == 'english fries' ", @"'%(HintPath)' == 'c:\myassemblies\foo.dll'", @"%(HintPath) == 'c:\myassemblies\foo.dll'", "exists('')", "exists(' ')", "exists($(nonexistent))", // DDB #141195 "exists('$(nonexistent)')", // DDB #141195 "exists(@(nonexistent))", // DDB #141195 "exists('@(nonexistent)')", // DDB #141195 "exists('\t')", "exists('@(u)')", "exists('$(foo_apos_foo)')", "!exists('a')", "!!!exists(a)", @"hastrailingslash('foo')", @"hastrailingslash('')", @"HasTrailingSlash($(nonexistent))", "'59264.59264' == '59264.59265'", "1" + new String('0', 500) + "==2", /* too big for double, eval as string */ "'1" + new String('0', 500) + "'=='2'", /* too big for double, eval as string */ "'1" + new String('0', 500) + "'=='01" + new String('0', 500) + "'" /* too big for double, eval as string */ }; string[] errorTests = { "$", "$(", "$()", "@", "@(", "@()", "%", "%(", "%()", "exists", "exists(", "exists()", "exists( )", "exists(,)", "@(x->'", "@(x->''", "@(x-", "@(x->'x','", "@(x->'x',''", "@(x->'x','')", "-1>x", "%00", "\n", "\t", "+-1==1", "1==-+1", "1==+0xa", "!$(c)", "'a'==('a'=='a')", "'a'!=('a'=='a')", "('a'=='a')!=a", "('a'=='a')==a", "!'x'", "!'$(d)'", "ab#==ab#", "#!=#", "$(d)$(e)=='xxxxxx'", "1=1=1", "'a'=='a'=='a'", "1 > 'x'", "x1<=1", "1<=x", "1>x", "x<x", "@(x)<x", "x>x", "x>=x", "x<=x", "x>1", "x>=1", "1>=x", "@(y)<=1", "1<=@(z)", "1>$(d)", "$(c)@(y)>1", "'$(c)@(y)'>1", "$(d)>=1", "1>=$(b)", "1> =0", "or true", "1 and", "and", "or", "not", "not true", "()", "(a)", "!", "or=or", "1==", "1= =1", "=", "'true", "'false''", "'a'=='a", "('a'=='a'", "('a'=='a'))", "'a'=='a')", "!and", "@(a)@(x)!=1", "@(a) @(x)!=1", "$(a==off", "=='x'", "==", "!0", ">", "true!=false==", "true!=false==true", "()", "!1", "1==(2", "$(a)==x>1==2", "'a'>'a'", "0", "$(a)>0", "!$(e)", "1<=1<=1", "true $(and) true", "--1==1", "$(and)==and", "!@#$%^&*", "-($(c))==-1", "a==b or $(d)", "false or $()", "$(d) or true", "%(Culture) or true", "@(nonexistent) and true", "$(nonexistent) and true", "@(nonexistent)", "$(nonexistent)", "@(z) and true", "@() and true", "@()", "$()", "1", "1 or true", "false or 1", "1 and true", "true and 1", "!1", "false or !1", "false or 'aa'", "true blah", "existsX", "!", "nonexistentfunction('xyz')", "exists('a;b')", /* non scalar */ "exists(@(z))", "exists('@(z)')", "exists($(a_semi_b))", "exists('$(a_semi_b)')", "exists(@(v)x)", "exists(@(v)$(nonexistent))", "exists('@(v)$(a)')", "HasTrailingSlash(a,'b')", "HasTrailingSlash(,,)" }; for (int i = 0; i < trueTests.GetLength(0); i++) { tree = p.Parse(trueTests[i], DummyAttribute, ParserOptions.AllowAll); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, null, trueTests[i]); Assertion.Assert("expected true from '" + trueTests[i] + "'", tree.Evaluate(state)); } for (int i = 0; i < falseTests.GetLength(0); i++) { tree = p.Parse(falseTests[i], DummyAttribute, ParserOptions.AllowAll); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, null, falseTests[i]); Assertion.Assert("expected false from '" + falseTests[i] + "' and got true", !tree.Evaluate(state)); } for (int i = 0; i < errorTests.GetLength(0); i++) { // It seems that if an expression is invalid, // - Parse may throw, or // - Evaluate may throw, or // - Evaluate may return false causing its caller EvaluateCondition to throw bool success = true; bool caughtException = false; bool value; try { tree = p.Parse(errorTests[i], DummyAttribute, ParserOptions.AllowAll); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, null, errorTests[i]); value = tree.Evaluate(state); if (!success) Console.WriteLine(errorTests[i] + " caused Evaluate to return false"); } catch (InvalidProjectFileException ex) { Console.WriteLine(errorTests[i] + " caused '" + ex.Message + "'"); caughtException = true; } Assertion.Assert("expected '" + errorTests[i] + "' to not parse or not be evaluated", (success == false || caughtException == true)); } } finally { foreach (string file in files) { if (File.Exists(file)) File.Delete(file); } } }
public void RemoveItemFromProjectPreviouslyModifiedAndGottenThroughGetItem() { // Create some project state with an item with m=m1 and n=n1 Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); BuildItemGroup group0 = new BuildItemGroup(); group0.AddExistingItem(item1); table1["i1"] = group0; Lookup lookup = LookupHelpers.CreateLookup(table1); lookup.EnterScope(); // Make a modification to the item to be m=m2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems(item1.Name, group, newMetadata); // Get the item (under the covers, it cloned it in order to apply the modification) BuildItemGroup group2 = lookup.GetItems(item1.Name); Assertion.AssertEquals(1, group2.Count); BuildItem item1b = group2[0]; // Remove the item lookup.RemoveItem(item1b); // There's now no items at all BuildItemGroup group3 = lookup.GetItems(item1.Name); Assertion.AssertEquals(0, group3.Count); // Leave scope lookup.LeaveScope(); // And now none left in the project either Assertion.AssertEquals(0, ((BuildItemGroup)table1["i1"]).Count); }
public void AddItem1() { XmlElement ig = CreatePersistedItemGroupElement(); BuildItemGroup group = new BuildItemGroup(ig, false, new Project()); BuildItem item = CreatePersistedBuildItem(ig, "i", "i3"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 2); // should be last item = CreatePersistedBuildItem(ig, "h", "h1"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 3); // should be last, because there were no h's. item = CreatePersistedBuildItem(ig, "h", "h0"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 3);// should be 2nd last item = CreatePersistedBuildItem(ig, "i", "i2"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 1); // should be 2nd item = CreatePersistedBuildItem(ig, "i", "i0"); group.AddItem(item); VerifyPersistedItemPosition(group, item, 0); // should be first }
public void ModifyItemThatWasAddedInSameScope() { Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); Lookup lookup = LookupHelpers.CreateLookup(table1); lookup.EnterScope(); // Add an item with m=m1 BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); lookup.AddNewItem(item1); // Change the item to be m=m2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems(item1.Name, group, newMetadata); // Now it has m=m2 group = lookup.GetItems("i1"); Assertion.AssertEquals(1, group.Count); Assertion.AssertEquals("m2", group[0].GetMetadata("m")); // But the original item hasn't changed yet Assertion.AssertEquals("m1", item1.GetMetadata("m")); lookup.LeaveScope(); // It still has m=m2 group = lookup.GetItems("i1"); Assertion.AssertEquals(1, group.Count); Assertion.AssertEquals("m2", group[0].GetMetadata("m")); // But now the original item has changed as well Assertion.AssertEquals("m2", item1.GetMetadata("m")); }
public void ItemListTests() { Parser p = new Parser(); Hashtable conditionedProperties = null; BuildItemGroup myCompileItemGroup = new BuildItemGroup(); myCompileItemGroup.AddItem(new BuildItem("Compile", "foo.cs")); myCompileItemGroup.AddItem(new BuildItem("Compile", "bar.cs")); myCompileItemGroup.AddItem(new BuildItem("Compile", "baz.cs")); BuildItemGroup myBooleanItemGroup = new BuildItemGroup(); myBooleanItemGroup.AddItem(new BuildItem("Boolean", "true")); Hashtable itemsByType = new Hashtable(StringComparer.OrdinalIgnoreCase); itemsByType["Compile"] = myCompileItemGroup; itemsByType["Boolean"] = myBooleanItemGroup; Expander expander = new Expander(LookupHelpers.CreateLookup(itemsByType).ReadOnlyLookup); ConditionEvaluationState state = new ConditionEvaluationState(DummyAttribute, expander, conditionedProperties, string.Empty); AssertParseEvaluate(p, "@(Compile) == 'foo.cs;bar.cs;baz.cs'", state, true); AssertParseEvaluate(p, "@(Compile,' ') == 'foo.cs bar.cs baz.cs'", state, true); AssertParseEvaluate(p, "@(Compile,'') == 'foo.csbar.csbaz.cs'", state, true); AssertParseEvaluate(p, "@(Compile->'%(Filename)') == 'foo;bar;baz'", state, true); AssertParseEvaluate(p, "@(Compile -> 'temp\\%(Filename).xml', ' ') == 'temp\\foo.xml temp\\bar.xml temp\\baz.xml'", state, true); AssertParseEvaluate(p, "@(Compile->'', '') == ''", state, true); AssertParseEvaluate(p, "@(Compile->'') == ';;'", state, true); AssertParseEvaluate(p, "@(Compile->'%(Nonexistent)', '') == ''", state, true); AssertParseEvaluate(p, "@(Compile->'%(Nonexistent)') == ';;'", state, true); AssertParseEvaluate(p, "@(Boolean)", state, true); AssertParseEvaluate(p, "@(Boolean) == true", state, true); AssertParseEvaluate(p, "'@(Empty, ';')' == ''", state, true);}
public void ModifyItemInProjectPreviouslyModifiedAndGottenThroughGetItem() { // Create some project state with an item with m=m1 and n=n1 Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); BuildItemGroup group0 = new BuildItemGroup(); group0.AddExistingItem(item1); table1["i1"] = group0; Lookup lookup = LookupHelpers.CreateLookup(table1); lookup.EnterScope(); // Make a modification to the item to be m=m2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems(item1.Name, group, newMetadata); // Get the item (under the covers, it cloned it in order to apply the modification) BuildItemGroup group2 = lookup.GetItems(item1.Name); Assertion.AssertEquals(1, group2.Count); BuildItem item1b = group2[0]; // Modify to m=m3 Dictionary<string, string> newMetadata2 = new Dictionary<string, string>(); newMetadata2.Add("m", "m3"); BuildItemGroup group3 = new BuildItemGroup(); group3.AddItem(item1b); lookup.ModifyItems(item1b.Name, group3, newMetadata2); // Modifications are visible BuildItemGroup group4 = lookup.GetItems(item1b.Name); Assertion.AssertEquals(1, group4.Count); Assertion.AssertEquals("m3", group4[0].GetMetadata("m")); // Leave scope lookup.LeaveScope(); // Still visible BuildItemGroup group5 = lookup.GetItems(item1b.Name); Assertion.AssertEquals(1, group5.Count); Assertion.AssertEquals("m3", group5[0].GetMetadata("m")); // And the one in the project is changed Assertion.AssertEquals("m3", item1.GetMetadata("m")); }
public void RemoveItemPreviouslyModifiedAndGottenThroughGetItem() { Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase); Lookup lookup = LookupHelpers.CreateLookup(table1); // Add an item with m=m1 and n=n1 BuildItem item1 = new BuildItem("i1", "a2"); item1.SetMetadata("m", "m1"); lookup.PopulateWithItem(item1); lookup.EnterScope(); // Make a modification to the item to be m=m2 Dictionary<string, string> newMetadata = new Dictionary<string, string>(); newMetadata.Add("m", "m2"); BuildItemGroup group = new BuildItemGroup(); group.AddItem(item1); lookup.ModifyItems(item1.Name, group, newMetadata); // Get the item (under the covers, it cloned it in order to apply the modification) BuildItemGroup group2 = lookup.GetItems(item1.Name); Assertion.AssertEquals(1, group2.Count); BuildItem item1b = group2[0]; // Remove the item lookup.RemoveItem(item1b); // There's now no items at all BuildItemGroup group3 = lookup.GetItems(item1.Name); Assertion.AssertEquals(0, group3.Count); }
/// <summary> /// Determines if the target needs to be built/rebuilt/skipped if its inputs and outputs can be correlated. /// </summary> /// <owner>SumedhK</owner> /// <param name="itemVectorsInTargetInputs"></param> /// <param name="itemVectorsInTargetOutputs"></param> /// <param name="itemVectorsReferencedInBothTargetInputsAndOutputs"></param> /// <param name="changedTargetInputs"></param> /// <param name="upToDateTargetInputs"></param> /// <returns>Indication of how to build the target.</returns> private DependencyAnalysisResult PerformDependencyAnalysisIfCorrelatedInputsOutputs ( Hashtable itemVectorsInTargetInputs, Hashtable itemVectorsInTargetOutputs, ArrayList itemVectorsReferencedInBothTargetInputsAndOutputs, out Hashtable changedTargetInputs, out Hashtable upToDateTargetInputs ) { DependencyAnalysisResult result = DependencyAnalysisResult.SkipUpToDate; changedTargetInputs = new Hashtable(StringComparer.OrdinalIgnoreCase); upToDateTargetInputs = new Hashtable(StringComparer.OrdinalIgnoreCase); // indicates if an incremental build is really just a full build, because all input items have changed int numberOfInputItemVectorsWithAllChangedItems = 0; foreach (string itemVectorType in itemVectorsReferencedInBothTargetInputsAndOutputs) { Hashtable inputItemVectors = (Hashtable)itemVectorsInTargetInputs[itemVectorType]; Hashtable outputItemVectors = (Hashtable)itemVectorsInTargetOutputs[itemVectorType]; // NOTE: recall that transforms have been separated out already ErrorUtilities.VerifyThrow(inputItemVectors.Count == 1, "There should only be one item vector of a particular type in the target inputs that can be filtered."); // NOTE: this loop only makes one iteration foreach (BuildItemGroup inputItems in inputItemVectors.Values) { if (inputItems.Count > 0) { BuildItemGroup changedInputItems = new BuildItemGroup(); BuildItemGroup upToDateInputItems = new BuildItemGroup(); BuildItem[] inputItemsAssumedToBeUpToDate = inputItems.ToArray(); foreach (DictionaryEntry outputEntry in outputItemVectors) { BuildItemGroup outputItems = (BuildItemGroup)outputEntry.Value; // Get the metadata name so if it is missing we can print out a nice error message. string outputItemExpression = (string)outputEntry.Key; ErrorUtilities.VerifyThrow(inputItems.Count == outputItems.Count, "An item vector of a particular type must always contain the same number of items."); for (int i = 0; i < inputItemsAssumedToBeUpToDate.Length; i++) { // if we haven't already determined that this input item has changed if (inputItemsAssumedToBeUpToDate[i] != null) { // Check to see if the outputItem specification is null or empty, if that is the case we need to error out saying that some metadata // on one of the items used in the target output is missing. bool outputEscapedValueIsNullOrEmpty = String.IsNullOrEmpty(outputItems[i].FinalItemSpecEscaped); ProjectErrorUtilities.VerifyThrowInvalidProject(!outputEscapedValueIsNullOrEmpty, this.TargetToAnalyze.TargetElement, "TargetOutputsSpecifiedAreMissing", inputItemsAssumedToBeUpToDate[i].FinalItemSpecEscaped, outputItems[i].Name, outputItemExpression, TargetToAnalyze.Name); // check if it has changed bool outOfDate = IsOutOfDate(inputItemsAssumedToBeUpToDate[i].FinalItemSpecEscaped, outputItems[i].FinalItemSpecEscaped, inputItemsAssumedToBeUpToDate[i].Name, outputItems[i].Name); if (outOfDate) { changedInputItems.AddItem(inputItemsAssumedToBeUpToDate[i]); inputItemsAssumedToBeUpToDate[i] = null; result = DependencyAnalysisResult.IncrementalBuild; } } } if (changedInputItems.Count == inputItems.Count) { numberOfInputItemVectorsWithAllChangedItems++; break; } } if (changedInputItems.Count < inputItems.Count) { foreach (BuildItem item in inputItemsAssumedToBeUpToDate) { if (item != null) { upToDateInputItems.AddItem(item); } } } changedTargetInputs[itemVectorType] = changedInputItems; upToDateTargetInputs[itemVectorType] = upToDateInputItems; } } } ErrorUtilities.VerifyThrow(numberOfInputItemVectorsWithAllChangedItems <= itemVectorsReferencedInBothTargetInputsAndOutputs.Count, "The number of vectors containing all changed items cannot exceed the number of correlated vectors."); // if all correlated input items have changed if (numberOfInputItemVectorsWithAllChangedItems == itemVectorsReferencedInBothTargetInputsAndOutputs.Count) { ErrorUtilities.VerifyThrow(result == DependencyAnalysisResult.IncrementalBuild, "If inputs have changed, this must be an incremental build."); // then the incremental build is really a full build result = DependencyAnalysisResult.FullBuild; } return result; }