Author: msierad
Date: 2007-01-02 06:05:36 -0500 (Tue, 02 Jan 2007)
New Revision: 70340

Modified:
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemGroupTest.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemTest.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyGroupTest.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyTest.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildTaskTest.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ChangeLog
   
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ProjectTest.cs
Log:
2007-01-02  Marek Sieradzki  <[EMAIL PROTECTED]>

        * BuildItemTest.cs: Tests for items from XML.
        * BuildPropertyGroupTest.cs, BuildTaskTest.cs, BuildItemGroupTest.cs,
        BuildPropertyTest.cs, ProjectTest.cs: More tests.



Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemGroupTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemGroupTest.cs
       2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemGroupTest.cs
       2007-01-02 11:05:36 UTC (rev 70340)
@@ -104,6 +104,89 @@
                }
 
                [Test]
+               public void TestAddNewItem3 ()
+               {
+                       Engine engine;
+                       Project project;
+                       string name = "name";
+                       string include = "$(Property)";
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <PropertyGroup>
+                                               <Property>a</Property>
+                                       </PropertyGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       BuildItem bi = project.EvaluatedItems.AddNewItem (name, 
include, true);
+
+                       Assert.AreEqual (String.Empty, bi.Condition, "A1");
+                       Assert.AreEqual (String.Empty, bi.Exclude, "A2");
+                       Assert.AreEqual (include, bi.FinalItemSpec, "A3");
+                       Assert.AreEqual (Utilities.Escape (include), 
bi.Include, "A4");
+                       Assert.IsFalse (bi.IsImported, "A5");
+                       Assert.AreEqual (name, bi.Name, "A6");
+
+                       bi = project.EvaluatedItems.AddNewItem (name, include, 
false);
+
+                       Assert.AreEqual (String.Empty, bi.Condition, "A7");
+                       Assert.AreEqual (String.Empty, bi.Exclude, "A8");
+                       Assert.AreEqual (include, bi.FinalItemSpec, "A9");
+                       Assert.AreEqual (include, bi.Include, "A10");
+                       Assert.IsFalse (bi.IsImported, "A11");
+                       Assert.AreEqual (name, bi.Name, "A12");
+
+                       Assert.AreEqual (0, project.EvaluatedItems.Count, 
"A13");
+
+                       project.GlobalProperties.SetProperty ("a", "b");
+
+                       Assert.AreEqual (0, project.EvaluatedItems.Count, 
"A14");
+               }
+
+               [Test]
+               public void TestAddNewItem4 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.EvaluatedItems.AddNewItem ("I1", "Value");
+
+                       BuildItem bi = project.EvaluatedItems.AddNewItem ("I2", 
"@(I1)");
+
+                       Assert.AreEqual ("@(I1)", bi.FinalItemSpec, "A1");
+                       Assert.AreEqual ("@(I1)", bi.Include, "A2");
+                       Assert.AreEqual (0, project.EvaluatedItems.Count, "A3");
+               }
+
+               [Test]
+               public void TestAddNewItem5 ()
+               {
+                       BuildItemGroup big = new BuildItemGroup ();
+
+                       big.AddNewItem ("I1", "Value");
+
+                       BuildItem bi = big.AddNewItem ("I2", "@(I1)");
+
+                       Assert.AreEqual ("@(I1)", bi.FinalItemSpec, "A1");
+                       Assert.AreEqual ("@(I1)", bi.Include, "A2");
+                       Assert.AreEqual (2, big.Count, "A3");
+               }
+
+               [Test]
                public void TestClear ()
                {
                        BuildItemGroup big = new BuildItemGroup ();

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemTest.cs
    2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildItemTest.cs
    2007-01-02 11:05:36 UTC (rev 70340)
@@ -126,13 +126,37 @@
                [Test]
                [ExpectedException (typeof (InvalidOperationException),
                        "Cannot set a condition on an object not represented by 
an XML element in the project file.")]
-               public void TestCondition ()
+               public void TestCondition1 ()
                {
                        item = new BuildItem ("name", "1");
                        item.Condition = "true";
                }
 
                [Test]
+               public void TestCondition2 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b' />
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.EvaluatedItems [0].Condition = "something";
+                       project.ItemGroups.CopyTo (groups, 0);
+                       Assert.AreEqual (String.Empty, groups [0] 
[0].Condition, "A1");
+               }
+
+               [Test]
                public void TestCopyCustomMetadataTo1 ()
                {
                        BuildItem source, destination;
@@ -167,15 +191,43 @@
                [Test]
                [ExpectedException (typeof (InvalidOperationException),
                        "Assigning the \"Exclude\" attribute of a virtual item 
is not allowed.")]
-               public void TestExclude ()
+               public void TestExclude1 ()
                {
                        item = new BuildItem ("name", "1");
                        item.Exclude = "e";
                }
 
                [Test]
-               public void TestHasMetadata ()
+               public void TestExclude2 ()
                {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b' />
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       Assert.AreEqual (String.Empty, groups [0] [0].Exclude, 
"A1");
+
+                       groups [0] [0].Exclude = "b";
+
+                       Assert.AreEqual ("b", groups [0] [0].Exclude, "A2");
+                       Assert.AreEqual ("a;b", groups [0] [0].Include, "A3");
+               }
+
+               [Test]
+               public void TestHasMetadata1 ()
+               {
                        string itemName = "a";
                        string itemInclude = "a";
                        string metadataName = "name";
@@ -187,13 +239,71 @@
                        item.SetMetadata (metadataName, "value");
 
                        Assert.AreEqual (true, item.HasMetadata (metadataName), 
"A2");
+                       Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
+                       Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
+                       Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
+                       Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
+                       Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
+                       Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
+                       Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
+                       Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
+                       Assert.IsTrue (item.HasMetadata ("ModifiedTime"), 
"A11");
+                       Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
+                       Assert.IsTrue (item.HasMetadata ("AccessedTime"), 
"A13");
                }
 
                [Test]
-               public void TestGetMetadata ()
+               public void TestHasMetadata2 ()
                {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b'>
+                                                       <Meta>Value</Meta>
+                                               </A>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       BuildItem item = groups [0] [0];
+
+                       Assert.IsFalse (item.HasMetadata ("Other"), "A1");
+                       Assert.IsTrue (item.HasMetadata ("Meta"), "A2");
+                       Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
+                       Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
+                       Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
+                       Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
+                       Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
+                       Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
+                       Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
+                       Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
+                       Assert.IsTrue (item.HasMetadata ("ModifiedTime"), 
"A11");
+                       Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
+                       Assert.IsTrue (item.HasMetadata ("AccessedTime"), 
"A13");
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void TestHasMetadata3 ()
+               {
+                       item = new BuildItem ("name", "spec");
+                       item.HasMetadata (null);
+               }
+
+               [Test]
+               public void TestGetMetadata1 ()
+               {
                        string itemName = "a";
-                       string itemInclude = "a";
+                       string itemInclude = "a;b;c";
                        string metadataName = "name";
                        string metadataValue = "a;b;c";
 
@@ -204,11 +314,57 @@
                        item.SetMetadata (metadataName, metadataValue);
 
                        Assert.AreEqual (metadataValue, item.GetMetadata 
(metadataName), "A2");
+                       Assert.IsTrue (item.GetMetadata ("FullPath").EndsWith 
(Utilities.Escape (itemInclude)), "A3");
+                       //Assert.IsTrue (String.Empty != item.GetMetadata 
("RootDir"), "A4");
+                       Assert.AreEqual (itemInclude, item.GetMetadata 
("Filename"), "A5");
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("Extension"), "A6");
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("RelativeDir"), "A7");
+                       Assert.IsTrue (String.Empty != item.GetMetadata 
("Directory"), "A8");
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("RecursiveDir"), "A9");
+                       Assert.AreEqual (itemInclude, item.GetMetadata 
("Identity"), "A10");
+                       // FIXME: test with CreatedTime
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("ModifiedTime"), "A11");
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("ModifiedTime"), "A12");
+                       Assert.AreEqual (String.Empty, item.GetMetadata 
("AccessedTime"), "A13");
                }
 
                [Test]
-               public void TestGetEvaluatedMetadata ()
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void TestGetMetadata2 ()
                {
+                       item = new BuildItem ("name", "spec");
+                       item.GetMetadata (null);
+               }
+
+               [Test]
+               public void TestGetMetadata3 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b'>
+                                                       <Meta>Value</Meta>
+                                               </A>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       Assert.AreEqual ("Value", groups [0] [0].GetMetadata 
("Meta"), "A1");
+                       Assert.AreEqual (String.Empty, groups [0] 
[0].GetMetadata ("Other"), "A2");
+               }
+
+               [Test]
+               public void TestGetEvaluatedMetadata1 ()
+               {
                        string itemName = "a";
                        string itemInclude = "a";
                        string metadataName = "name";
@@ -224,6 +380,36 @@
                }
 
                [Test]
+               public void TestGetEvaluatedMetadata2 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <PropertyGroup>
+                                               <A>A</A>
+                                       </PropertyGroup>
+                                       <ItemGroup>
+                                               <A Include='a;b'>
+                                                       <Meta>Value</Meta>
+                                                       <Meta2>$(A)</Meta2>
+                                               </A>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       Assert.AreEqual ("Value", groups [0] 
[0].GetEvaluatedMetadata ("Meta"), "A1");
+                       Assert.AreEqual (String.Empty, groups [0] 
[0].GetEvaluatedMetadata ("Other"), "A2");
+                       Assert.AreEqual ("A", groups [0] 
[0].GetEvaluatedMetadata ("Meta2"), "A3");
+               }
+               [Test]
                public void TestRemoveMetadata1 ()
                {
                        string itemName = "a";
@@ -267,6 +453,76 @@
                }
 
                [Test]
+               public void TestRemoveMetadata5 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b'>
+                                                       <Meta>Value</Meta>
+                                                       <Meta2>$(A)</Meta2>
+                                               </A>
+                                               <B Include='a'/>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       Assert.AreEqual (3, project.EvaluatedItems.Count, "A1");
+
+                       groups [0] [0].RemoveMetadata ("Meta");
+                       Assert.IsFalse (groups [0] [0].HasMetadata ("Meta"), 
"A2");
+                       groups [0] [0].RemoveMetadata ("undefined_metadata");
+
+                       Assert.AreEqual (2, groups [0].Count, "A3");
+                       Assert.AreEqual (3, project.EvaluatedItems.Count, "A4");
+               }
+
+               [Test]
+               public void TestRemoveMetadata6 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b;c'>
+                                                       <Meta>Value</Meta>
+                                                       <Meta2>$(A)</Meta2>
+                                               </A>
+                                               <B Include='a'/>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       Assert.AreEqual (4, project.EvaluatedItems.Count, "A1");
+                       project.ItemGroups.CopyTo (groups, 0);
+                       Assert.AreEqual (2, groups [0].Count, "A2");
+
+                       BuildItem b1 = project.EvaluatedItems [0];
+
+                       b1.RemoveMetadata ("Meta");
+
+                       Assert.AreEqual (4, project.EvaluatedItems.Count, "A3");
+                       project.ItemGroups.CopyTo (groups, 0);
+                       Assert.AreEqual (4, groups [0].Count, "A4");
+               }
+
+               [Test]
                [ExpectedException (typeof (ArgumentNullException))]
                public void TestSetMetadata1 ()
                {
@@ -305,5 +561,69 @@
                        item = new BuildItem ("name", "include");
                        item.SetMetadata ("Filename", "something");
                }
+
+               [Test]
+               public void TestSetMetadata5 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b'/>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       groups [0] [0].SetMetadata ("Meta", "Value");
+                       // FIXME: add check for project.EvaluatedItems.Count
+
+                       Assert.AreEqual (1, groups [0].Count, "A1");
+                       Assert.AreEqual ("Value", groups [0] [0].GetMetadata 
("Meta"), "A2");
+                       Assert.AreEqual ("Value", project.EvaluatedItems 
[0].GetMetadata ("Meta"), "A3");
+                       Assert.AreEqual ("Value", project.EvaluatedItems 
[1].GetMetadata ("Meta"), "A4");
+               }
+
+               [Test]
+               public void TestSetMetadata6 ()
+               {
+                       Engine engine;
+                       Project project;
+                       BuildItemGroup [] groups = new BuildItemGroup [1];
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b;c'/>
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.EvaluatedItems [0].SetMetadata ("Meta", 
"Value");
+                       //NOTE: this triggers reevaluation
+                       Assert.AreEqual ("A", project.EvaluatedItems [0].Name, 
"A0");
+                       project.ItemGroups.CopyTo (groups, 0);
+
+                       Assert.AreEqual (3, groups [0].Count, "A1");
+                       Assert.AreEqual ("Value", groups [0] [0].GetMetadata 
("Meta"), "A2");
+                       Assert.AreEqual (String.Empty, groups [0] 
[1].GetMetadata ("Meta"), "A3");
+                       Assert.AreEqual (String.Empty, groups [0] 
[2].GetMetadata ("Meta"), "A4");
+                       Assert.AreEqual (3, project.EvaluatedItems.Count, "A5");
+                       Assert.AreEqual ("Value", project.EvaluatedItems 
[0].GetMetadata ("Meta"), "A6");
+                       Assert.AreEqual (String.Empty, project.EvaluatedItems 
[1].GetMetadata ("Meta"), "A7");
+                       Assert.AreEqual (String.Empty, project.EvaluatedItems 
[1].GetMetadata ("Meta"), "A8");
+               }
        }
 }

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyGroupTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyGroupTest.cs
   2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyGroupTest.cs
   2007-01-02 11:05:36 UTC (rev 70340)
@@ -324,5 +324,75 @@
 
                        bpg.SetProperty ("1", "$(A)");
                }
+
+               [Test]
+               public void TestSetProperty6 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <PropertyGroup>
+                                               <Property Condition=""'$(P)' != 
''"">a</Property>
+                                       </PropertyGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.GlobalProperties.SetProperty ("P", "V");
+
+                       Assert.IsNotNull (project.EvaluatedProperties 
["Property"], "A1");
+               }
+
+               [Test]
+               public void TestSetProperty7 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <PropertyGroup>
+                                               <Property Condition=""'$(P)' != 
''"">a</Property>
+                                               <A>A</A>
+                                       </PropertyGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       BuildProperty p1 = project.EvaluatedProperties ["A"];
+                       p1.Value = "B";
+
+                       project.GlobalProperties.SetProperty ("P", "V");
+
+                       Assert.AreEqual ("A", project.EvaluatedProperties 
["A"].Value, "A1");
+               }
+
+               [Test]
+               public void TestSetProperty8 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       project.EvaluatedProperties.SetProperty ("A", "B");
+
+                       Assert.IsNull (project.EvaluatedProperties ["A"], "A1");
+               }
        }
 }

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyTest.cs
        2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildPropertyTest.cs
        2007-01-02 11:05:36 UTC (rev 70340)
@@ -225,6 +225,7 @@
                }
 
                [Test]
+               [Category ("NotWorking")]
                public void TestCondition1 ()
                {
                        string documentString = @"

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildTaskTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildTaskTest.cs
    2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/BuildTaskTest.cs
    2007-01-02 11:05:36 UTC (rev 70340)
@@ -398,7 +398,39 @@
                        BuildTask [] bt;
                        project.Targets.CopyTo (t, 0);
                        bt = GetTasks (t [0]);
+                       bt [0].AddOutputProperty ("Property", "PropertyName");
+                       project.Build ("T");
 
+                       Assert.AreEqual ("some_text", 
project.EvaluatedProperties ["PropertyName"].Value, "A1");
+                       Assert.AreEqual ("some_text", 
project.EvaluatedProperties ["PropertyName"].FinalValue, "A1");
+               }
+
+               // FIXME: edit
+               public void TestPublish1 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <UsingTask
+                                               
AssemblyFile='Test\resources\TestTasks.dll'
+                                               TaskName='OutputTestTask'
+                                       />
+                                       <Target Name='T'>
+                                               <OutputTestTask />
+                                       </Target>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       Target [] t = new Target [1];
+                       BuildTask [] bt;
+                       project.Targets.CopyTo (t, 0);
+                       bt = GetTasks (t [0]);
                        bt [0].AddOutputProperty ("Property", "PropertyName");
                        project.Build ("T");
 

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ChangeLog
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ChangeLog
   2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ChangeLog
   2007-01-02 11:05:36 UTC (rev 70340)
@@ -1,3 +1,9 @@
+2007-01-02  Marek Sieradzki  <[EMAIL PROTECTED]>
+
+       * BuildItemTest.cs: Tests for items from XML.
+       * BuildPropertyGroupTest.cs, BuildTaskTest.cs, BuildItemGroupTest.cs,
+       BuildPropertyTest.cs, ProjectTest.cs: More tests.
+
 2006-12-20  Marek Sieradzki  <[EMAIL PROTECTED]>
 
        * BuildItemGroupTest.cs: Enabled TestAddNewItem2 ().

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ProjectTest.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ProjectTest.cs
      2007-01-02 10:52:37 UTC (rev 70339)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ProjectTest.cs
      2007-01-02 11:05:36 UTC (rev 70340)
@@ -297,6 +297,73 @@
                }
 
                [Test]
+               public void TestEvaluatedItems1 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a' />
+                                               <B Include='b' 
Condition='false' />
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       Assert.AreEqual (1, project.EvaluatedItems.Count, "A1");
+
+                       BuildItem bi = project.EvaluatedItems [0];
+
+                       bi.Name = "C";
+                       bi.Include = "c";
+
+                       BuildItemGroup [] big = new BuildItemGroup [1];
+                       project.ItemGroups.CopyTo (big, 0);
+                       Assert.AreEqual ("C", big [0] [0].Name, "A2");
+                       Assert.AreEqual ("c", big [0] [0].Include, "A3");
+               }
+
+               [Test]
+               public void TestEvaluatedItems2 ()
+               {
+                       Engine engine;
+                       Project project;
+
+                       string documentString = @"
+                               <Project 
xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
+                                       <ItemGroup>
+                                               <A Include='a;b;c' />
+                                       </ItemGroup>
+                               </Project>
+                       ";
+
+                       engine = new Engine (Consts.BinPath);
+                       project = engine.CreateNewProject ();
+                       project.LoadXml (documentString);
+
+                       BuildItemGroup [] big = new BuildItemGroup [1];
+                       project.ItemGroups.CopyTo (big, 0);
+
+                       Assert.AreEqual (3, project.EvaluatedItems.Count, "A1");
+                       Assert.AreEqual ("a;b;c", big [0] [0].Include, "A2");
+                       Assert.AreEqual (1, big [0].Count, "A3");
+
+                       BuildItem bi = project.EvaluatedItems [0];
+
+                       bi.Include = "d";
+
+                       Assert.AreEqual (3, big [0].Count, "A4");
+                       Assert.AreEqual ("d", big [0] [0].Include, "A5");
+                       Assert.AreEqual ("b", big [0] [1].Include, "A6");
+                       Assert.AreEqual ("c", big [0] [2].Include, "A7");
+               }
+
+               [Test]
                [Category ("NotWorking")]
                public void TestGetConditionedPropertyValues ()
                {

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to